bump

Support Feathercoin

.dockerignore

@@ -121,3 +121,4 @@ bower_components
 output
 
 .vs
+**/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

.gitignore

@@ -287,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,15 +1,16 @@
-<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>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0-preview-20170720-02" />
-    <PackageReference Include="xunit" Version="2.2.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.7.2" />
+    <PackageReference Include="xunit" Version="2.3.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />
   </ItemGroup>
 
   <ItemGroup>

BTCPayServer.Tests/BTCPayServerTester.cs

@@ -1,7 +1,12 @@
 using BTCPayServer.Configuration;
 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;
@@ -30,117 +35,166 @@ using Xunit;
 
 namespace BTCPayServer.Tests
 {
-	public class BTCPayServerTester : IDisposable
-	{
-		private string _Directory;
+    public class BTCPayServerTester : IDisposable
+    {
+        private string _Directory;
 
-		public BTCPayServerTester(string scope)
-		{
-			this._Directory = scope ?? throw new ArgumentNullException(nameof(scope));
-		}
+        public BTCPayServerTester(string scope)
+        {
+            this._Directory = scope ?? throw new ArgumentNullException(nameof(scope));
+        }
 
-		public Uri NBXplorerUri
-		{
-			get; set;
-		}
-		public string CookieFile
-		{
-			get; set;
-		}
-		public Uri ServerUri
-		{
-			get;
-			set;
-		}
+        public Uri NBXplorerUri
+        {
+            get; set;
+        }
 
-		public ExtKey HDPrivateKey
-		{
-			get; set;
-		}
+        public Uri LTCNBXplorerUri { get; set; }
 
-		public string Postgres
-		{
-			get; set;
-		}
+        public Uri ServerUri
+        {
+            get;
+            set;
+        }
 
-		IWebHost _Host;
-		public void Start()
-		{
-			if(!Directory.Exists(_Directory))
-				Directory.CreateDirectory(_Directory);
+        public string Postgres
+        {
+            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)}");
-			if(Postgres != null)
-				config.AppendLine($"postgres=" + Postgres);
-			File.WriteAllText(Path.Combine(_Directory, "settings.config"), config.ToString());
+        IWebHost _Host;
+        public int Port
+        {
+            get; set;
+        }
 
-			ServerUri = new Uri("http://127.0.0.1:" + port + "/");
 
-			var conf = new DefaultConfiguration() { Logger = Logs.LogProvider.CreateLogger("Console") }.CreateConfiguration(new[] { "--datadir", _Directory });
+        public bool MockRates { get; set; } = true;
 
-			_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);
-		}
+        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);
 
-		public BTCPayServerRuntime Runtime
-		{
-			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;
+            StringBuilder config = new StringBuilder();
+            config.AppendLine($"{chain.ToLowerInvariant()}=1");
+            config.AppendLine($"port={Port}");
+            config.AppendLine($"chains=btc,ltc");
 
-			var httpAccessor = provider.GetRequiredService<IHttpContextAccessor>();
-			httpAccessor.HttpContext = context;
+            config.AppendLine($"btc.explorer.url={NBXplorerUri.AbsoluteUri}");
+            config.AppendLine($"btc.explorer.cookiefile=0");
 
-			var controller = (T)ActivatorUtilities.CreateInstance(provider, typeof(T));
-			controller.Url = new UrlHelperMock();
-			controller.ControllerContext = new ControllerContext()
-			{
-				HttpContext = context
-			};
-			return controller;
-		}
+            config.AppendLine($"ltc.explorer.url={LTCNBXplorerUri.AbsoluteUri}");
+            config.AppendLine($"ltc.explorer.cookiefile=0");
 
-		public void Dispose()
-		{
-			if(_Host != null)
-				_Host.Dispose();
-		}
-	}
+            config.AppendLine($"btc.lightning={IntegratedLightning.AbsoluteUri}");
+
+            if (Postgres != null)
+                config.AppendLine($"postgres=" + Postgres);
+            var confPath = Path.Combine(chainDirectory, "settings.config");
+            File.WriteAllText(confPath, config.ToString());
+
+            ServerUri = new Uri("http://" + HostName + ":" + Port + "/");
+
+            Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development");
+            var conf = new DefaultConfiguration() { Logger = Logs.LogProvider.CreateLogger("Console") }.CreateConfiguration(new[] { "--datadir", _Directory, "--conf", confPath });
+            _Host = new WebHostBuilder()
+                    .UseConfiguration(conf)
+                    .ConfigureServices(s =>
+                    {
+                        s.AddLogging(l =>
+                        {
+                            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));
+
+            var rateProvider = (BTCPayRateProviderFactory)_Host.Services.GetService(typeof(BTCPayRateProviderFactory));
+            rateProvider.DirectProviders.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_USD"),
+                BidAsk = new BidAsk(500m)
+            });
+            rateProvider.DirectProviders.Add("coinaverage", coinAverageMock);
+        }
+
+        public string HostName
+        {
+            get;
+            internal set;
+        }
+        public InvoiceRepository InvoiceRepository { 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) 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) }, 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/ChargeTester.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using BTCPayServer.Payments.Lightning.Charge;
+using BTCPayServer.Payments.Lightning.CLightning;
+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 = new ChargeClient(new Uri(url), network);
+            P2PHost = _Parent.GetEnvironment(environmentName + "_HOST", defaultHost);
+        }        
+        public ChargeClient Client { get; set; }
+        public string P2PHost { get; }
+    }
+}

BTCPayServer.Tests/CustomerHttpServer.cs

@@ -11,65 +11,65 @@ using Microsoft.AspNetCore.Hosting.Server.Features;
 
 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
+    {
+        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 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");
-			}
-		}
+        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 void Dispose()
-		{
-			_Closed.Cancel();
-			_Host.Dispose();
-		}
-	}
+        public void Dispose()
+        {
+            _Closed.Cancel();
+            _Host.Dispose();
+        }
+    }
 }

BTCPayServer.Tests/Dockerfile

@@ -1,4 +1,4 @@
-FROM microsoft/dotnet:2.0.0-sdk
+FROM microsoft/dotnet:2.1.300-sdk-alpine3.7
 WORKDIR /app
  # caches restore result by copying csproj file separately
 COPY BTCPayServer.Tests/BTCPayServer.Tests.csproj BTCPayServer.Tests/BTCPayServer.Tests.csproj
@@ -9,4 +9,4 @@ RUN dotnet restore
 # copies the rest of your code
 COPY . ../.
 
-ENTRYPOINT ["dotnet", "test"]
+ENTRYPOINT ["dotnet", "test"]

BTCPayServer.Tests/LightningDTester.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using BTCPayServer.Payments.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 CLightningRPCClient(new Uri(parent.GetEnvironment(environmentName, defaultRPC)), network);
+        }
+
+        public CLightningRPCClient RPC { get; }
+        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/Mocks/MockRateProvider.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+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()
+        {
+            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/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

@@ -1,10 +1,14 @@
-# How to run the tests
+# How to be started for development
 
-The tests depends on having a proper environment running with Postgres, Bitcoind, NBxplorer configured.
+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 nbxplorer
+docker-compose up dev
 ```
 
 You can run the tests while it is running through your favorite IDE, or with
@@ -19,14 +23,62 @@ 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 the tests inside a container by running
 
 ```
 docker-compose run --rm tests
 ```
 
-The Bitcoin RPC server is exposed to the host, for example, you can send 0.23111090 BTC to mohu16LH66ptoWGEL1GtP6KHTBJYXMWhEf.
+## 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:
+```
+.\docker-bitcoin-cli.ps1 sendtoaddress "mohu16LH66ptoWGEL1GtP6KHTBJYXMWhEf" 0.23111090
+```
+
+### 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:
 
 ```
-bitcoin-cli -regtest -rpcport=43782 -rpcuser=ceiwHEbqWI83 -rpcpassword=DwubwWsoo3 sendtoaddress "mohu16LH66ptoWGEL1GtP6KHTBJYXMWhEf" 0.23111090
-```
+{ "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,179 @@
+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]
+        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.GlobalMultiplier = 2.32m;
+            Assert.Equal("(bittrex(DOGE_BTC) * gdax(BTC_USD) * 1.1) * 2.32", 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.Value, 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.GlobalMultiplier = 1.1m;
+
+            rule2 = rules.GetRuleFor(CurrencyPair.Parse("DOGE_USD"));
+            Assert.Equal("(2000 * (-3 + coinbase(BTC_CAD) + 50 - 5)) * 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)) * 1.1", rule2.ToString(true));
+            Assert.Equal((2000m * (-3m + 1000m + 50m - 5m)) * 1.1m, rule2.Value.Value);
+
+            // Test inverse
+            rule2 = rules.GetRuleFor(CurrencyPair.Parse("USD_DOGE"));
+            Assert.Equal("(1 / (2000 * (-3 + coinbase(BTC_CAD) + 50 - 5))) * 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))) * 1.1", rule2.ToString(true));
+            Assert.Equal((1.0m / (2000m * (-3m + 1000m + 50m - 5m))) * 1.1m, rule2.Value.Value);
+            ////////
+
+            // 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.Value.Value);
+            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.Value.Value);
+
+            // 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,88 +1,199 @@
 using BTCPayServer.Controllers;
+using System.Linq;
 using BTCPayServer.Models.AccountViewModels;
+using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using NBitcoin;
 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.Payments.Lightning.CLightning;
+using BTCPayServer.Payments.Lightning.Charge;
 
 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;
-		public ServerTester(string scope)
-		{
-			_Directory = scope;
-		}
+        string _Directory;
+        public ServerTester(string scope)
+        {
+            _Directory = scope;
+            if (Directory.Exists(_Directory))
+                Utils.DeleteDirectory(_Directory);
+            if (!Directory.Exists(_Directory))
+                Directory.CreateDirectory(_Directory);
 
-		public void Start()
-		{
-			if(Directory.Exists(_Directory))
-				Utils.DeleteDirectory(_Directory);
-			if(!Directory.Exists(_Directory))
-				Directory.CreateDirectory(_Directory);
+            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);
+            LTCExplorerNode = new RPCClient(RPCCredentialString.Parse(GetEnvironment("TESTS_LTCRPCCONNECTION", "server=http://127.0.0.1:43783;ceiwHEbqWI83:DwubwWsoo3")), NetworkProvider.GetNetwork("LTC").NBitcoinNetwork);
 
-			ExplorerNode = new RPCClient(RPCCredentialString.Parse(GetEnvironment("TESTS_RPCCONNECTION", "server=http://127.0.0.1:43782;ceiwHEbqWI83:DwubwWsoo3")), Network);
-			ExplorerClient = new ExplorerClient(Network, new Uri(GetEnvironment("TESTS_NBXPLORERURL", "http://127.0.0.1:32838/")));
-			PayTester = new BTCPayServerTester(Path.Combine(_Directory, "pay"))
-			{
-				NBXplorerUri = ExplorerClient.Address,
-				Postgres = GetEnvironment("TESTS_POSTGRES", "User ID=postgres;Host=127.0.0.1;Port=39372;Database=btcpayserver")
-			};
-			PayTester.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/")));
 
-		private string GetEnvironment(string variable, string defaultValue)
-		{
-			var var = Environment.GetEnvironmentVariable(variable);
-			return String.IsNullOrEmpty(var) ? defaultValue : var;
-		}
+            var btc = NetworkProvider.GetNetwork("BTC").NBitcoinNetwork;
+            CustomerLightningD = new CLightningRPCClient(new Uri(GetEnvironment("TEST_CUSTOMERLIGHTNINGD", "tcp://127.0.0.1:30992/")), btc);
+            MerchantLightningD = new CLightningRPCClient(new Uri(GetEnvironment("TEST_MERCHANTLIGHTNINGD", "tcp://127.0.0.1:30993/")), btc);
 
-		public TestAccount NewAccount()
-		{
-			return new TestAccount(this);
-		}
+            MerchantCharge = new ChargeTester(this, "TEST_MERCHANTCHARGE", "http://api-token:foiewnccewuify@127.0.0.1:54938/", "merchant_lightningd", btc);
 
-		public RPCClient ExplorerNode
-		{
-			get; set;
-		}
+            PayTester = new BTCPayServerTester(Path.Combine(_Directory, "pay"))
+            {
+                NBXplorerUri = ExplorerClient.Address,
+                LTCNBXplorerUri = LTCExplorerClient.Address,
+                Postgres = GetEnvironment("TESTS_POSTGRES", "User ID=postgres;Host=127.0.0.1;Port=39372;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 ExplorerClient ExplorerClient
-		{
-			get; set;
-		}
+        public bool Dockerized
+        {
+            get; set;
+        }
 
-		
+        public void Start()
+        {
+            PayTester.Start();
+        }
 
-		public BTCPayServerTester PayTester
-		{
-			get; set;
-		}
-		
-		public Network Network
-		{
-			get;
-			set;
-		} = Network.RegTest;
 
-		public void Dispose()
-		{
-			if(PayTester != null)
-				PayTester.Dispose();
-		}
-	}
+        /// <summary>
+        /// Connect a customer LN node to the merchant LN node
+        /// </summary>
+        public void PrepareLightning()
+        {
+            PrepareLightningAsync().GetAwaiter().GetResult();
+        }
+
+
+        /// <summary>
+        /// Connect a customer LN node to the merchant LN node
+        /// </summary>
+        /// <returns></returns>
+        public async Task PrepareLightningAsync()
+        {
+            while (true)
+            {
+                var skippedStates = new[] { "ONCHAIN", "CHANNELD_SHUTTING_DOWN", "CLOSINGD_SIGEXCHANGE", "CLOSINGD_COMPLETE", "FUNDING_SPEND_SEEN" };
+                var channel = (await CustomerLightningD.ListPeersAsync())
+                            .SelectMany(p => p.Channels)
+                            .Where(c => !skippedStates.Contains(c.State ?? ""))
+                            .FirstOrDefault();
+                switch (channel?.State)
+                {
+                    case null:
+                        var merchantInfo = await WaitLNSynched();
+                        var clightning = new NodeInfo(merchantInfo.Id, MerchantCharge.P2PHost, merchantInfo.Port);
+                        await CustomerLightningD.ConnectAsync(clightning);
+                        var address = await CustomerLightningD.NewAddressAsync();
+                        await ExplorerNode.SendToAddressAsync(address, Money.Coins(0.2m));
+                        ExplorerNode.Generate(1);
+                        await WaitLNSynched();
+                        await Task.Delay(1000);
+                        await CustomerLightningD.FundChannelAsync(clightning, Money.Satoshis(16777215));
+                        break;
+                    case "CHANNELD_AWAITING_LOCKIN":
+                        ExplorerNode.Generate(1);
+                        await WaitLNSynched();
+                        break;
+                    case "CHANNELD_NORMAL":
+                        return;
+                    default:
+                        throw new NotSupportedException(channel?.State ?? "");
+                }
+            }
+        }
+
+        private async Task<GetInfoResponse> WaitLNSynched()
+        {
+            while (true)
+            {
+                var merchantInfo = await MerchantCharge.Client.GetInfoAsync();
+                var blockCount = await ExplorerNode.GetBlockCountAsync();
+                if (merchantInfo.BlockHeight != blockCount)
+                {
+                    await Task.Delay(1000);
+                }
+                else
+                {
+                    return merchantInfo;
+                }
+            }
+        }
+
+        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.SendAsync(bolt11);
+        }
+
+        public CLightningRPCClient CustomerLightningD { get; set; }
+        public CLightningRPCClient MerchantLightningD { get; private set; }
+        public ChargeTester MerchantCharge { get; private 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 void Dispose()
+        {
+            if (PayTester != null)
+                PayTester.Dispose();
+        }
+    }
 }

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,83 +11,130 @@ using System.Collections.Generic;
 using System.Text;
 using System.Threading.Tasks;
 using Xunit;
+using NBXplorer.DerivationStrategy;
+using BTCPayServer.Payments;
+using BTCPayServer.Payments.Lightning;
 
 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 void GrantAccess()
+        {
+            GrantAccessAsync().GetAwaiter().GetResult();
+        }
 
-		public void Register()
-		{
-			RegisterAsync().GetAwaiter().GetResult();
-		}
+        public void Register()
+        {
+            RegisterAsync().GetAwaiter().GetResult();
+        }
 
-		public BitcoinExtKey ExtKey
-		{
-			get; set;
-		}
+        public BitcoinExtKey ExtKey
+        {
+            get; set;
+        }
 
-		public async Task GrantAccessAsync()
-		{
-			await RegisterAsync();
-			var store = await CreateStoreAsync();
-			var pairingCode = BitPay.RequestClientAuthorization("test", Facade.Merchant);
-			Assert.IsType<ViewResult>(await store.RequestPairing(pairingCode.ToString()));
-			await store.Pair(pairingCode.ToString(), StoreId);
-		}
-		public StoresController CreateStore()
-		{
-			return CreateStoreAsync().GetAwaiter().GetResult();
-		}
-		public async Task<StoresController> CreateStoreAsync()
-		{
-			ExtKey = new ExtKey().GetWif(parent.Network);
-			var store = parent.PayTester.GetController<StoresController>(UserId);
-			await store.CreateStore(new CreateStoreViewModel() { Name = "Test Store" });
-			StoreId = store.CreatedStoreId;
-			await store.UpdateStore(StoreId, new StoreViewModel()
-			{
-				DerivationScheme = ExtKey.Neuter().ToString() + "-[legacy]",
-				SpeedPolicy = SpeedPolicy.MediumSpeed
-			}, "Save");
-			return store;
-		}
+        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();
+        }
 
-		private async Task RegisterAsync()
-		{
-			var account = parent.PayTester.GetController<AccountController>();
-			await account.Register(new RegisterViewModel()
-			{
-				Email = Guid.NewGuid() + "@toto.com",
-				ConfirmPassword = "Kitten0@",
-				Password = "Kitten0@",
-			});
-			UserId = account.RegisteredUserId;
-		}
+        public T GetController<T>(bool setImplicitStore = true) where T : Controller
+        {
+            return parent.PayTester.GetController<T>(UserId, setImplicitStore ? StoreId : null);
+        }
 
-		public Bitpay BitPay
-		{
-			get; set;
-		}
-		public string UserId
-		{
-			get; set;
-		}
+        public async Task CreateStoreAsync()
+        {
+            var store = this.GetController<UserStoresController>();
+            await store.CreateStore(new CreateStoreViewModel() { Name = "Test Store" });
+            StoreId = store.CreatedStoreId;
+        }
 
-		public string StoreId
-		{
-			get; set;
-		}
-	}
+        public BTCPayNetwork SupportedNetwork { get; set; }
+
+        public void RegisterDerivationScheme(string crytoCode)
+        {
+            RegisterDerivationSchemeAsync(crytoCode).GetAwaiter().GetResult();
+        }
+        public async Task RegisterDerivationSchemeAsync(string cryptoCode)
+        {
+            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() + "-[legacy]");
+            var vm = (StoreViewModel)((ViewResult)store.UpdateStore()).Model;
+            vm.SpeedPolicy = SpeedPolicy.MediumSpeed;
+            await store.UpdateStore(vm);
+
+            await store.AddDerivationScheme(StoreId, new DerivationSchemeViewModel()
+            {
+                DerivationScheme = DerivationScheme.ToString(),
+                Confirmation = true
+            }, cryptoCode);
+        }
+
+        public DerivationStrategyBase DerivationScheme { get; set; }
+
+        private async Task RegisterAsync()
+        {
+            var account = parent.PayTester.GetController<AccountController>();
+            await account.Register(new RegisterViewModel()
+            {
+                Email = Guid.NewGuid() + "@toto.com",
+                ConfirmPassword = "Kitten0@",
+                Password = "Kitten0@",
+            });
+            UserId = account.RegisteredUserId;
+        }
+
+        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>();
+            await storeController.AddLightningNode(StoreId, new LightningNodeViewModel()
+            {
+                Url = connectionType == LightningConnectionType.Charge ? parent.MerchantCharge.Client.Uri.AbsoluteUri :
+                      connectionType == LightningConnectionType.CLightning ? parent.MerchantLightningD.Address.AbsoluteUri
+                      : throw new NotSupportedException(connectionType.ToString()),
+                SkipPortTest = true
+            }, "save", "BTC");
+            if (storeController.ModelState.ErrorCount != 0)
+                Assert.False(true, storeController.ModelState.FirstOrDefault().Value.Errors[0].ErrorMessage);
+        }
+}
 }

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 @@
+docker exec -ti btcpayservertests_bitcoind_1 bitcoin-cli -datadir="/data" $args

BTCPayServer.Tests/docker-bitcoin-cli.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+docker exec -ti btcpayservertests_bitcoind_1 bitcoin-cli -datadir="/data" "$@"

BTCPayServer.Tests/docker-compose.yml

@@ -1,5 +1,8 @@
-version: "3"
+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:
@@ -7,44 +10,175 @@ services:
       context: ..
       dockerfile: BTCPayServer.Tests/Dockerfile
     environment:
-      TESTS_RPCCONNECTION: server=http://bitcoind:43782;ceiwHEbqWI83:DwubwWsoo3
-      TESTS_NBXPLORERURL: http://nbxplorer:32838/
+      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_POSTGRES: User ID=postgres;Host=postgres;Port=5432;Database=btcpayserver
+      TESTS_PORT: 80
+      TESTS_HOSTNAME: tests
+      TEST_MERCHANTLIGHTNINGD: "/etc/merchant_lightningd_datadir/lightning-rpc"
+      TEST_CUSTOMERLIGHTNINGD: "/etc/customer_lightningd_datadir/lightning-rpc"
+      TEST_MERCHANTCHARGE: http://api-token:foiewnccewuify@lightning-charged:9112/
+      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: nicolasdorier/docker-bitcoin:0.16.0
+    environment:
+      BITCOIN_EXTRA_ARGS: |
+        regtest=1
+        connect=bitcoind:39388
     links:
       - nbxplorer
+      - postgres
+      - customer_lightningd
+      - merchant_lightningd
+      - lightning-charged
 
   nbxplorer:
-    image: nicolasdorier/nbxplorer:1.0.0.16
+    image: nicolasdorier/nbxplorer:1.0.2.8
     ports:
       - "32838:32838"
     expose: 
       - "32838"
     environment:
       NBXPLORER_NETWORK: regtest
-      NBXPLORER_RPCURL: http://bitcoind:43782/
-      NBXPLORER_RPCUSER: ceiwHEbqWI83
-      NBXPLORER_RPCPASSWORD: DwubwWsoo3
-      NBXPLORER_NODEENDPOINT: bitcoind:39388
+      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
-      - postgres
+      - litecoind
 
   bitcoind:
-    image: nicolasdorier/docker-bitcoin:0.15.0.1
-    ports:
-      - "43782:43782"
-      - "39388:39388"
+    image: nicolasdorier/docker-bitcoin:0.16.0
     environment:
-      BITCOIN_EXTRA_ARGS: "regtest=1\nrpcport=43782\nport=39388\nwhitelist=0.0.0.0/0"
-      BITCOIN_RPC_USER: ceiwHEbqWI83
-      BITCOIN_RPC_PASSWORD: DwubwWsoo3
+      BITCOIN_EXTRA_ARGS: |
+        rpcuser=ceiwHEbqWI83
+        rpcpassword=DwubwWsoo3
+        regtest=1
+        server=1
+        rpcport=43782
+        port=39388
+        whitelist=0.0.0.0/0
+    ports: 
+      - "43782:43782"
     expose:
-      - "43782"
-      - "39388"
+      - "43782" # RPC
+      - "39388" # P2P
+    volumes:
+      - "bitcoin_datadir:/data"
+
+  customer_lightningd:
+    image: nicolasdorier/clightning:0.0.0.20-dev
+    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
+    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.3.12
+    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: nicolasdorier/clightning:0.0.0.20-dev
+    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:
+    image: nicolasdorier/docker-litecoin:0.15.1
+    environment:
+      BITCOIN_EXTRA_ARGS: |
+        rpcuser=ceiwHEbqWI83
+        rpcpassword=DwubwWsoo3
+        regtest=1
+        server=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"
+      - "39372:5432"
+    expose:
+      - "5432"
+
+volumes:
+    bitcoin_datadir:
+    customer_lightningd_datadir:
+    merchant_lightningd_datadir:
+    lightning_charge_datadir:

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

@@ -0,0 +1 @@
+docker exec -ti btcpayservertests_customer_lightningd_1 lightning-cli $args

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

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+docker exec -ti btcpayservertests_customer_lightningd_1 lightning-cli "$@"

BTCPayServer.Tests/docker-litecoin-cli.ps1

@@ -0,0 +1 @@
+docker exec -ti btcpayservertests_litecoind_1 litecoin-cli -datadir="/data" $args

BTCPayServer.Tests/docker-litecoin-cli.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+docker exec -ti btcpayservertests_litecoind_1 litecoin-cli -datadir="/data" "$@"

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

@@ -0,0 +1 @@
+docker exec -ti btcpayservertests_merchant_lightningd_1 lightning-cli $args

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

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+docker exec -ti btcpayservertests_merchant_lightningd_1 lightning-cli "$@"

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,43 +8,43 @@ namespace BTCPayServer.Authentication
 {
     public class BitTokenEntity
     {
-		public string Facade
-		{
-			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 string Facade
+        {
+            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()
-			{
-				Label = Label,
-				Facade = Facade,
-				StoreId = StoreId,
-				PairingTime = PairingTime,
-				SIN = SIN,
-				Value = Value
-			};
-		}
-	}
+        public BitTokenEntity Clone(Facade facade)
+        {
+            return new BitTokenEntity()
+            {
+                Label = Label,
+                Facade = Facade,
+                StoreId = StoreId,
+                PairingTime = PairingTime,
+                SIN = SIN,
+                Value = Value
+            };
+        }
+    }
 }

BTCPayServer/Authentication/PairingCodeEntity.cs

@@ -4,47 +4,47 @@ 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 CreatedTime
-		{
-			get;
-			set;
-		}
-		public DateTimeOffset Expiration
-		{
-			get;
-			set;
-		}
-		public string TokenValue
-		{
-			get;
-			set;
-		}
+    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 CreatedTime
+        {
+            get;
+            set;
+        }
+        public DateTimeOffset Expiration
+        {
+            get;
+            set;
+        }
+        public string TokenValue
+        {
+            get;
+            set;
+        }
 
-		public bool IsExpired()
-		{
-			return DateTimeOffset.UtcNow > Expiration;
-		}
-	}
+        public bool IsExpired()
+        {
+            return DateTimeOffset.UtcNow > Expiration;
+        }
+    }
 }

BTCPayServer/Authentication/TokenRepository.cs

@@ -13,173 +13,238 @@ using System.Linq;
 
 namespace BTCPayServer.Authentication
 {
-	public class TokenRepository
-	{
-		ApplicationDbContextFactory _Factory;
-		public TokenRepository(ApplicationDbContextFactory dbFactory)
-		{
-			if(dbFactory == null)
-				throw new ArgumentNullException(nameof(dbFactory));
-			_Factory = dbFactory;
-		}
+    public enum PairingResult
+    {
+        Partial,
+        Complete,
+        ReusedKey,
+        Expired
+    }
 
-		public async Task<BitTokenEntity[]> GetTokens(string sin)
-		{
-			using(var ctx = _Factory.CreateContext())
-			{
-				return (await ctx.PairedSINData
-					.Where(p => p.SIN == sin)
-					.ToListAsync())
-					.Select(p => CreateTokenEntity(p))
-					.ToArray();
-			}
-		}
+    public class TokenRepository
+    {
+        ApplicationDbContextFactory _Factory;
+        public TokenRepository(ApplicationDbContextFactory dbFactory)
+        {
+            if (dbFactory == null)
+                throw new ArgumentNullException(nameof(dbFactory));
+            _Factory = dbFactory;
+        }
 
-		private BitTokenEntity CreateTokenEntity(PairedSINData data)
-		{
-			return new BitTokenEntity()
-			{
-				Label = data.Label,
-				Facade = data.Facade,
-				Value = data.Id,
-				SIN = data.SIN,
-				PairingTime = data.PairingTime,
-				StoreId = data.StoreDataId
-			};
-		}
+        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> CreatePairingCodeAsync()
-		{
-			string pairingCodeId = Encoders.Base58.EncodeData(RandomUtils.GetBytes(6));
-			using(var ctx = _Factory.CreateContext())
-			{
-				var now = DateTime.UtcNow;
-				var expiration = DateTime.UtcNow + TimeSpan.FromMinutes(15);
-				await ctx.PairingCodes.AddAsync(new PairingCodeData()
-				{
-					Id = pairingCodeId,
-					DateCreated = now,
-					Expiration = expiration,
-					TokenValue = Encoders.Base58.EncodeData(RandomUtils.GetBytes(32))
-				});
-				await ctx.SaveChangesAsync();
-			}
-			return pairingCodeId;
-		}
+        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<PairingCodeEntity> UpdatePairingCode(PairingCodeEntity pairingCodeEntity)
-		{
-			using(var ctx = _Factory.CreateContext())
-			{
-				var pairingCode = await ctx.PairingCodes.FindAsync(pairingCodeEntity.Id);
-				pairingCode.Label = pairingCodeEntity.Label;
-				pairingCode.Facade = pairingCodeEntity.Facade;
-				await ctx.SaveChangesAsync();
-				return CreatePairingCodeEntity(pairingCode);
-			}
-		}
+        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)];
+            }
 
-		public async Task<bool> 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 false;
-				pairingCode.StoreDataId = storeId;
-				await ActivateIfComplete(ctx, pairingCode);
-				await ctx.SaveChangesAsync();
-			}
-			return true;
-		}
+            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<bool> 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 false;
-				pairingCode.SIN = sin;
-				await ActivateIfComplete(ctx, pairingCode);
-				await ctx.SaveChangesAsync();
-			}
-			return true;
-		}
+        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,
+                Facade = data.Facade,
+                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;
+                pairingCode.Facade = pairingCodeEntity.Facade;
+                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 async Task ActivateIfComplete(ApplicationDbContext ctx, PairingCodeData pairingCode)
-		{
-			if(!string.IsNullOrEmpty(pairingCode.SIN) && !string.IsNullOrEmpty(pairingCode.StoreDataId))
-			{
-				ctx.PairingCodes.Remove(pairingCode);
-				await ctx.PairedSINData.AddAsync(new PairedSINData()
-				{
-					Id = pairingCode.TokenValue,
-					PairingTime = DateTime.UtcNow,
-					Facade = pairingCode.Facade,
-					Label = pairingCode.Label,
-					StoreDataId = pairingCode.StoreDataId,
-					SIN = pairingCode.SIN
-				});
-			}
-		}
+        private async Task<PairingResult> ActivateIfComplete(ApplicationDbContext ctx, PairingCodeData pairingCode)
+        {
+            if (!string.IsNullOrEmpty(pairingCode.SIN) && !string.IsNullOrEmpty(pairingCode.StoreDataId))
+            {
+                ctx.PairingCodes.Remove(pairingCode);
+
+                // 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,
+                    Facade = pairingCode.Facade,
+                    Label = pairingCode.Label,
+                    StoreDataId = pairingCode.StoreDataId,
+                    SIN = pairingCode.SIN
+                });
+                return PairingResult.Complete;
+            }
+            return PairingResult.Partial;
+        }
 
 
-		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();
-			}
-		}
+        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();
+            }
+        }
 
-		public async Task<PairingCodeEntity> GetPairingAsync(string pairingCode)
-		{
-			using(var ctx = _Factory.CreateContext())
-			{
-				return CreatePairingCodeEntity(await ctx.PairingCodes.FindAsync(pairingCode));
-			}
-		}
+        public async Task<PairingCodeEntity> GetPairingAsync(string pairingCode)
+        {
+            using (var ctx = _Factory.CreateContext())
+            {
+                return CreatePairingCodeEntity(await ctx.PairingCodes.FindAsync(pairingCode));
+            }
+        }
 
-		private PairingCodeEntity CreatePairingCodeEntity(PairingCodeData data)
-		{
-			return new PairingCodeEntity()
-			{
-				Facade = data.Facade,
-				Id = data.Id,
-				Label = data.Label,
-				Expiration = data.Expiration,
-				CreatedTime = data.DateCreated,
-				TokenValue = data.TokenValue,
-				SIN = data.SIN
-			};
-		}
+        private PairingCodeEntity CreatePairingCodeEntity(PairingCodeData data)
+        {
+            if (data == null)
+                return null;
+            return new PairingCodeEntity()
+            {
+                Facade = data.Facade,
+                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<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);
-				return CreateTokenEntity(token);
-			}
-		}
+        public async Task<BitTokenEntity> GetToken(string tokenId)
+        {
+            using (var ctx = _Factory.CreateContext())
+            {
+                var token = await ctx.PairedSINData.FindAsync(tokenId);
+                return CreateTokenEntity(token);
+            }
+        }
 
-	}
+    }
 }

BTCPayServer/BTCPayNetwork.cs

@@ -0,0 +1,77 @@
+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; }
+
+        [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 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,31 @@
+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,
+                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-symbol.svg",
+                LightningImagePath = "imlegacy/btc-lightning.svg",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("0'") : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer/BTCPayNetworkProvider.BitcoinGold.cs

@@ -0,0 +1,29 @@
+using NBitcoin;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitBitcoinGold()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("BTG");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                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-symbol.svg",
+                LightningImagePath = "imlegacy/btg-symbol.svg",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("156'") : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer/BTCPayNetworkProvider.Dogecoin.cs

@@ -0,0 +1,34 @@
+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,
+                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'")
+            });
+        }
+    }
+}

BTCPayServer/BTCPayNetworkProvider.Feathercoin.cs

@@ -0,0 +1,34 @@
+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,
+                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.Litecoin.cs

@@ -0,0 +1,30 @@
+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,
+                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-symbol.svg",
+                LightningImagePath = "imlegacy/ltc-lightning.svg",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("2'") : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer/BTCPayNetworkProvider.Monacoin.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 InitMonacoin()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("MONA");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                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 = zaif(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,34 @@
+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,
+                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.cs

@@ -0,0 +1,101 @@
+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();
+            InitDogecoin();
+            InitBitcoinGold();
+            InitMonacoin();
+            InitPolis();
+            InitFeathercoin();
+        }
+
+        /// <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,14 +1,27 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
+<Project Sdk="Microsoft.NET.Sdk.Web">
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp2.0</TargetFramework>
-		<Version>1.0.0.7</Version>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
+		<Version>1.0.2.32</Version>
+    <NoWarn>NU1701,CA1816,CA1308,CA1810,CA2208</NoWarn>
   </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" />
@@ -17,43 +30,41 @@
     <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="BuildBundlerMinifier" Version="2.7.385" />
+    <PackageReference Include="DigitalRuby.ExchangeSharp" Version="0.4.1" />
+    <PackageReference Include="Hangfire" Version="1.6.19" />
+    <PackageReference Include="Hangfire.MemoryStorage" Version="1.5.2" />
+    <PackageReference Include="Hangfire.PostgreSql" Version="1.4.8.2" />
+    <PackageReference Include="LedgerWallet" Version="1.0.1.36" />
+    <PackageReference Include="Meziantou.AspNetCore.BundleTagHelpers" Version="2.0.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.0" />
     <PackageReference Include="Microsoft.Extensions.Logging.Filter" Version="1.1.2" />
-    <PackageReference Include="NBitcoin" Version="4.0.0.38" />
-    <PackageReference Include="NBitpayClient" Version="1.0.0.10" />	  
+    <PackageReference Include="Microsoft.NetCore.Analyzers" Version="2.6.0" />
+    <PackageReference Include="NBitcoin" Version="4.1.1.10" />
+    <PackageReference Include="NBitpayClient" Version="1.0.0.27" />	  
     <PackageReference Include="DBreeze" Version="1.87.0" />
-    <PackageReference Include="NBXplorer.Client" Version="1.0.0.16" />
-    <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="NBXplorer.Client" Version="1.0.2.10" />
+    <PackageReference Include="NicolasDorier.CommandLine" Version="1.0.0.2" />
+    <PackageReference Include="NicolasDorier.CommandLine.Configuration" Version="1.0.0.3" />
+    <PackageReference Include="NicolasDorier.StandardConfiguration" Version="1.0.0.14" />
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="2.1.0" />
+    <PackageReference Include="System.Xml.XmlSerializer" Version="4.3.0" />
+    <PackageReference Include="Text.Analyzers" Version="2.6.0" />
   </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.0" />
+		<PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version=" 2.1.0" PrivateAssets="All" />
+		<PackageReference Include="YamlDotNet" Version="4.3.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 +110,12 @@
 
 	<ItemGroup>
 	  <Folder Include="Build\" />
+	  <Folder Include="wwwroot\vendor\clipboard.js\" />
 	</ItemGroup>
-</Project>
+
+	<ItemGroup>
+	  <None Update="devtest.pfx">
+	    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+	  </None>
+	</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,124 @@ using System.Net;
 using System.Text;
 using StandardConfiguration;
 using Microsoft.Extensions.Configuration;
+using NBXplorer;
+using BTCPayServer.Payments.Lightning;
 
 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 string DataDir
+        {
+            get;
+            private set;
+        }
+        public List<IPEndPoint> Listen
+        {
+            get;
+            set;
+        }
 
-		public void LoadArgs(IConfiguration conf)
-		{
-			var networkInfo = DefaultConfiguration.GetNetwork(conf);
-			Network = networkInfo?.Network;
-			if(Network == null)
-				throw new ConfigException("Invalid network");
+        public List<NBXplorerConnectionSetting> NBXplorerConnectionSettings
+        {
+            get;
+            set;
+        } = new List<NBXplorerConnectionSetting>();
 
-			DataDir = conf.GetOrDefault<string>("datadir", networkInfo.DefaultDataDirectory);
-			Logs.Configuration.LogInformation("Network: " + Network);
+        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());
 
-			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);
-		}
+            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}\"");
+            }
 
-		public bool RequireHttps
-		{
-			get; set;
-		}
-		public string PostgresConnectionString
-		{
-			get;
-			set;
-		}
-	}
+            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, out var connectionString, out var error))
+                    {
+                        throw new ConfigException($"Invalid setting {net.CryptoCode}.lightning, you need to pass either " +
+                            $"the absolute path to the unix socket of a running CLightning instance (eg. /root/.lightning/lightning-rpc), " +
+                            $"or the url to a charge server with crendetials (eg. https://apitoken@API_TOKEN_SECRET:charge.example.com/)");
+                    }
+                    InternalLightningByCryptoCode.Add(net.CryptoCode, connectionString);
+                }
+            }
+
+            Logs.Configuration.LogInformation("Supported chains: " + String.Join(',', supportedChains.ToArray()));
+
+            PostgresConnectionString = conf.GetOrDefault<string>("postgres", null);
+            BundleJsCss = conf.GetOrDefault<bool>("bundlejscss", true);
+            ExternalUrl = conf.GetOrDefault<Uri>("externalurl", null);
+
+            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 should not be used anymore, use btclightning instead");
+        }
+        public string RootPath { get; set; }
+        public Dictionary<string, LightningConnectionString> InternalLightningByCryptoCode { get; set; } = new Dictionary<string, LightningConnectionString>();
+
+        public BTCPayNetworkProvider NetworkProvider { get; set; }
+        public string PostgresConnectionString
+        {
+            get;
+            set;
+        }
+        public Uri ExternalUrl
+        {
+            get;
+            set;
+        }
+        public bool BundleJsCss
+        {
+            get;
+            set;
+        }
+
+        internal string GetRootUri()
+        {
+            if (ExternalUrl == null)
+                return null;
+            UriBuilder builder = new UriBuilder(ExternalUrl);
+            builder.Path = RootPath;
+            return builder.ToString();
+        }
+    }
 }

BTCPayServer/Configuration/BTCPayServerRuntime.cs

@@ -1,113 +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(30000);
-			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);
-
-			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);
-		}
-
-		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 InvoiceRepository InvoiceRepository
-		{
-			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

@@ -9,44 +9,51 @@ using Microsoft.Extensions.Primitives;
 
 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(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,114 @@ 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 comma separated (default: btc, available: {chains})", CommandOptionType.SingleValue);
+            app.Option("--postgres", $"Connection string to postgres database (default: sqlite is used)", CommandOptionType.SingleValue);
+            app.Option("--externalurl", $"The expected external url of this service, to use if BTCPay is behind a reverse proxy (default: empty, use the incoming HTTP request to figure out)", CommandOptionType.SingleValue);
+            app.Option("--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);
+            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 adnistrator: Must be a unix socket of CLightning (lightning-rpc) or URL to a 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();
+            builder.AppendLine("### Database ###");
+            builder.AppendLine("#postgres=User ID=root;Password=myPassword;Host=localhost;Port=5432;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/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

@@ -12,69 +12,81 @@ 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> Tokens()
-		{
-			var tokens = await _TokenRepository.GetTokens(this.GetBitIdentity().SIN);
-			return new GetTokensResponse(tokens);
-		}
+    [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>>> Tokens([FromBody] TokenRequest request)
-		{
-			PairingCodeEntity pairingEntity = null;
-			if(string.IsNullOrEmpty(request.PairingCode))
-			{
-				if(string.IsNullOrEmpty(request.Id) || !NBitpayClient.Extensions.BitIdExtensions.ValidateSIN(request.Id))
-					throw new BitpayHttpException(400, "'id' property is required");
-				if(string.IsNullOrEmpty(request.Facade))
-					throw new BitpayHttpException(400, "'facade' property is required");
+        [HttpPost]
+        [Route("tokens")]
+        public async Task<DataWrapper<List<PairingCodeResponse>>> Tokens([FromBody] TokenRequest request)
+        {
+            PairingCodeEntity pairingEntity = null;
+            if (string.IsNullOrEmpty(request.PairingCode))
+            {
+                if (string.IsNullOrEmpty(request.Id) || !NBitpayClient.Extensions.BitIdExtensions.ValidateSIN(request.Id))
+                    throw new BitpayHttpException(400, "'id' property is required");
+                if (string.IsNullOrEmpty(request.Facade))
+                    throw new BitpayHttpException(400, "'facade' property is required");
 
-				var pairingCode = await _TokenRepository.CreatePairingCodeAsync();
-				await _TokenRepository.PairWithSINAsync(pairingCode, request.Id);
-				pairingEntity = await _TokenRepository.UpdatePairingCode(new PairingCodeEntity()
-				{
-					Id = pairingCode,
-					Facade = request.Facade,
-					Label = request.Label
-				});
+                var pairingCode = await _TokenRepository.CreatePairingCodeAsync();
+                await _TokenRepository.PairWithSINAsync(pairingCode, request.Id);
+                pairingEntity = await _TokenRepository.UpdatePairingCode(new PairingCodeEntity()
+                {
+                    Id = pairingCode,
+                    Facade = request.Facade,
+                    Label = request.Label
+                });
 
-			}
-			else
-			{
-				var sin = this.GetBitIdentity(false)?.SIN ?? request.Id;
-				if(string.IsNullOrEmpty(request.Id) || !NBitpayClient.Extensions.BitIdExtensions.ValidateSIN(request.Id))
-					throw new BitpayHttpException(400, "'id' property is required, alternatively, use BitId");
+            }
+            else
+            {
+                var sin = this.User.GetSIN() ?? request.Id;
+                if (string.IsNullOrEmpty(request.Id) || !NBitpayClient.Extensions.BitIdExtensions.ValidateSIN(request.Id))
+                    throw new BitpayHttpException(400, "'id' property is required, alternatively, use BitId");
 
-				pairingEntity = await _TokenRepository.GetPairingAsync(request.PairingCode);
-				pairingEntity.SIN = sin;
-				if(!await _TokenRepository.PairWithSINAsync(request.PairingCode, sin))
-					throw new BitpayHttpException(400, "Unknown pairing code");
-				
-			}
+                pairingEntity = await _TokenRepository.GetPairingAsync(request.PairingCode);
+                if (pairingEntity == null)
+                    throw new BitpayHttpException(404, "The specified pairingCode is not found");
+                pairingEntity.SIN = sin;
 
-			var pairingCodes = new List<PairingCodeResponse>
-				{
-					new PairingCodeResponse()
-					{
-						PairingCode = pairingEntity.Id,
-						PairingExpiration = pairingEntity.Expiration,
-						DateCreated = pairingEntity.CreatedTime,
-						Facade = pairingEntity.Facade,
-						Token = pairingEntity.TokenValue,
-						Label = pairingEntity.Label
-					}
-				};
-			return DataWrapper.Create(pairingCodes);
-		}
-	}
+                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 = pairingEntity.Facade,
+                        Token = pairingEntity.TokenValue,
+                        Label = pairingEntity.Label
+                    }
+                };
+            return DataWrapper.Create(pairingCodes);
+        }
+    }
 }

BTCPayServer/Controllers/AccountController.cs

@@ -15,506 +15,509 @@ using BTCPayServer.Models.AccountViewModels;
 using BTCPayServer.Services;
 using BTCPayServer.Services.Mails;
 using BTCPayServer.Services.Stores;
+using BTCPayServer.Logging;
+using BTCPayServer.Security;
 
 namespace BTCPayServer.Controllers
 {
-	[Authorize]
-	[Route("[controller]/[action]")]
-	public class AccountController : Controller
-	{
-		private readonly UserManager<ApplicationUser> _userManager;
-		private readonly SignInManager<ApplicationUser> _signInManager;
-		private readonly IEmailSender _emailSender;
-		private readonly ILogger _logger;
-		StoreRepository storeRepository;
-		RoleManager<IdentityRole> _RoleManager;
-		SettingsRepository _SettingsRepository;
+    [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
+    [Route("[controller]/[action]")]
+    public class AccountController : Controller
+    {
+        private readonly UserManager<ApplicationUser> _userManager;
+        private readonly SignInManager<ApplicationUser> _signInManager;
+        private readonly IEmailSender _emailSender;
+        StoreRepository storeRepository;
+        RoleManager<IdentityRole> _RoleManager;
+        SettingsRepository _SettingsRepository;
+        ILogger _logger;
 
-		public AccountController(
-			UserManager<ApplicationUser> userManager,
-			RoleManager<IdentityRole> roleManager,
-			StoreRepository storeRepository,
-			SignInManager<ApplicationUser> signInManager,
-			IEmailSender emailSender,
-			SettingsRepository settingsRepository,
-			ILogger<AccountController> logger)
-		{
-			this.storeRepository = storeRepository;
-			_userManager = userManager;
-			_signInManager = signInManager;
-			_emailSender = emailSender;
-			_logger = logger;
-			_RoleManager = roleManager;
-			_SettingsRepository = settingsRepository;
-		}
+        public AccountController(
+            UserManager<ApplicationUser> userManager,
+            RoleManager<IdentityRole> roleManager,
+            StoreRepository storeRepository,
+            SignInManager<ApplicationUser> signInManager,
+            IEmailSender emailSender,
+            SettingsRepository settingsRepository)
+        {
+            this.storeRepository = storeRepository;
+            _userManager = userManager;
+            _signInManager = signInManager;
+            _emailSender = emailSender;
+            _RoleManager = roleManager;
+            _SettingsRepository = settingsRepository;
+            _logger = Logs.PayServer;
+        }
 
-		[TempData]
-		public string ErrorMessage
-		{
-			get; set;
-		}
+        [TempData]
+        public string ErrorMessage
+        {
+            get; set;
+        }
 
-		[HttpGet]
-		[AllowAnonymous]
-		public async Task<IActionResult> Login(string returnUrl = null)
-		{
-			// Clear the existing external cookie to ensure a clean login process
-			await HttpContext.SignOutAsync(IdentityConstants.ExternalScheme);
+        [HttpGet]
+        [AllowAnonymous]
+        public async Task<IActionResult> Login(string returnUrl = null)
+        {
+            // Clear the existing external cookie to ensure a clean login process
+            await HttpContext.SignOutAsync(IdentityConstants.ExternalScheme);
 
-			ViewData["ReturnUrl"] = returnUrl;
-			return View();
-		}
+            ViewData["ReturnUrl"] = returnUrl;
+            return View();
+        }
 
-		[HttpPost]
-		[AllowAnonymous]
-		[ValidateAntiForgeryToken]
-		public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null)
-		{
-			ViewData["ReturnUrl"] = returnUrl;
-			if(ModelState.IsValid)
-			{
-				// Require the user to have a confirmed email before they can log on.
-				var user = await _userManager.FindByEmailAsync(model.Email);
-				if(user != null)
-				{
-					if(user.RequiresEmailConfirmation && !await _userManager.IsEmailConfirmedAsync(user))
-					{
-						ModelState.AddModelError(string.Empty,
-									  "You must have a confirmed email to log in.");
-						return View(model);
-					}
-				}
-				// This doesn't count login failures towards account lockout
-				// To enable password failures to trigger account lockout, set lockoutOnFailure: true
-				var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure: false);
-				if(result.Succeeded)
-				{
-					_logger.LogInformation("User logged in.");
-					return RedirectToLocal(returnUrl);
-				}
-				if(result.RequiresTwoFactor)
-				{
-					return RedirectToAction(nameof(LoginWith2fa), new
-					{
-						returnUrl,
-						model.RememberMe
-					});
-				}
-				if(result.IsLockedOut)
-				{
-					_logger.LogWarning("User account locked out.");
-					return RedirectToAction(nameof(Lockout));
-				}
-				else
-				{
-					ModelState.AddModelError(string.Empty, "Invalid login attempt.");
-					return View(model);
-				}
-			}
+        [HttpPost]
+        [AllowAnonymous]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null)
+        {
+            ViewData["ReturnUrl"] = returnUrl;
+            if (ModelState.IsValid)
+            {
+                // Require the user to have a confirmed email before they can log on.
+                var user = await _userManager.FindByEmailAsync(model.Email);
+                if (user != null)
+                {
+                    if (user.RequiresEmailConfirmation && !await _userManager.IsEmailConfirmedAsync(user))
+                    {
+                        ModelState.AddModelError(string.Empty,
+                                      "You must have a confirmed email to log in.");
+                        return View(model);
+                    }
+                }
+                // This doesn't count login failures towards account lockout
+                // To enable password failures to trigger account lockout, set lockoutOnFailure: true
+                var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure: false);
+                if (result.Succeeded)
+                {
+                    _logger.LogInformation("User logged in.");
+                    return RedirectToLocal(returnUrl);
+                }
+                if (result.RequiresTwoFactor)
+                {
+                    return RedirectToAction(nameof(LoginWith2fa), new
+                    {
+                        returnUrl,
+                        model.RememberMe
+                    });
+                }
+                if (result.IsLockedOut)
+                {
+                    _logger.LogWarning("User account locked out.");
+                    return RedirectToAction(nameof(Lockout));
+                }
+                else
+                {
+                    ModelState.AddModelError(string.Empty, "Invalid login attempt.");
+                    return View(model);
+                }
+            }
 
-			// If we got this far, something failed, redisplay form
-			return View(model);
-		}
+            // If we got this far, something failed, redisplay form
+            return View(model);
+        }
 
-		[HttpGet]
-		[AllowAnonymous]
-		public async Task<IActionResult> LoginWith2fa(bool rememberMe, string returnUrl = null)
-		{
-			// Ensure the user has gone through the username & password screen first
-			var user = await _signInManager.GetTwoFactorAuthenticationUserAsync();
+        [HttpGet]
+        [AllowAnonymous]
+        public async Task<IActionResult> LoginWith2fa(bool rememberMe, string returnUrl = null)
+        {
+            // Ensure the user has gone through the username & password screen first
+            var user = await _signInManager.GetTwoFactorAuthenticationUserAsync();
 
-			if(user == null)
-			{
-				throw new ApplicationException($"Unable to load two-factor authentication user.");
-			}
+            if (user == null)
+            {
+                throw new ApplicationException($"Unable to load two-factor authentication user.");
+            }
 
-			var model = new LoginWith2faViewModel { RememberMe = rememberMe };
-			ViewData["ReturnUrl"] = returnUrl;
+            var model = new LoginWith2faViewModel { RememberMe = rememberMe };
+            ViewData["ReturnUrl"] = returnUrl;
 
-			return View(model);
-		}
+            return View(model);
+        }
 
-		[HttpPost]
-		[AllowAnonymous]
-		[ValidateAntiForgeryToken]
-		public async Task<IActionResult> LoginWith2fa(LoginWith2faViewModel model, bool rememberMe, string returnUrl = null)
-		{
-			if(!ModelState.IsValid)
-			{
-				return View(model);
-			}
+        [HttpPost]
+        [AllowAnonymous]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> LoginWith2fa(LoginWith2faViewModel model, bool rememberMe, string returnUrl = null)
+        {
+            if (!ModelState.IsValid)
+            {
+                return View(model);
+            }
 
-			var user = await _signInManager.GetTwoFactorAuthenticationUserAsync();
-			if(user == null)
-			{
-				throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
-			}
+            var user = await _signInManager.GetTwoFactorAuthenticationUserAsync();
+            if (user == null)
+            {
+                throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
+            }
 
-			var authenticatorCode = model.TwoFactorCode.Replace(" ", string.Empty).Replace("-", string.Empty);
+            var authenticatorCode = model.TwoFactorCode.Replace(" ", string.Empty, StringComparison.InvariantCulture).Replace("-", string.Empty, StringComparison.InvariantCulture);
 
-			var result = await _signInManager.TwoFactorAuthenticatorSignInAsync(authenticatorCode, rememberMe, model.RememberMachine);
+            var result = await _signInManager.TwoFactorAuthenticatorSignInAsync(authenticatorCode, rememberMe, model.RememberMachine);
 
-			if(result.Succeeded)
-			{
-				_logger.LogInformation("User with ID {UserId} logged in with 2fa.", user.Id);
-				return RedirectToLocal(returnUrl);
-			}
-			else if(result.IsLockedOut)
-			{
-				_logger.LogWarning("User with ID {UserId} account locked out.", user.Id);
-				return RedirectToAction(nameof(Lockout));
-			}
-			else
-			{
-				_logger.LogWarning("Invalid authenticator code entered for user with ID {UserId}.", user.Id);
-				ModelState.AddModelError(string.Empty, "Invalid authenticator code.");
-				return View();
-			}
-		}
+            if (result.Succeeded)
+            {
+                _logger.LogInformation("User with ID {UserId} logged in with 2fa.", user.Id);
+                return RedirectToLocal(returnUrl);
+            }
+            else if (result.IsLockedOut)
+            {
+                _logger.LogWarning("User with ID {UserId} account locked out.", user.Id);
+                return RedirectToAction(nameof(Lockout));
+            }
+            else
+            {
+                _logger.LogWarning("Invalid authenticator code entered for user with ID {UserId}.", user.Id);
+                ModelState.AddModelError(string.Empty, "Invalid authenticator code.");
+                return View();
+            }
+        }
 
-		[HttpGet]
-		[AllowAnonymous]
-		public async Task<IActionResult> LoginWithRecoveryCode(string returnUrl = null)
-		{
-			// Ensure the user has gone through the username & password screen first
-			var user = await _signInManager.GetTwoFactorAuthenticationUserAsync();
-			if(user == null)
-			{
-				throw new ApplicationException($"Unable to load two-factor authentication user.");
-			}
+        [HttpGet]
+        [AllowAnonymous]
+        public async Task<IActionResult> LoginWithRecoveryCode(string returnUrl = null)
+        {
+            // Ensure the user has gone through the username & password screen first
+            var user = await _signInManager.GetTwoFactorAuthenticationUserAsync();
+            if (user == null)
+            {
+                throw new ApplicationException($"Unable to load two-factor authentication user.");
+            }
 
-			ViewData["ReturnUrl"] = returnUrl;
+            ViewData["ReturnUrl"] = returnUrl;
 
-			return View();
-		}
+            return View();
+        }
 
-		[HttpPost]
-		[AllowAnonymous]
-		[ValidateAntiForgeryToken]
-		public async Task<IActionResult> LoginWithRecoveryCode(LoginWithRecoveryCodeViewModel model, string returnUrl = null)
-		{
-			if(!ModelState.IsValid)
-			{
-				return View(model);
-			}
+        [HttpPost]
+        [AllowAnonymous]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> LoginWithRecoveryCode(LoginWithRecoveryCodeViewModel model, string returnUrl = null)
+        {
+            if (!ModelState.IsValid)
+            {
+                return View(model);
+            }
 
-			var user = await _signInManager.GetTwoFactorAuthenticationUserAsync();
-			if(user == null)
-			{
-				throw new ApplicationException($"Unable to load two-factor authentication user.");
-			}
+            var user = await _signInManager.GetTwoFactorAuthenticationUserAsync();
+            if (user == null)
+            {
+                throw new ApplicationException($"Unable to load two-factor authentication user.");
+            }
 
-			var recoveryCode = model.RecoveryCode.Replace(" ", string.Empty);
+            var recoveryCode = model.RecoveryCode.Replace(" ", string.Empty, StringComparison.InvariantCulture);
 
-			var result = await _signInManager.TwoFactorRecoveryCodeSignInAsync(recoveryCode);
+            var result = await _signInManager.TwoFactorRecoveryCodeSignInAsync(recoveryCode);
 
-			if(result.Succeeded)
-			{
-				_logger.LogInformation("User with ID {UserId} logged in with a recovery code.", user.Id);
-				return RedirectToLocal(returnUrl);
-			}
-			if(result.IsLockedOut)
-			{
-				_logger.LogWarning("User with ID {UserId} account locked out.", user.Id);
-				return RedirectToAction(nameof(Lockout));
-			}
-			else
-			{
-				_logger.LogWarning("Invalid recovery code entered for user with ID {UserId}", user.Id);
-				ModelState.AddModelError(string.Empty, "Invalid recovery code entered.");
-				return View();
-			}
-		}
+            if (result.Succeeded)
+            {
+                _logger.LogInformation("User with ID {UserId} logged in with a recovery code.", user.Id);
+                return RedirectToLocal(returnUrl);
+            }
+            if (result.IsLockedOut)
+            {
+                _logger.LogWarning("User with ID {UserId} account locked out.", user.Id);
+                return RedirectToAction(nameof(Lockout));
+            }
+            else
+            {
+                _logger.LogWarning("Invalid recovery code entered for user with ID {UserId}", user.Id);
+                ModelState.AddModelError(string.Empty, "Invalid recovery code entered.");
+                return View();
+            }
+        }
 
-		[HttpGet]
-		[AllowAnonymous]
-		public IActionResult Lockout()
-		{
-			return View();
-		}
+        [HttpGet]
+        [AllowAnonymous]
+        public IActionResult Lockout()
+        {
+            return View();
+        }
 
-		[HttpGet]
-		[AllowAnonymous]
-		public IActionResult Register(string returnUrl = null)
-		{
-			ViewData["ReturnUrl"] = returnUrl;
-			return View();
-		}
+        [HttpGet]
+        [AllowAnonymous]
+        public async Task<IActionResult> Register(string returnUrl = null)
+        {
+            var policies = await _SettingsRepository.GetSettingAsync<PoliciesSettings>() ?? new PoliciesSettings();
+            if (policies.LockSubscription)
+                return RedirectToAction(nameof(HomeController.Index), "Home");
+            ViewData["ReturnUrl"] = returnUrl;
+            return View();
+        }
 
-		[HttpPost]
-		[AllowAnonymous]
-		[ValidateAntiForgeryToken]
-		public async Task<IActionResult> Register(RegisterViewModel model, string returnUrl = null)
-		{
-			ViewData["ReturnUrl"] = returnUrl;
-			if(ModelState.IsValid)
-			{
-				var policies = await _SettingsRepository.GetSettingAsync<PoliciesSettings>() ?? new PoliciesSettings();
-				var user = new ApplicationUser { UserName = model.Email, Email = model.Email, RequiresEmailConfirmation = policies.RequiresConfirmedEmail };
-				var result = await _userManager.CreateAsync(user, model.Password);
-				if(result.Succeeded)
-				{
-					_logger.LogInformation("User created a new account with password.");
+        [HttpPost]
+        [AllowAnonymous]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> Register(RegisterViewModel model, string returnUrl = null)
+        {
+            ViewData["ReturnUrl"] = returnUrl;
+            var policies = await _SettingsRepository.GetSettingAsync<PoliciesSettings>() ?? new PoliciesSettings();
+            if (policies.LockSubscription)
+                return RedirectToAction(nameof(HomeController.Index), "Home");
+            if (ModelState.IsValid)
+            {
+                var user = new ApplicationUser { UserName = model.Email, Email = model.Email, RequiresEmailConfirmation = policies.RequiresConfirmedEmail };
+                var result = await _userManager.CreateAsync(user, model.Password);
+                if (result.Succeeded)
+                {
+                    var admin = await _userManager.GetUsersInRoleAsync(Roles.ServerAdmin);
+                    Logs.PayServer.LogInformation($"A new user just registered {user.Email} {(admin.Count == 0 ? "(admin)" : "")}");
+                    if (admin.Count == 0)
+                    {
+                        await _RoleManager.CreateAsync(new IdentityRole(Roles.ServerAdmin));
+                        await _userManager.AddToRoleAsync(user, Roles.ServerAdmin);
+                    }
 
-					var admin = await _userManager.GetUsersInRoleAsync(Roles.ServerAdmin);
-					if(admin.Count == 0)
-					{
-						_logger.LogInformation("Admin created.");
-						await _RoleManager.CreateAsync(new IdentityRole(Roles.ServerAdmin));
-						await _userManager.AddToRoleAsync(user, Roles.ServerAdmin);
-					}
+                    var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
+                    var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
+                    RegisteredUserId = user.Id;
+                    await _emailSender.SendEmailConfirmationAsync(model.Email, callbackUrl);
+                    if (!policies.RequiresConfirmedEmail)
+                    {
+                        await _signInManager.SignInAsync(user, isPersistent: false);
+                        return RedirectToLocal(returnUrl);
+                    }
+                    else
+                    {
+                        TempData["StatusMessage"] = "Account created, please confirm your email";
+                        return View();
+                    }
+                }
+                AddErrors(result);
+            }
 
-					var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
-					var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
-					RegisteredUserId = user.Id;
-					await _emailSender.SendEmailConfirmationAsync(model.Email, callbackUrl);
-					_logger.LogInformation("User created a new account with password.");
-					if(!policies.RequiresConfirmedEmail)
-					{
-						await _signInManager.SignInAsync(user, isPersistent: false);
-						return RedirectToLocal(returnUrl);
-					}
-					else
-					{
-						TempData["StatusMessage"] = "Account created, please confirm your email";
-						return View();
-					}
-				}
-				AddErrors(result);
-			}
+            // If we got this far, something failed, redisplay form
+            return View(model);
+        }
 
-			// If we got this far, something failed, redisplay form
-			return View(model);
-		}
+        /// <summary> 
+        /// Test property
+        /// </summary>
+        public string RegisteredUserId
+        {
+            get; set;
+        }
 
-		/// <summary>
-		/// Test property
-		/// </summary>
-		public string RegisteredUserId
-		{
-			get; set;
-		}
+        [HttpGet]
+        public async Task<IActionResult> Logout()
+        {
+            await _signInManager.SignOutAsync();
+            _logger.LogInformation("User logged out.");
+            return RedirectToAction(nameof(HomeController.Index), "Home");
+        }
 
-		[HttpGet]
-		public async Task<IActionResult> Logout()
-		{
-			await _signInManager.SignOutAsync();
-			_logger.LogInformation("User logged out.");
-			return RedirectToAction(nameof(HomeController.Index), "Home");
-		}
+        [HttpPost]
+        [AllowAnonymous]
+        [ValidateAntiForgeryToken]
+        public IActionResult ExternalLogin(string provider, string returnUrl = null)
+        {
+            // Request a redirect to the external login provider.
+            var redirectUrl = Url.Action(nameof(ExternalLoginCallback), "Account", new
+            {
+                returnUrl
+            });
+            var properties = _signInManager.ConfigureExternalAuthenticationProperties(provider, redirectUrl);
+            return Challenge(properties, provider);
+        }
 
-		[HttpPost]
-		[AllowAnonymous]
-		[ValidateAntiForgeryToken]
-		public IActionResult ExternalLogin(string provider, string returnUrl = null)
-		{
-			// Request a redirect to the external login provider.
-			var redirectUrl = Url.Action(nameof(ExternalLoginCallback), "Account", new
-			{
-				returnUrl
-			});
-			var properties = _signInManager.ConfigureExternalAuthenticationProperties(provider, redirectUrl);
-			return Challenge(properties, provider);
-		}
+        [HttpGet]
+        [AllowAnonymous]
+        public async Task<IActionResult> ExternalLoginCallback(string returnUrl = null, string remoteError = null)
+        {
+            if (remoteError != null)
+            {
+                ErrorMessage = $"Error from external provider: {remoteError}";
+                return RedirectToAction(nameof(Login));
+            }
+            var info = await _signInManager.GetExternalLoginInfoAsync();
+            if (info == null)
+            {
+                return RedirectToAction(nameof(Login));
+            }
 
-		[HttpGet]
-		[AllowAnonymous]
-		public async Task<IActionResult> ExternalLoginCallback(string returnUrl = null, string remoteError = null)
-		{
-			if(remoteError != null)
-			{
-				ErrorMessage = $"Error from external provider: {remoteError}";
-				return RedirectToAction(nameof(Login));
-			}
-			var info = await _signInManager.GetExternalLoginInfoAsync();
-			if(info == null)
-			{
-				return RedirectToAction(nameof(Login));
-			}
+            // Sign in the user with this external login provider if the user already has a login.
+            var result = await _signInManager.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, isPersistent: false, bypassTwoFactor: true);
+            if (result.Succeeded)
+            {
+                _logger.LogInformation("User logged in with {Name} provider.", info.LoginProvider);
+                return RedirectToLocal(returnUrl);
+            }
+            if (result.IsLockedOut)
+            {
+                return RedirectToAction(nameof(Lockout));
+            }
+            else
+            {
+                // If the user does not have an account, then ask the user to create an account.
+                ViewData["ReturnUrl"] = returnUrl;
+                ViewData["LoginProvider"] = info.LoginProvider;
+                var email = info.Principal.FindFirstValue(ClaimTypes.Email);
+                return View("ExternalLogin", new ExternalLoginViewModel { Email = email });
+            }
+        }
 
-			// Sign in the user with this external login provider if the user already has a login.
-			var result = await _signInManager.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, isPersistent: false, bypassTwoFactor: true);
-			if(result.Succeeded)
-			{
-				_logger.LogInformation("User logged in with {Name} provider.", info.LoginProvider);
-				return RedirectToLocal(returnUrl);
-			}
-			if(result.IsLockedOut)
-			{
-				return RedirectToAction(nameof(Lockout));
-			}
-			else
-			{
-				// If the user does not have an account, then ask the user to create an account.
-				ViewData["ReturnUrl"] = returnUrl;
-				ViewData["LoginProvider"] = info.LoginProvider;
-				var email = info.Principal.FindFirstValue(ClaimTypes.Email);
-				return View("ExternalLogin", new ExternalLoginViewModel { Email = email });
-			}
-		}
+        [HttpPost]
+        [AllowAnonymous]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> ExternalLoginConfirmation(ExternalLoginViewModel model, string returnUrl = null)
+        {
+            if (ModelState.IsValid)
+            {
+                // Get the information about the user from the external login provider
+                var info = await _signInManager.GetExternalLoginInfoAsync();
+                if (info == null)
+                {
+                    throw new ApplicationException("Error loading external login information during confirmation.");
+                }
+                var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
+                var result = await _userManager.CreateAsync(user);
+                if (result.Succeeded)
+                {
+                    result = await _userManager.AddLoginAsync(user, info);
+                    if (result.Succeeded)
+                    {
+                        await _signInManager.SignInAsync(user, isPersistent: false);
+                        _logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
+                        return RedirectToLocal(returnUrl);
+                    }
+                }
+                AddErrors(result);
+            }
 
-		[HttpPost]
-		[AllowAnonymous]
-		[ValidateAntiForgeryToken]
-		public async Task<IActionResult> ExternalLoginConfirmation(ExternalLoginViewModel model, string returnUrl = null)
-		{
-			if(ModelState.IsValid)
-			{
-				// Get the information about the user from the external login provider
-				var info = await _signInManager.GetExternalLoginInfoAsync();
-				if(info == null)
-				{
-					throw new ApplicationException("Error loading external login information during confirmation.");
-				}
-				var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
-				var result = await _userManager.CreateAsync(user);
-				if(result.Succeeded)
-				{
-					result = await _userManager.AddLoginAsync(user, info);
-					if(result.Succeeded)
-					{
-						await _signInManager.SignInAsync(user, isPersistent: false);
-						_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
-						return RedirectToLocal(returnUrl);
-					}
-				}
-				AddErrors(result);
-			}
+            ViewData["ReturnUrl"] = returnUrl;
+            return View(nameof(ExternalLogin), model);
+        }
 
-			ViewData["ReturnUrl"] = returnUrl;
-			return View(nameof(ExternalLogin), model);
-		}
+        [HttpGet]
+        [AllowAnonymous]
+        public async Task<IActionResult> ConfirmEmail(string userId, string code)
+        {
+            if (userId == null || code == null)
+            {
+                return RedirectToAction(nameof(HomeController.Index), "Home");
+            }
+            var user = await _userManager.FindByIdAsync(userId);
+            if (user == null)
+            {
+                throw new ApplicationException($"Unable to load user with ID '{userId}'.");
+            }
+            var result = await _userManager.ConfirmEmailAsync(user, code);
+            return View(result.Succeeded ? "ConfirmEmail" : "Error");
+        }
 
-		[HttpGet]
-		[AllowAnonymous]
-		public async Task<IActionResult> ConfirmEmail(string userId, string code)
-		{
-			if(userId == null || code == null)
-			{
-				return RedirectToAction(nameof(HomeController.Index), "Home");
-			}
-			var user = await _userManager.FindByIdAsync(userId);
-			if(user == null)
-			{
-				throw new ApplicationException($"Unable to load user with ID '{userId}'.");
-			}
-			var result = await _userManager.ConfirmEmailAsync(user, code);
-			return View(result.Succeeded ? "ConfirmEmail" : "Error");
-		}
+        [HttpGet]
+        [AllowAnonymous]
+        public IActionResult ForgotPassword()
+        {
+            return View();
+        }
 
-		[HttpGet]
-		[AllowAnonymous]
-		public IActionResult ForgotPassword()
-		{
-			return View();
-		}
+        [HttpPost]
+        [AllowAnonymous]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> ForgotPassword(ForgotPasswordViewModel model)
+        {
+            if (ModelState.IsValid)
+            {
+                var user = await _userManager.FindByEmailAsync(model.Email);
+                if (user == null || !(await _userManager.IsEmailConfirmedAsync(user)))
+                {
+                    // Don't reveal that the user does not exist or is not confirmed
+                    return RedirectToAction(nameof(ForgotPasswordConfirmation));
+                }
 
-		[HttpPost]
-		[AllowAnonymous]
-		[ValidateAntiForgeryToken]
-		public async Task<IActionResult> ForgotPassword(ForgotPasswordViewModel model)
-		{
-			if(ModelState.IsValid)
-			{
-				var user = await _userManager.FindByEmailAsync(model.Email);
-				if(user == null || !(await _userManager.IsEmailConfirmedAsync(user)))
-				{
-					// Don't reveal that the user does not exist or is not confirmed
-					return RedirectToAction(nameof(ForgotPasswordConfirmation));
-				}
+                // For more information on how to enable account confirmation and password reset please
+                // visit https://go.microsoft.com/fwlink/?LinkID=532713
+                var code = await _userManager.GeneratePasswordResetTokenAsync(user);
+                var callbackUrl = Url.ResetPasswordCallbackLink(user.Id, code, Request.Scheme);
+                await _emailSender.SendEmailAsync(model.Email, "Reset Password",
+                   $"Please reset your password by clicking here: <a href='{callbackUrl}'>link</a>");
+                return RedirectToAction(nameof(ForgotPasswordConfirmation));
+            }
 
-				// For more information on how to enable account confirmation and password reset please
-				// visit https://go.microsoft.com/fwlink/?LinkID=532713
-				var code = await _userManager.GeneratePasswordResetTokenAsync(user);
-				var callbackUrl = Url.ResetPasswordCallbackLink(user.Id, code, Request.Scheme);
-				await _emailSender.SendEmailAsync(model.Email, "Reset Password",
-				   $"Please reset your password by clicking here: <a href='{callbackUrl}'>link</a>");
-				return RedirectToAction(nameof(ForgotPasswordConfirmation));
-			}
+            // If we got this far, something failed, redisplay form
+            return View(model);
+        }
 
-			// If we got this far, something failed, redisplay form
-			return View(model);
-		}
+        [HttpGet]
+        [AllowAnonymous]
+        public IActionResult ForgotPasswordConfirmation()
+        {
+            return View();
+        }
 
-		[HttpGet]
-		[AllowAnonymous]
-		public IActionResult ForgotPasswordConfirmation()
-		{
-			return View();
-		}
+        [HttpGet]
+        [AllowAnonymous]
+        public IActionResult ResetPassword(string code = null)
+        {
+            if (code == null)
+            {
+                throw new ApplicationException("A code must be supplied for password reset.");
+            }
+            var model = new ResetPasswordViewModel { Code = code };
+            return View(model);
+        }
 
-		[HttpGet]
-		[AllowAnonymous]
-		public IActionResult ResetPassword(string code = null)
-		{
-			if(code == null)
-			{
-				throw new ApplicationException("A code must be supplied for password reset.");
-			}
-			var model = new ResetPasswordViewModel { Code = code };
-			return View(model);
-		}
+        [HttpPost]
+        [AllowAnonymous]
+        [ValidateAntiForgeryToken]
+        public async Task<IActionResult> ResetPassword(ResetPasswordViewModel model)
+        {
+            if (!ModelState.IsValid)
+            {
+                return View(model);
+            }
+            var user = await _userManager.FindByEmailAsync(model.Email);
+            if (user == null)
+            {
+                // Don't reveal that the user does not exist
+                return RedirectToAction(nameof(ResetPasswordConfirmation));
+            }
+            var result = await _userManager.ResetPasswordAsync(user, model.Code, model.Password);
+            if (result.Succeeded)
+            {
+                return RedirectToAction(nameof(ResetPasswordConfirmation));
+            }
+            AddErrors(result);
+            return View();
+        }
 
-		[HttpPost]
-		[AllowAnonymous]
-		[ValidateAntiForgeryToken]
-		public async Task<IActionResult> ResetPassword(ResetPasswordViewModel model)
-		{
-			if(!ModelState.IsValid)
-			{
-				return View(model);
-			}
-			var user = await _userManager.FindByEmailAsync(model.Email);
-			if(user == null)
-			{
-				// Don't reveal that the user does not exist
-				return RedirectToAction(nameof(ResetPasswordConfirmation));
-			}
-			var result = await _userManager.ResetPasswordAsync(user, model.Code, model.Password);
-			if(result.Succeeded)
-			{
-				return RedirectToAction(nameof(ResetPasswordConfirmation));
-			}
-			AddErrors(result);
-			return View();
-		}
-
-		[HttpGet]
-		[AllowAnonymous]
-		public IActionResult ResetPasswordConfirmation()
-		{
-			return View();
-		}
+        [HttpGet]
+        [AllowAnonymous]
+        public IActionResult ResetPasswordConfirmation()
+        {
+            return View();
+        }
 
 
-		[HttpGet]
-		public IActionResult AccessDenied()
-		{
-			return View();
-		}
+        [HttpGet]
+        public IActionResult AccessDenied()
+        {
+            return View();
+        }
 
-		#region Helpers
+        #region Helpers
 
-		private void AddErrors(IdentityResult result)
-		{
-			foreach(var error in result.Errors)
-			{
-				ModelState.AddModelError(string.Empty, error.Description);
-			}
-		}
+        private void AddErrors(IdentityResult result)
+        {
+            foreach (var error in result.Errors)
+            {
+                ModelState.AddModelError(string.Empty, error.Description);
+            }
+        }
 
-		private IActionResult RedirectToLocal(string returnUrl)
-		{
-			if(Url.IsLocalUrl(returnUrl))
-			{
-				return Redirect(returnUrl);
-			}
-			else
-			{
-				return RedirectToAction(nameof(HomeController.Index), "Home");
-			}
-		}
+        private IActionResult RedirectToLocal(string returnUrl)
+        {
+            if (Url.IsLocalUrl(returnUrl))
+            {
+                return Redirect(returnUrl);
+            }
+            else
+            {
+                return RedirectToAction(nameof(HomeController.Index), "Home");
+            }
+        }
 
-		#endregion
-	}
+        #endregion
+    }
 }

BTCPayServer/Controllers/AppsController.PointOfSale.cs

@@ -0,0 +1,282 @@
+using System;
+using Microsoft.EntityFrameworkCore;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Data;
+using BTCPayServer.Models;
+using BTCPayServer.Models.AppViewModels;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc;
+using NBitcoin.DataEncoders;
+using NBitcoin;
+using BTCPayServer.Services.Apps;
+using Newtonsoft.Json;
+using YamlDotNet.RepresentationModel;
+using System.IO;
+using BTCPayServer.Services.Rates;
+using System.Globalization;
+using System.Text;
+using System.Text.Encodings.Web;
+
+namespace BTCPayServer.Controllers
+{
+    public partial class AppsController
+    {
+        public class PointOfSaleSettings
+        {
+            public PointOfSaleSettings()
+            {
+                Title = "My awesome Point of Sale";
+                Currency = "USD";
+                Template =
+                    "tea:\n" +
+                    "  price: 0.02\n" +
+                    "  title: Green Tea # title is optional, defaults to the keys\n\n" +
+                    "coffee:\n" +
+                    "  price: 1\n\n" +
+                    "bamba:\n" +
+                    "  price: 3\n\n" +
+                    "beer:\n" +
+                    "  price: 7\n\n" +
+                    "hat:\n" +
+                    "  price: 15\n\n" +
+                    "tshirt:\n" +
+                    "  price: 25";
+                ShowCustomAmount = true;
+            }
+            public string Title { get; set; }
+            public string Currency { get; set; }
+            public string Template { get; set; }
+            public bool ShowCustomAmount { 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()
+            {
+                Title = settings.Title,
+                ShowCustomAmount = settings.ShowCustomAmount,
+                Currency = settings.Currency,
+                Template = settings.Template
+            };
+            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 = 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
+            {
+                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,
+                ShowCustomAmount = vm.ShowCustomAmount,
+                Currency = vm.Currency.ToUpperInvariant(),
+                Template = vm.Template
+            });
+            await UpdateAppSettings(app);
+            StatusMessage = "App updated";
+            return RedirectToAction(nameof(UpdatePointOfSale));
+        }
+
+        [HttpGet]
+        [Route("{appId}/pos")]
+        public async Task<IActionResult> ViewPointOfSale(string appId)
+        {
+            var app = await GetApp(appId, AppType.PointOfSale);
+            if (app == null)
+                return NotFound();
+            var settings = app.GetSettings<PointOfSaleSettings>();
+            var currency = _Currencies.GetCurrencyData(settings.Currency, false);
+            double step = currency == null ? 1 : Math.Pow(10, -(currency.Divisibility));
+
+            return View(new ViewPointOfSaleViewModel()
+            {
+                Title = settings.Title,
+                Step = step.ToString(CultureInfo.InvariantCulture),
+                ShowCustomAmount = settings.ShowCustomAmount,
+                Items = Parse(settings.Template, settings.Currency)
+            });
+        }
+
+        private async Task<AppData> GetApp(string appId, AppType appType)
+        {
+            using (var ctx = _ContextFactory.CreateContext())
+            {
+                return await ctx.Apps
+                                .Where(us => us.Id == appId && us.AppType == appType.ToString())
+                                .FirstOrDefaultAsync();
+            }
+        }
+
+        private ViewPointOfSaleViewModel.Item[] Parse(string template, string currency)
+        {
+            var input = new StringReader(template);
+            YamlStream stream = new YamlStream();
+            stream.Load(input);
+            var root = (YamlMappingNode)stream.Documents[0].RootNode;
+            return root
+                .Children
+                .Select(kv => new { Key = (kv.Key as YamlScalarNode)?.Value, Value = kv.Value as YamlMappingNode })
+                .Where(kv => kv.Value != null)
+                .Select(c => new ViewPointOfSaleViewModel.Item()
+                {
+                    Id = c.Key,
+                    Title = c.Value.Children
+                             .Select(kv => new { Key = (kv.Key as YamlScalarNode)?.Value, Value = kv.Value as YamlScalarNode })
+                             .Where(kv => kv.Value != null)
+                             .Where(cc => cc.Key == "title")
+                             .FirstOrDefault()?.Value?.Value ?? c.Key,
+                    Price = c.Value.Children
+                             .Select(kv => new { Key = (kv.Key as YamlScalarNode)?.Value, Value = kv.Value as YamlScalarNode })
+                             .Where(kv => kv.Value != null)
+                             .Where(cc => cc.Key == "price")
+                             .Select(cc => new ViewPointOfSaleViewModel.Item.ItemPrice()
+                             {
+                                 Value = decimal.Parse(cc.Value.Value, CultureInfo.InvariantCulture),
+                                 Formatted = FormatCurrency(cc.Value.Value, currency)
+                             })
+                             .Single()
+                })
+                .ToArray();
+        }
+
+        string FormatCurrency(string price, string currency)
+        {
+            return decimal.Parse(price, CultureInfo.InvariantCulture).ToString("C", _Currencies.GetCurrencyProvider(currency));
+        }
+
+        [HttpPost]
+        [Route("{appId}/pos")]
+        [IgnoreAntiforgeryToken]
+        public async Task<IActionResult> ViewPointOfSale(string appId,
+                                                        decimal amount,
+                                                        string email,
+                                                        string orderId,
+                                                        string notificationUrl,
+                                                        string redirectUrl,
+                                                        string choiceKey)
+        {
+            var app = await 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)
+            {
+                return RedirectToAction(nameof(ViewPointOfSale), new { appId = appId });
+            }
+            string title = null;
+            var price = 0.0m;
+            if (!string.IsNullOrEmpty(choiceKey))
+            {
+                var choices = Parse(settings.Template, settings.Currency);
+                var choice = choices.FirstOrDefault(c => c.Id == choiceKey);
+                if (choice == null)
+                    return NotFound();
+                title = choice.Title;
+                price = choice.Price.Value;
+            }
+            else
+            {
+                if (!settings.ShowCustomAmount)
+                    return NotFound();
+                price = amount;
+                title = settings.Title;
+            }
+            var store = await GetStore(app);
+            var invoice = await _InvoiceController.CreateInvoiceCore(new NBitpayClient.Invoice()
+            {
+                ItemDesc = title,
+                Currency = settings.Currency,
+                Price = price,
+                BuyerEmail = email,
+                OrderId = orderId,
+                NotificationURL = notificationUrl,
+                RedirectURL = redirectUrl,
+                FullNotifications = true
+            }, store, HttpContext.Request.GetAbsoluteRoot());
+            return Redirect(invoice.Data.Url);
+        }
+
+        private async Task<StoreData> GetStore(AppData app)
+        {
+            using (var ctx = _ContextFactory.CreateContext())
+            {
+                return await ctx.Stores.FirstOrDefaultAsync(s => s.Id == app.StoreDataId);
+            }
+        }
+
+        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;
+                await ctx.SaveChangesAsync();
+            }
+        }
+    }
+}

BTCPayServer/Controllers/AppsController.cs

@@ -0,0 +1,200 @@
+using System;
+using Microsoft.EntityFrameworkCore;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Data;
+using BTCPayServer.Models;
+using BTCPayServer.Models.AppViewModels;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc;
+using NBitcoin.DataEncoders;
+using NBitcoin;
+using BTCPayServer.Services.Apps;
+using BTCPayServer.Services.Rates;
+
+namespace BTCPayServer.Controllers
+{
+    [AutoValidateAntiforgeryToken]
+    [Route("apps")]
+    public partial class AppsController : Controller
+    {
+        ApplicationDbContextFactory _ContextFactory;
+        UserManager<ApplicationUser> _UserManager;
+        CurrencyNameTable _Currencies;
+        InvoiceController _InvoiceController;
+
+        [TempData]
+        public string StatusMessage { get; set; }
+
+        public AppsController(
+            UserManager<ApplicationUser> userManager,
+            ApplicationDbContextFactory contextFactory,
+            CurrencyNameTable currencies,
+            InvoiceController invoiceController)
+        {
+            _InvoiceController = invoiceController;
+            _UserManager = userManager;
+            _ContextFactory = contextFactory;
+            _Currencies = currencies;
+        }
+        public async Task<IActionResult> ListApps()
+        {
+            var apps = await GetAllApps();
+            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 DeleteApp(appData))
+                StatusMessage = "App removed successfully";
+            return RedirectToAction(nameof(ListApps));
+        }
+
+        [HttpGet]
+        [Route("create")]
+        public async Task<IActionResult> CreateApp()
+        {
+            var stores = await GetOwnedStores();
+            if (stores.Length == 0)
+            {
+                StatusMessage = "Error: You must have created at least one store";
+                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 GetOwnedStores();
+            if (stores.Length == 0)
+            {
+                StatusMessage = "Error: You must own at least one store";
+                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));
+            }
+            using (var ctx = _ContextFactory.CreateContext())
+            {
+                var id = Encoders.Base58.EncodeData(RandomUtils.GetBytes(32));
+                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";
+            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 async Task<AppData> GetOwnedApp(string appId, AppType? type = null)
+        {
+            var userId = GetUserId();
+            using (var ctx = _ContextFactory.CreateContext())
+            {
+                var app = await ctx.UserStore
+                                .Where(us => us.ApplicationUserId == userId && us.Role == StoreRoles.Owner)
+                                .SelectMany(us => us.StoreData.Apps.Where(a => a.Id == appId))
+                   .FirstOrDefaultAsync();
+                if (app == null)
+                    return null;
+                if (type != null && type.Value.ToString() != app.AppType)
+                    return null;
+                return app;
+            }
+        }
+
+        private async Task<StoreData[]> GetOwnedStores()
+        {
+            var userId = GetUserId();
+            using (var ctx = _ContextFactory.CreateContext())
+            {
+                return await ctx.UserStore
+                    .Where(us => us.ApplicationUserId == userId && us.Role == StoreRoles.Owner)
+                    .Select(u => u.StoreData)
+                    .ToArrayAsync();
+            }
+        }
+
+        private async Task<bool> DeleteApp(AppData appData)
+        {
+            using (var ctx = _ContextFactory.CreateContext())
+            {
+                ctx.Apps.Add(appData);
+                ctx.Entry<AppData>(appData).State = EntityState.Deleted;
+                return await ctx.SaveChangesAsync() == 1;
+            }
+        }
+
+        private async Task<ListAppsViewModel.ListAppViewModel[]> GetAllApps()
+        {
+            var userId = GetUserId();
+            using (var ctx = _ContextFactory.CreateContext())
+            {
+                return await ctx.UserStore
+                    .Where(us => us.ApplicationUserId == userId)
+                    .Join(ctx.Apps, us => us.StoreDataId, app => app.StoreDataId,
+                    (us, app) =>
+                    new ListAppsViewModel.ListAppViewModel()
+                    {
+                        IsOwner = us.Role == StoreRoles.Owner,
+                        StoreId = us.StoreDataId,
+                        StoreName = us.StoreData.StoreName,
+                        AppName = app.Name,
+                        AppType = app.AppType,
+                        Id = app.Id
+                    })
+                    .ToArrayAsync();
+            }
+        }
+
+        private string GetUserId()
+        {
+            return _UserManager.GetUserId(User);
+        }
+    }
+}

BTCPayServer/Controllers/InvoiceController.API.cs

@@ -10,112 +10,83 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using BTCPayServer.Data;
-using BTCPayServer.Servcices.Invoices;
+using BTCPayServer.Services.Invoices;
+using Microsoft.AspNetCore.Cors;
+using BTCPayServer.Services.Stores;
+using Microsoft.AspNetCore.Authorization;
+using BTCPayServer.Security;
 
 namespace BTCPayServer.Controllers
 {
-    public partial class InvoiceController
+    [EnableCors("BitpayAPI")]
+    [BitpayAPIConstraint]
+    [Authorize(Policies.CanUseStore.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] Invoice invoice)
+        {
+            return await _InvoiceController.CreateInvoiceCore(invoice, HttpContext.GetStoreData(), HttpContext.Request.GetAbsoluteRoot());
+        }
 
-		[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}")]
+        [AllowAnonymous]
+        public async Task<DataWrapper<InvoiceResponse>> GetInvoice(string id, string token)
+        {
+            var invoice = await _InvoiceRepository.GetInvoice(null, id);
+            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,
+                ItemCode = 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)).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.Facade).Concat(new[] { "user" }).FirstOrDefault()}` facade");
-			}
-			return actualToken;
-		}
-
-		private IEnumerable<BitTokenEntity> GetCompatibleTokens(BitTokenEntity token)
-		{
-			if(token.Facade == Facade.Merchant.ToString())
-			{
-				yield return token.Clone(Facade.User);
-				yield return token.Clone(Facade.PointOfSale);
-			}
-			if(token.Facade == 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.StoreId);
-			if(store == null)
-				throw new BitpayHttpException(401, "Unknown store");
-			return store;
-		}
-
-	}
+            return DataWrapper.Create(entities);
+        }
+    }
 }

BTCPayServer/Controllers/InvoiceController.PaymentProtocol.cs

@@ -9,64 +9,79 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using BTCPayServer.Services.Invoices;
+using BTCPayServer.Payments;
 
 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();
+        [HttpGet]
+        [Route("i/{invoiceId}/{cryptoCode?}")]
+        [AcceptMediaTypeConstraint("application/bitcoin-paymentrequest")]
+        public async Task<IActionResult> GetInvoiceRequest(string invoiceId, string cryptoCode = null)
+        {
+            if (cryptoCode == null)
+                cryptoCode = "BTC";
+            var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId);
+            var network = _NetworkProvider.GetNetwork(cryptoCode);
+            var paymentMethodId = new PaymentMethodId(cryptoCode, Payments.PaymentTypes.BTCLike);
+            if (invoice == null || invoice.IsExpired() || network == null || !invoice.Support(paymentMethodId))
+                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 dto = invoice.EntityToDTO(_NetworkProvider);
+            var paymentMethod = dto.CryptoInfo.First(c => c.GetpaymentMethodId() == paymentMethodId);
+            PaymentRequest request = new PaymentRequest
+            {
+                DetailsVersion = 1
+            };
+            request.Details.Expires = invoice.ExpirationTime;
+            request.Details.Memo = invoice.ProductInformation.ItemDesc;
+            request.Details.Network = network.NBitcoinNetwork;
+            request.Details.Outputs.Add(new PaymentOutput() { Amount = paymentMethod.Due, Script = BitcoinAddress.Create(paymentMethod.Address, network.NBitcoinNetwork).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");
+            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");
-				}
-			}
+            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);
-		}
+            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..."));
-		}
-	}
+        [HttpPost]
+        [Route("i/{invoiceId}", Order = 99)]
+        [Route("i/{invoiceId}/{cryptoCode}", Order = 99)]
+        [MediaTypeConstraint("application/bitcoin-payment")]
+        public async Task<IActionResult> PostPayment(string invoiceId, string cryptoCode = null)
+        {
+            var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId);
+            if (cryptoCode == null)
+                cryptoCode = "BTC";
+            var network = _NetworkProvider.GetNetwork(cryptoCode);
+            if (network == null || invoice == null || invoice.IsExpired() || !invoice.Support(new PaymentMethodId(cryptoCode, Payments.PaymentTypes.BTCLike)))
+                return NotFound();
+
+            var wallet = _WalletProvider.GetWallet(network);
+            if (wallet == null)
+                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(), network.NBitcoinNetwork);
+            return new PaymentAckActionResult(payment.CreateACK(invoiceId + " is currently processing, thanks for your purchase..."));
+        }
+    }
 }

BTCPayServer/Controllers/InvoiceController.UI.cs

@@ -1,8 +1,9 @@
 using BTCPayServer.Data;
 using BTCPayServer.Filters;
 using BTCPayServer.Models.InvoicingModels;
-using BTCPayServer.Servcices.Invoices;
+using BTCPayServer.Services.Invoices;
 using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Cors;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Rendering;
 using NBitcoin;
@@ -14,193 +15,541 @@ using System.Linq;
 using System.Security.Claims;
 using System.Text;
 using System.Threading.Tasks;
+using BTCPayServer.Services.Rates;
+using System.Net.WebSockets;
+using System.Threading;
+using BTCPayServer.Events;
+using NBXplorer;
+using BTCPayServer.Payments;
+using BTCPayServer.Payments.Lightning;
+using BTCPayServer.Security;
 
 namespace BTCPayServer.Controllers
 {
     public partial class InvoiceController
     {
+        [HttpGet]
+        [Route("invoices/{invoiceId}")]
+        public async Task<IActionResult> Invoice(string invoiceId)
+        {
+            var invoice = (await _InvoiceRepository.GetInvoices(new InvoiceQuery()
+            {
+                UserId = GetUserId(),
+                InvoiceId = invoiceId,
+                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 dto = invoice.EntityToDTO(_NetworkProvider);
+            var store = await _StoreRepository.FindStore(invoice.StoreId);
 
-			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
-			};
+            InvoiceDetailsModel model = new InvoiceDetailsModel()
+            {
+                StoreName = store.StoreName,
+                StoreLink = Url.Action(nameof(StoresController.UpdateStore), "Stores", new { storeId = store.Id }),
+                Id = invoice.Id,
+                Status = invoice.Status,
+                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 = FormatCurrency((decimal)dto.Price, dto.Currency, _CurrencyNameTable),
+                NotificationUrl = invoice.NotificationURL,
+                RedirectUrl = invoice.RedirectURL,
+                ProductInformation = invoice.ProductInformation,
+                StatusException = invoice.ExceptionStatus,
+                Events = invoice.Events
+            };
 
-			var expiration = TimeSpan.FromSeconds((double)model.ExpirationSeconds);
-			model.TimeLeft = PrettyPrint(expiration);
-			return View(model);
-		}
+            foreach (var data in invoice.GetPaymentMethods(null))
+            {
+                var cryptoInfo = dto.CryptoInfo.First(o => o.GetpaymentMethodId() == data.GetId());
+                var accounting = data.Calculate();
+                var paymentMethodId = data.GetId();
+                var cryptoPayment = new InvoiceDetailsModel.CryptoPayment();
+                cryptoPayment.PaymentMethod = ToString(paymentMethodId);
+                cryptoPayment.Due = accounting.Due.ToString() + $" {paymentMethodId.CryptoCode}";
+                cryptoPayment.Paid = accounting.CryptoPaid.ToString() + $" {paymentMethodId.CryptoCode}";
+                cryptoPayment.Overpaid = (accounting.DueUncapped > Money.Zero ? Money.Zero : -accounting.DueUncapped).ToString() + $" {paymentMethodId.CryptoCode}";
 
-		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 onchainMethod = data.GetPaymentMethodDetails() as Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod;
+                if (onchainMethod != null)
+                {
+                    cryptoPayment.Address = onchainMethod.DepositAddress;
+                }
+                cryptoPayment.Rate = ExchangeRate(data);
+                cryptoPayment.PaymentUrl = cryptoInfo.PaymentUrls.BIP21;
+                model.CryptoPayments.Add(cryptoPayment);
+            }
 
-		[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);
-		}
+            var onChainPayments = invoice
+                .GetPayments()
+                .Select<PaymentEntity, Task<object>>(async payment =>
+                {
+                    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.Output.ScriptPubKey.GetDestinationAddress(paymentNetwork.NBitcoinNetwork);
 
-		[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();
-		}
+                        int confirmationCount = 0;
+                        if ((onChainPaymentData.ConfirmationCount < paymentNetwork.MaxTrackedConfirmation && payment.Accounted)
+                             && (onChainPaymentData.Legacy || invoice.MonitoringExpiration < DateTimeOffset.UtcNow)) // The confirmation count in the paymentData is not up to date
+                        {
+                            confirmationCount = (await ((ExplorerClientProvider)_ServiceProvider.GetService(typeof(ExplorerClientProvider))).GetExplorerClient(payment.GetCryptoCode())?.GetTransactionAsync(onChainPaymentData.Outpoint.Hash))?.Confirmations ?? 0;
+                            onChainPaymentData.ConfirmationCount = confirmationCount;
+                            payment.SetCryptoPaymentData(onChainPaymentData);
+                            await _InvoiceRepository.UpdatePayments(new List<PaymentEntity> { payment });
+                        }
+                        else
+                        {
+                            confirmationCount = onChainPaymentData.ConfirmationCount;
+                        }
+                        if (confirmationCount >= paymentNetwork.MaxTrackedConfirmation)
+                        {
+                            m.Confirmations = "At least " + (paymentNetwork.MaxTrackedConfirmation);
+                        }
+                        else
+                        {
+                            m.Confirmations = confirmationCount.ToString(CultureInfo.InvariantCulture);
+                        }
 
-		[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);
-		}
+                        m.TransactionId = onChainPaymentData.Outpoint.Hash.ToString();
+                        m.ReceivedTime = payment.ReceivedTime;
+                        m.TransactionLink = string.Format(CultureInfo.InvariantCulture, paymentNetwork.BlockExplorerLink, m.TransactionId);
+                        m.Replaced = !payment.Accounted;
+                        return m;
+                    }
+                    else
+                    {
+                        var lightningPaymentData = (Payments.Lightning.LightningLikePaymentData)paymentData;
+                        return new InvoiceDetailsModel.OffChainPayment()
+                        {
+                            Crypto = paymentNetwork.CryptoCode,
+                            BOLT11 = lightningPaymentData.BOLT11
+                        };
+                    }
+                })
+                .ToArray();
+            await Task.WhenAll(onChainPayments);
+            model.Addresses = invoice.HistoricalAddresses.Select(h => new InvoiceDetailsModel.AddressModel
+            {
+                Destination = h.GetAddress(),
+                PaymentMethod = ToString(h.GetPaymentMethodId()),
+                Current = !h.UnAssigned.HasValue
+            }).ToArray();
+            model.OnChainPayments = onChainPayments.Select(p => p.GetAwaiter().GetResult()).OfType<InvoiceDetailsModel.Payment>().ToList();
+            model.OffChainPayments = onChainPayments.Select(p => p.GetAwaiter().GetResult()).OfType<InvoiceDetailsModel.OffChainPayment>().ToList();
+            model.StatusMessage = StatusMessage;
+            return View(model);
+        }
 
-		[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 });
-		}
+        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})";
+        }
 
-		[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));
-		}
+        [HttpGet]
+        [Route("i/{invoiceId}")]
+        [Route("i/{invoiceId}/{paymentMethodId}")]
+        [Route("invoice")]
+        [AcceptMediaTypeConstraint("application/bitcoin-paymentrequest", false)]
+        [XFrameOptionsAttribute(null)]
+        public async Task<IActionResult> Checkout(string invoiceId, string id = null, string paymentMethodId = null)
+        {
+            //Keep compatibility with Bitpay
+            invoiceId = invoiceId ?? id;
+            id = invoiceId;
+            ////
 
-		private async Task<SelectList> GetStores(string userId, string storeId = null)
-		{
-			return new	SelectList(await _StoreRepository.GetStoresByUserId(userId), nameof(StoreData.Id), nameof(StoreData.StoreName), storeId);
-		}
+            var model = await GetInvoiceModel(invoiceId, paymentMethodId);
+            if (model == null)
+                return NotFound();
 
-		[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,
-			});
-		}
+            return View(nameof(Checkout), model);
+        }
 
-		[TempData]
-		public string StatusMessage
-		{
-			get;
-			set;
-		}
+        private async Task<PaymentModel> GetInvoiceModel(string invoiceId, string paymentMethodIdStr)
+        {
+            var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId);
+            if (invoice == null)
+                return null;
+            var store = await _StoreRepository.FindStore(invoice.StoreId);
+            bool isDefaultCrypto = false;
+            if (paymentMethodIdStr == null)
+            {
+                paymentMethodIdStr = store.GetDefaultCrypto();
+                isDefaultCrypto = true;
+            }
 
-		private string GetUserId()
-		{
-			return _UserManager.GetUserId(User);
-		}
-	}
+            var paymentMethodId = PaymentMethodId.Parse(paymentMethodIdStr);
+            var network = _NetworkProvider.GetNetwork(paymentMethodId.CryptoCode);
+            if (network == null && isDefaultCrypto)
+            {
+                network = _NetworkProvider.GetAll().FirstOrDefault();
+                paymentMethodId = new PaymentMethodId(network.CryptoCode, PaymentTypes.BTCLike);
+                paymentMethodIdStr = paymentMethodId.ToString();
+            }
+            if (invoice == null || network == null)
+                return null;
+            if (!invoice.Support(paymentMethodId))
+            {
+                if (!isDefaultCrypto)
+                    return null;
+                var paymentMethodTemp = invoice.GetPaymentMethods(_NetworkProvider).First();
+                network = paymentMethodTemp.Network;
+                paymentMethodId = paymentMethodTemp.GetId();
+                paymentMethodIdStr = paymentMethodId.ToString();
+            }
+
+            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();
+            var model = new PaymentModel()
+            {
+                CryptoCode = network.CryptoCode,
+                PaymentMethodId = paymentMethodId.ToString(),
+                IsLightning = paymentMethodId.PaymentType == PaymentTypes.LightningLike,
+                ServerUrl = HttpContext.Request.GetAbsoluteRoot(),
+                OrderId = invoice.OrderId,
+                InvoiceId = invoice.Id,
+                DefaultLang = storeBlob.DefaultLang ?? "en-US",
+                HtmlTitle = storeBlob.HtmlTitle ?? "BTCPay Invoice",
+                CustomCSSLink = storeBlob.CustomCSS?.AbsoluteUri,
+                CustomLogoLink = storeBlob.CustomLogo?.AbsoluteUri,
+                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 ?? "/",
+                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(),
+                Status = invoice.Status,
+                CryptoImage = "/" + GetImage(paymentMethodId, network),
+                NetworkFee = paymentMethodDetails.GetTxFee(),
+                IsMultiCurrency = invoice.GetPayments().Select(p => p.GetPaymentMethodId()).Concat(new[] { paymentMethod.GetId() }).Distinct().Count() > 1,
+                AllowCoinConversion = storeBlob.AllowCoinConversion,
+                AvailableCryptos = invoice.GetPaymentMethods(_NetworkProvider)
+                                          .Where(i => i.Network != null)
+                                          .Select(kv => new PaymentModel.AvailableCrypto()
+                                          {
+                                              PaymentMethodId = kv.GetId().ToString(),
+                                              CryptoImage = "/" + GetImage(kv.GetId(), kv.Network),
+                                              Link = Url.Action(nameof(Checkout), new { invoiceId = invoiceId, paymentMethodId = kv.GetId().ToString() })
+                                          }).Where(c => c.CryptoImage != "/")
+                .ToList()
+            };
+
+            var expiration = TimeSpan.FromSeconds(model.ExpirationSeconds);
+            model.TimeLeft = expiration.PrettyPrint();
+            return model;
+        }
+
+        private string GetImage(PaymentMethodId paymentMethodId, BTCPayNetwork network)
+        {
+            return (paymentMethodId.PaymentType == PaymentTypes.BTCLike ? Url.Content(network.CryptoImagePath) : Url.Content(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 FormatCurrency(productInformation.Price, productInformation.Currency, _CurrencyNameTable);
+        }
+        private string ExchangeRate(PaymentMethod paymentMethod)
+        {
+            string currency = paymentMethod.ParentEntity.ProductInformation.Currency;
+            return FormatCurrency(paymentMethod.Rate, currency, _CurrencyNameTable);
+        }
+
+        public static string FormatCurrency(decimal price, string currency, CurrencyNameTable currencies)
+        {
+            var provider = currencies.GetNumberFormatInfo(currency, true);
+            var currencyData = currencies.GetCurrencyData(currency, true);
+            var divisibility = currencyData.Divisibility;
+            while (true)
+            {
+                var rounded = decimal.Round(price, divisibility, MidpointRounding.AwayFromZero);
+                if ((Math.Abs(rounded - price) / price) < 0.001m)
+                {
+                    price = rounded;
+                    break;
+                }
+                divisibility++;
+            }
+            if (divisibility != provider.CurrencyDecimalDigits)
+            {
+                provider = (NumberFormatInfo)provider.Clone();
+                provider.CurrencyDecimalDigits = divisibility;
+            }
+            
+            if (currencyData.Crypto)
+                return price.ToString("C", provider);
+            else
+                return price.ToString("C", provider) + $" ({currency})";
+        }
+
+        [HttpGet]
+        [Route("i/{invoiceId}/status")]
+        [Route("i/{invoiceId}/{paymentMethodId}/status")]
+        public async Task<IActionResult> GetStatus(string invoiceId, string paymentMethodId = null)
+        {
+            var model = await GetInvoiceModel(invoiceId, paymentMethodId);
+            if (model == null)
+                return NotFound();
+            return Json(model);
+        }
+
+        [HttpGet]
+        [Route("i/{invoiceId}/status/ws")]
+        public async Task<IActionResult> GetStatusWebSocket(string invoiceId)
+        {
+            if (!HttpContext.WebSockets.IsWebSocketRequest)
+                return NotFound();
+            var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId);
+            if (invoice == null || invoice.Status == "complete" || invoice.Status == "invalid" || invoice.Status == "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.InvoiceId, 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")]
+        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)
+        {
+            var model = new InvoicesModel();
+            var filterString = new SearchString(searchTerm);
+            foreach (var invoice in await _InvoiceRepository.GetInvoices(new InvoiceQuery()
+            {
+                TextSearch = filterString.TextSearch,
+                Count = count,
+                Skip = skip,
+                UserId = GetUserId(),
+                Unusual = !filterString.Filters.ContainsKey("unusual") ? null
+                          : !bool.TryParse(filterString.Filters["unusual"].First(), out var r) ? (bool?)null
+                          : r,
+                Status = filterString.Filters.ContainsKey("status") ? filterString.Filters["status"].ToArray() : null,
+                ExceptionStatus = filterString.Filters.ContainsKey("exceptionstatus") ? filterString.Filters["exceptionstatus"].ToArray() : null,
+                StoreId = filterString.Filters.ContainsKey("storeid") ? filterString.Filters["storeid"].ToArray() : null
+            }))
+            {
+                model.SearchTerm = searchTerm;
+                model.Invoices.Add(new InvoiceModel()
+                {
+                    Status = invoice.Status + (invoice.ExceptionStatus == null ? string.Empty : $" ({invoice.ExceptionStatus})"),
+                    ShowCheckout = invoice.Status == "new",
+                    Date = invoice.InvoiceTime,
+                    InvoiceId = invoice.Id,
+                    OrderId = invoice.OrderId ?? string.Empty,
+                    RedirectUrl = invoice.RedirectURL ?? string.Empty,
+                    AmountCurrency = $"{invoice.ProductInformation.Price.ToString(CultureInfo.InvariantCulture)} {invoice.ProductInformation.Currency}"
+                });
+            }
+            model.Skip = skip;
+            model.Count = count;
+            model.StatusMessage = StatusMessage;
+            return View(model);
+        }
+
+        [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");
+            }
+            return View(new CreateInvoiceModel() { Stores = stores });
+        }
+
+        [HttpPost]
+        [Route("invoices/create")]
+        [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
+        [BitpayAPIConstraint(false)]
+        public async Task<IActionResult> CreateInvoice(CreateInvoiceModel model)
+        {
+            var stores = await _StoreRepository.GetStoresByUserId(GetUserId());
+            model.Stores = new SelectList(stores, nameof(StoreData.Id), nameof(StoreData.StoreName), model.StoreId);
+            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.CanModifyStoreSettings.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 Invoice()
+                {
+                    Price = model.Amount.Value,
+                    Currency = model.Currency,
+                    PosData = model.PosData,
+                    OrderId = model.OrderId,
+                    //RedirectURL = redirect + "redirect",
+                    NotificationURL = model.NotificationUrl,
+                    ItemDesc = model.ItemDesc,
+                    FullNotifications = true,
+                    BuyerEmail = model.BuyerEmail,
+                }, store, HttpContext.Request.GetAbsoluteRoot());
+
+                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]
+        [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
+        [BitpayAPIConstraint(false)]
+        public IActionResult SearchInvoice(InvoicesModel invoices)
+        {
+            return RedirectToAction(nameof(ListInvoices), new
+            {
+                searchTerm = invoices.SearchTerm,
+                skip = invoices.Skip,
+                count = invoices.Count,
+            });
+        }
+
+        [HttpPost]
+        [Route("invoices/invalidatepaid")]
+        [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
+        [BitpayAPIConstraint(false)]
+        public async Task<IActionResult> InvalidatePaidInvoice(string invoiceId)
+        {
+            await _InvoiceRepository.UpdatePaidInvoiceToInvalid(invoiceId);
+            _EventAggregator.Publish(new InvoiceEvent(invoiceId, 1008, "invoice_markedInvalid"));
+            return RedirectToAction(nameof(ListInvoices));
+        }
+
+        [TempData]
+        public string StatusMessage
+        {
+            get;
+            set;
+        }
+
+        private string GetUserId()
+        {
+            return _UserManager.GetUserId(User);
+        }
+    }
 }

BTCPayServer/Controllers/InvoiceController.cs

@@ -29,87 +29,283 @@ using BTCPayServer.Services;
 using System.ComponentModel.DataAnnotations;
 using System.Text.RegularExpressions;
 using BTCPayServer.Services.Stores;
-using BTCPayServer.Servcices.Invoices;
+using BTCPayServer.Services.Invoices;
 using BTCPayServer.Services.Rates;
 using BTCPayServer.Services.Wallets;
 using BTCPayServer.Validations;
 
 using Microsoft.EntityFrameworkCore;
 using Microsoft.AspNetCore.Mvc.Routing;
+using NBXplorer.DerivationStrategy;
+using NBXplorer;
+using BTCPayServer.HostedServices;
+using BTCPayServer.Payments;
+using BTCPayServer.Rating;
 
 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;
+        BTCPayRateProviderFactory _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,
+            BTCPayRateProviderFactory rateProvider,
+            StoreRepository storeRepository,
+            EventAggregator eventAggregator,
+            BTCPayWalletProvider walletProvider,
+            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;
+        }
 
-		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(Invoice invoice, StoreData store, string serverUrl)
+        {
+            var entity = new InvoiceEntity
+            {
+                InvoiceTime = DateTimeOffset.UtcNow
+            };
 
-			entity = await _InvoiceRepository.CreateInvoiceAsync(store.Id, entity);
-			await _Wallet.MapAsync(entity.DepositAddress.ScriptPubKey, entity.Id);
-			await _Watcher.WatchAsync(entity.Id);
-			var resp = entity.EntityToDTO();
-			return new DataWrapper<InvoiceResponse>(resp) { Facade = "pos/invoice" };
-		}
+            var storeBlob = store.GetStoreBlob();
+            Uri notificationUri = Uri.IsWellFormedUriString(invoice.NotificationURL, UriKind.Absolute) ? new Uri(invoice.NotificationURL, UriKind.Absolute) : null;
+            if (notificationUri == null || (notificationUri.Scheme != "http" && notificationUri.Scheme != "https")) //TODO: Filer non routable addresses ?
+                notificationUri = null;
+            EmailAddressAttribute emailValidator = new EmailAddressAttribute();
+            entity.ExpirationTime = entity.InvoiceTime.AddMinutes(storeBlob.InvoiceExpiration);
+            entity.MonitoringExpiration = entity.ExpirationTime + TimeSpan.FromMinutes(storeBlob.MonitoringExpiration);
+            entity.OrderId = invoice.OrderId;
+            entity.ServerUrl = serverUrl;
+            entity.FullNotifications = invoice.FullNotifications || invoice.ExtendedNotifications;
+            entity.ExtendedNotifications = invoice.ExtendedNotifications;
+            entity.NotificationURL = notificationUri?.AbsoluteUri;
+            entity.BuyerInformation = Map<Invoice, BuyerInformation>(invoice);
+            entity.PaymentTolerance = storeBlob.PaymentTolerance;
+            //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;
+            }
+            entity.ProductInformation = Map<Invoice, ProductInformation>(invoice);
+            entity.RedirectURL = invoice.RedirectURL ?? store.StoreWebsite;
+            if (!Uri.IsWellFormedUriString(entity.RedirectURL, UriKind.Absolute))
+                entity.RedirectURL = null;
 
-		private TDest Map<TFrom, TDest>(TFrom data)
-		{
-			return JsonConvert.DeserializeObject<TDest>(JsonConvert.SerializeObject(data));
-		}
-	}
+            entity.Status = "new";
+            entity.SpeedPolicy = ParseSpeedPolicy(invoice.TransactionSpeed, store.SpeedPolicy);
+
+
+            HashSet<CurrencyPair> currencyPairsToFetch = new HashSet<CurrencyPair>();
+            var rules = storeBlob.GetRateRules(_NetworkProvider);
+
+            foreach (var network in store.GetSupportedPaymentMethods(_NetworkProvider)
+                                               .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);
+
+            var supportedPaymentMethods = store.GetSupportedPaymentMethods(_NetworkProvider)
+                                               .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)))
+                                                .ToList();
+
+            List<string> paymentMethodErrors = new List<string>();
+            List<ISupportedPaymentMethod> supported = new List<ISupportedPaymentMethod>();
+            var paymentMethods = new PaymentMethodDictionary();
+
+            foreach(var pair in fetchingByCurrencyPair)
+            {
+                var rateResult = await pair.Value;
+                bool hasError = false;
+                if(rateResult.Errors.Count != 0)
+                {
+                    var allRateRuleErrors = string.Join(", ", rateResult.Errors.ToArray());
+                    paymentMethodErrors.Add($"{pair.Key}: Rate rule error ({allRateRuleErrors})");
+                    hasError = true;
+                }
+                if(rateResult.ExchangeExceptions.Count != 0)
+                {
+                    foreach(var ex in rateResult.ExchangeExceptions)
+                    {
+                        paymentMethodErrors.Add($"{pair.Key}: Exception reaching exchange {ex.ExchangeName} ({ex.Exception.Message})");
+                    }
+                    hasError = true;
+                }
+                if(hasError)
+                {
+                    paymentMethodErrors.Add($"{pair.Key}: The rule is {rateResult.Rule}");
+                    paymentMethodErrors.Add($"{pair.Key}: Evaluated rule is {rateResult.EvaluatedRule}");
+                }
+            }
+
+            foreach (var o in supportedPaymentMethods)
+            {
+                try
+                {
+                    var paymentMethod = await o.PaymentMethod;
+                    if (paymentMethod == null)
+                        throw new PaymentMethodUnavailableException("Payment method unavailable");
+                    supported.Add(o.SupportedPaymentMethod);
+                    paymentMethods.Add(paymentMethod);
+                }
+                catch (PaymentMethodUnavailableException ex)
+                {
+                    paymentMethodErrors.Add($"{o.SupportedPaymentMethod.PaymentId.CryptoCode} ({o.SupportedPaymentMethod.PaymentId.PaymentType}): Payment method unavailable ({ex.Message})");
+                }
+                catch (Exception ex)
+                {
+                    paymentMethodErrors.Add($"{o.SupportedPaymentMethod.PaymentId.CryptoCode} ({o.SupportedPaymentMethod.PaymentId.PaymentType}): Unexpected exception ({ex.ToString()})");
+                }
+            }
+
+            if (supported.Count == 0)
+            {
+                StringBuilder errors = new StringBuilder();
+                errors.AppendLine("No payment method available for this store");
+                foreach (var error in paymentMethodErrors)
+                {
+                    errors.AppendLine(error);
+                }
+                throw new BitpayHttpException(400, errors.ToString());
+            }
+
+            entity.SetSupportedPaymentMethods(supported);
+            entity.SetPaymentMethods(paymentMethods);
+            entity.PosData = invoice.PosData;
+            entity = await _InvoiceRepository.CreateInvoiceAsync(store.Id, entity, paymentMethodErrors, _NetworkProvider);
+
+            _EventAggregator.Publish(new Events.InvoiceEvent(entity, 1001, "invoice_created"));
+            var resp = entity.EntityToDTO(_NetworkProvider);
+            return new DataWrapper<InvoiceResponse>(resp) { Facade = "pos/invoice" };
+        }
+
+        private async Task<PaymentMethod> CreatePaymentMethodAsync(Dictionary<CurrencyPair, Task<RateResult>> fetchingByCurrencyPair, IPaymentMethodHandler handler, ISupportedPaymentMethod supportedPaymentMethod, BTCPayNetwork network, InvoiceEntity entity, StoreData store)
+        {
+            var storeBlob = store.GetStoreBlob();
+            var rate = await fetchingByCurrencyPair[new CurrencyPair(network.CryptoCode, entity.ProductInformation.Currency)];
+            if (rate.Value == null)
+                return null;
+            PaymentMethod paymentMethod = new PaymentMethod();
+            paymentMethod.ParentEntity = entity;
+            paymentMethod.Network = network;
+            paymentMethod.SetId(supportedPaymentMethod.PaymentId);
+            paymentMethod.Rate = rate.Value.Value;
+            var paymentDetails = await handler.CreatePaymentMethodDetails(supportedPaymentMethod, paymentMethod, store, network);
+            if (storeBlob.NetworkFeeDisabled)
+                paymentDetails.SetNoTxFee();
+            paymentMethod.SetPaymentMethodDetails(paymentDetails);
+
+            Func<Money, Money, bool> compare = null;
+            CurrencyValue limitValue = null;
+            string errorMessage = null;
+            if (supportedPaymentMethod.PaymentId.PaymentType == PaymentTypes.LightningLike &&
+               storeBlob.LightningMaxValue != null)
+            {
+                compare = (a, b) => a > b;
+                limitValue = storeBlob.LightningMaxValue;
+                errorMessage = "The amount of the invoice is too high to be paid with lightning";
+            }
+            else if (supportedPaymentMethod.PaymentId.PaymentType == PaymentTypes.BTCLike &&
+               storeBlob.OnChainMinValue != null)
+            {
+                compare = (a, b) => a < b;
+                limitValue = storeBlob.OnChainMinValue;
+                errorMessage = "The amount of the invoice is too low to be paid on chain";
+            }
+
+            if (compare != null)
+            {
+                var limitValueRate = await fetchingByCurrencyPair[new CurrencyPair(network.CryptoCode, limitValue.Currency)];
+                if (limitValueRate.Value.HasValue)
+                {
+                    var limitValueCrypto = Money.Coins(limitValue.Value / limitValueRate.Value.Value);
+                    if (compare(paymentMethod.Calculate().Due, limitValueCrypto))
+                    {
+                        throw new PaymentMethodUnavailableException(errorMessage);
+                    }
+                }
+            }
+            ///////////////
+
+
+#pragma warning disable CS0618
+            if (paymentMethod.GetId().IsBTCOnChain)
+            {
+                entity.TxFee = paymentMethod.TxFee;
+                entity.Rate = paymentMethod.Rate;
+                entity.DepositAddress = paymentMethod.DepositAddress;
+            }
+#pragma warning restore CS0618
+            return paymentMethod;
+        }
+
+        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/PaymentRequestActionResult.cs

@@ -7,34 +7,34 @@ 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;
-		}
-	}
+    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/RateController.cs

@@ -7,34 +7,128 @@ using System.Linq;
 using System.Threading.Tasks;
 using BTCPayServer.Filters;
 using BTCPayServer.Services.Rates;
+using BTCPayServer.Services.Stores;
+using BTCPayServer.Rating;
+using Newtonsoft.Json;
 
 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));
-		}
+    public class RateController : Controller
+    {
+        BTCPayRateProviderFactory _RateProviderFactory;
+        BTCPayNetworkProvider _NetworkProvider;
+        CurrencyNameTable _CurrencyNameTable;
+        StoreRepository _StoreRepo;
+        public RateController(
+            BTCPayRateProviderFactory rateProviderFactory,
+            BTCPayNetworkProvider networkProvider,
+            StoreRepository storeRepo,
+            CurrencyNameTable currencyNameTable)
+        {
+            _RateProviderFactory = rateProviderFactory ?? throw new ArgumentNullException(nameof(rateProviderFactory));
+            _NetworkProvider = networkProvider;
+            _StoreRepo = storeRepo;
+            _CurrencyNameTable = currencyNameTable ?? throw new ArgumentNullException(nameof(currencyNameTable));
+        }
 
-		[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());
+        [Route("rates")]
+        [HttpGet]
+        [BitpayAPIConstraint]
+        public async Task<IActionResult> GetRates(string currencyPairs, string storeId)
+        {
+            storeId = storeId ?? this.HttpContext.GetStoreData()?.Id;
+            var result = await GetRates2(currencyPairs, storeId);
+            var rates = (result as JsonResult)?.Value as Rate[];
+            if (rates == null)
+                return result;
+            return Json(new DataWrapper<Rate[]>(rates));
+        }
 
-		}
-	}
+        [Route("api/rates")]
+        [HttpGet]
+        public async Task<IActionResult> GetRates2(string currencyPairs, string storeId)
+        {
+            if(storeId == null || currencyPairs == null)
+            {
+                var result = Json(new BitpayErrorsModel() { Error = "You need to specify storeId (in your store settings) and currencyPairs (eg. BTC_USD,LTC_CAD)" });
+                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;
+            }
+            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);
+            await Task.WhenAll(fetching.Select(f => f.Value).ToArray());
+            return Json(pairs
+                            .Select(r => (Pair: r, Value: fetching[r].GetAwaiter().GetResult().Value))
+                            .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());
+        }
+
+        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.cs

@@ -1,7 +1,9 @@
-using BTCPayServer.Models;
+using BTCPayServer.HostedServices;
+using BTCPayServer.Models;
 using BTCPayServer.Models.ServerViewModels;
 using BTCPayServer.Services;
 using BTCPayServer.Services.Mails;
+using BTCPayServer.Services.Rates;
 using BTCPayServer.Validations;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Identity;
@@ -11,87 +13,257 @@ using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
 using System.Linq;
 using System.Net;
+using System.Net.Http;
 using System.Net.Mail;
 using System.Threading.Tasks;
 
 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 class ServerController : Controller
+    {
+        private UserManager<ApplicationUser> _UserManager;
+        SettingsRepository _SettingsRepository;
+        private BTCPayRateProviderFactory _RateProviderFactory;
 
-		public ServerController(UserManager<ApplicationUser> userManager, SettingsRepository settingsRepository)
-		{
-			_UserManager = userManager;
-			_SettingsRepository = settingsRepository;
-		}
+        public ServerController(UserManager<ApplicationUser> userManager,
+            BTCPayRateProviderFactory rateProviderFactory,
+            SettingsRepository settingsRepository)
+        {
+            _UserManager = userManager;
+            _SettingsRepository = settingsRepository;
+            _RateProviderFactory = rateProviderFactory;
+        }
 
-		[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);
+        }
+
+        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();
+            var roles = await _UserManager.GetRolesAsync(user);
+            var isAdmin = IsAdmin(roles);
+            bool updated = false;
+
+            if (isAdmin != viewModel.IsAdmin)
+            {
+                if (viewModel.IsAdmin)
+                    await _UserManager.AddToRoleAsync(user, Roles.ServerAdmin);
+                else
+                    await _UserManager.RemoveFromRoleAsync(user, Roles.ServerAdmin);
+                updated = true;
+            }
+            if (updated)
+            {
+                viewModel.StatusMessage = "User successfully updated";
+            }
+            return View(viewModel);
+        }
+
+
+        [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();
+            return View("Confirm", new ConfirmModel()
+            {
+                Title = "Delete user " + user.Email,
+                Description = "This user will be permanently deleted",
+                Action = "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);
+            StatusMessage = "User deleted";
+            return RedirectToAction(nameof(ListUsers));
+        }
+
+        [TempData]
+        public string StatusMessage
+        {
+            get; set;
+        }
+
+        [Route("server/emails")]
+        public async Task<IActionResult> Emails()
+        {
+            var data = (await _SettingsRepository.GetSettingAsync<EmailSettings>()) ?? new EmailSettings();
+            return View(new EmailsViewModel() { Settings = data });
+        }
+
+        [Route("server/policies")]
+        public async Task<IActionResult> Policies()
+        {
+            var data = (await _SettingsRepository.GetSettingAsync<PoliciesSettings>()) ?? new PoliciesSettings();
+            return View(data);
+        }
+        [Route("server/policies")]
+        [HttpPost]
+        public async Task<IActionResult> Policies(PoliciesSettings settings)
+        {
+            await _SettingsRepository.UpdateSetting(settings);
+            TempData["StatusMessage"] = "Policies updated successfully";
+            return View(settings);
+        }
+
+        [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")]
+        [HttpPost]
+        public async Task<IActionResult> Emails(EmailsViewModel model, string command)
+        {
+            if (command == "Test")
+            {
+                try
+                {
+                    if(!model.Settings.IsComplete())
+                    {
+                        model.StatusMessage = "Error: Required fields missing";
+                        return View(model);
+                    }
+                    var client = model.Settings.CreateSmtpClient();
+                    await client.SendMailAsync(model.Settings.From, model.TestEmail, "BTCPay test", "BTCPay test");
+                    model.StatusMessage = "Email sent to " + model.TestEmail + ", please, verify you received it";
+                }
+                catch (Exception ex)
+                {
+                    model.StatusMessage = "Error: " + ex.Message;
+                }
+                return View(model);
+            }
+            else // if(command == "Save")
+            {
+                await _SettingsRepository.UpdateSetting(model.Settings);
+                model.StatusMessage = "Email settings saved";
+                return View(model);
+            }
+        }
+    }
 }

BTCPayServer/Controllers/StoresController.BTCLike.cs

@@ -0,0 +1,422 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Net.WebSockets;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Data;
+using BTCPayServer.Models.StoreViewModels;
+using BTCPayServer.Payments;
+using BTCPayServer.Services;
+using LedgerWallet;
+using Microsoft.AspNetCore.Mvc;
+using NBitcoin;
+using NBXplorer.DerivationStrategy;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Controllers
+{
+    public partial class StoresController
+    {
+        [HttpGet]
+        [Route("{storeId}/derivations/{cryptoCode}")]
+        public IActionResult AddDerivationScheme(string storeId, string cryptoCode)
+        {
+            var store = HttpContext.GetStoreData();
+            if (store == null)
+                return NotFound();
+            var network = cryptoCode == null ? null : _ExplorerProvider.GetNetwork(cryptoCode);
+            if (network == null)
+            {
+                return NotFound();
+            }
+
+            DerivationSchemeViewModel vm = new DerivationSchemeViewModel();
+            vm.ServerUrl = GetStoreUrl(storeId);
+            vm.CryptoCode = cryptoCode;
+            vm.RootKeyPath = network.GetRootKeyPath();
+            SetExistingValues(store, vm);
+            return View(vm);
+        }
+
+        private void SetExistingValues(StoreData store, DerivationSchemeViewModel vm)
+        {
+            vm.DerivationScheme = GetExistingDerivationStrategy(vm.CryptoCode, store)?.DerivationStrategyBase.ToString();
+        }
+
+        private DerivationStrategy GetExistingDerivationStrategy(string cryptoCode, StoreData store)
+        {
+            var id = new PaymentMethodId(cryptoCode, PaymentTypes.BTCLike);
+            var existing = store.GetSupportedPaymentMethods(_NetworkProvider)
+                .OfType<DerivationStrategy>()
+                .FirstOrDefault(d => d.PaymentId == id);
+            return existing;
+        }
+
+        [HttpPost]
+        [Route("{storeId}/derivations/{cryptoCode}")]
+        public async Task<IActionResult> AddDerivationScheme(string storeId, DerivationSchemeViewModel vm, string cryptoCode)
+        {
+            vm.ServerUrl = GetStoreUrl(storeId);
+            vm.CryptoCode = cryptoCode;
+            var store = HttpContext.GetStoreData();
+            if (store == null)
+                return NotFound();
+
+            var network = cryptoCode == null ? null : _ExplorerProvider.GetNetwork(cryptoCode);
+            if (network == null)
+            {
+                return NotFound();
+            }
+            vm.RootKeyPath = network.GetRootKeyPath();
+            var wallet = _WalletProvider.GetWallet(network);
+            if (wallet == null)
+            {
+                return NotFound();
+            }
+
+            PaymentMethodId paymentMethodId = new PaymentMethodId(network.CryptoCode, PaymentTypes.BTCLike);
+            DerivationStrategy strategy = null;
+            try
+            {
+                if (!string.IsNullOrEmpty(vm.DerivationScheme))
+                {
+                    strategy = ParseDerivationStrategy(vm.DerivationScheme, null, network);
+                    vm.DerivationScheme = strategy.ToString();
+                }
+            }
+            catch
+            {
+                ModelState.AddModelError(nameof(vm.DerivationScheme), "Invalid Derivation Scheme");
+                vm.Confirmation = false;
+                return View(vm);
+            }
+
+            if (!vm.Confirmation && strategy != null)
+                return ShowAddresses(vm, strategy);
+
+            if (vm.Confirmation && !string.IsNullOrWhiteSpace(vm.HintAddress))
+            {
+                BitcoinAddress address = null;
+                try
+                {
+                    address = BitcoinAddress.Create(vm.HintAddress, network.NBitcoinNetwork);
+                }
+                catch
+                {
+                    ModelState.AddModelError(nameof(vm.HintAddress), "Invalid hint address");
+                    return ShowAddresses(vm, strategy);
+                }
+
+                try
+                {
+                    strategy = ParseDerivationStrategy(vm.DerivationScheme, address.ScriptPubKey, network);
+                }
+                catch
+                {
+                    ModelState.AddModelError(nameof(vm.HintAddress), "Impossible to find a match with this address");
+                    return ShowAddresses(vm, strategy);
+                }
+                vm.HintAddress = "";
+                vm.StatusMessage = "Address successfully found, please verify that the rest is correct and click on \"Confirm\"";
+                ModelState.Remove(nameof(vm.HintAddress));
+                ModelState.Remove(nameof(vm.DerivationScheme));
+                return ShowAddresses(vm, strategy);
+            }
+            else
+            {
+                try
+                {
+                    if (strategy != null)
+                        await wallet.TrackAsync(strategy.DerivationStrategyBase);
+                    store.SetSupportedPaymentMethod(paymentMethodId, strategy);
+                }
+                catch
+                {
+                    ModelState.AddModelError(nameof(vm.DerivationScheme), "Invalid Derivation Scheme");
+                    return View(vm);
+                }
+
+                await _Repo.UpdateStore(store);
+                StatusMessage = $"Derivation scheme for {network.CryptoCode} has been modified.";
+                return RedirectToAction(nameof(UpdateStore), new { storeId = storeId });
+            }
+        }
+
+        private IActionResult ShowAddresses(DerivationSchemeViewModel vm, DerivationStrategy strategy)
+        {
+            vm.DerivationScheme = strategy.DerivationStrategyBase.ToString();
+            if (!string.IsNullOrEmpty(vm.DerivationScheme))
+            {
+                var line = strategy.DerivationStrategyBase.GetLineFor(DerivationFeature.Deposit);
+
+                for (int i = 0; i < 10; i++)
+                {
+                    var address = line.Derive((uint)i);
+                    vm.AddressSamples.Add((DerivationStrategyBase.GetKeyPath(DerivationFeature.Deposit).Derive((uint)i).ToString(), address.ScriptPubKey.GetDestinationAddress(strategy.Network.NBitcoinNetwork).ToString()));
+                }
+            }
+            vm.Confirmation = true;
+            return View(vm);
+        }
+
+
+        public class GetInfoResult
+        {
+            public int RecommendedSatoshiPerByte { get; set; }
+            public double Balance { get; set; }
+        }
+
+        public class SendToAddressResult
+        {
+            public string TransactionId { get; set; }
+        }
+
+        [HttpGet]
+        [Route("{storeId}/ws/ledger")]
+        public async Task<IActionResult> LedgerConnection(
+            string storeId,
+            string command,
+            // getinfo
+            string cryptoCode = null,
+            // getxpub
+            int account = 0,
+            // sendtoaddress
+            string destination = null, string amount = null, string feeRate = null, string substractFees = null
+            )
+        {
+            if (!HttpContext.WebSockets.IsWebSocketRequest)
+                return NotFound();
+            var store = HttpContext.GetStoreData();
+            if (store == null)
+                return NotFound();
+
+            var webSocket = await HttpContext.WebSockets.AcceptWebSocketAsync();
+
+            var hw = new HardwareWalletService(webSocket);
+            object result = null;
+            try
+            {
+                BTCPayNetwork network = null;
+                if (cryptoCode != null)
+                {
+                    network = _NetworkProvider.GetNetwork(cryptoCode);
+                    if (network == null)
+                        throw new FormatException("Invalid value for crypto code");
+                }
+
+                BitcoinAddress destinationAddress = null;
+                if (destination != null)
+                {
+                    try
+                    {
+                        destinationAddress = BitcoinAddress.Create(destination, network.NBitcoinNetwork);
+                    }
+                    catch { }
+                    if (destinationAddress == null)
+                        throw new FormatException("Invalid value for destination");
+                }
+
+                FeeRate feeRateValue = null;
+                if (feeRate != null)
+                {
+                    try
+                    {
+                        feeRateValue = new FeeRate(Money.Satoshis(int.Parse(feeRate, CultureInfo.InvariantCulture)), 1);
+                    }
+                    catch { }
+                    if (feeRateValue == null || feeRateValue.FeePerK <= Money.Zero)
+                        throw new FormatException("Invalid value for fee rate");
+                }
+
+                Money amountBTC = null;
+                if (amount != null)
+                {
+                    try
+                    {
+                        amountBTC = Money.Parse(amount);
+                    }
+                    catch { }
+                    if (amountBTC == null || amountBTC <= Money.Zero)
+                        throw new FormatException("Invalid value for amount");
+                }
+
+                bool subsctractFeesValue = false;
+                if (substractFees != null)
+                {
+                    try
+                    {
+                        subsctractFeesValue = bool.Parse(substractFees);
+                    }
+                    catch { throw new FormatException("Invalid value for subtract fees"); }
+                }
+                if (command == "test")
+                {
+                    result = await hw.Test();
+                }
+                if (command == "getxpub")
+                {
+                    var getxpubResult = await hw.GetExtPubKey(network, account);
+                    result = getxpubResult;
+                }
+                if (command == "getinfo")
+                {
+                    var strategy = GetDirectDerivationStrategy(store, network);
+                    var strategyBase = GetDerivationStrategy(store, network);
+                    if (strategy == null || await hw.GetKeyPath(network, strategy) == null)
+                    {
+                        throw new Exception($"This store is not configured to use this ledger");
+                    }
+
+                    var feeProvider = _FeeRateProvider.CreateFeeProvider(network);
+                    var recommendedFees = feeProvider.GetFeeRateAsync();
+                    var balance = _WalletProvider.GetWallet(network).GetBalance(strategyBase);
+                    result = new GetInfoResult() { Balance = (double)(await balance).ToDecimal(MoneyUnit.BTC), RecommendedSatoshiPerByte = (int)(await recommendedFees).GetFee(1).Satoshi };
+                }
+
+                if (command == "sendtoaddress")
+                {
+                    if (!_Dashboard.IsFullySynched(network.CryptoCode, out var summary))
+                        throw new Exception($"{network.CryptoCode}: not started or fully synched");
+                    var strategy = GetDirectDerivationStrategy(store, network);
+                    var strategyBase = GetDerivationStrategy(store, network);
+                    var wallet = _WalletProvider.GetWallet(network);
+                    var change = wallet.GetChangeAddressAsync(strategyBase);
+
+                    var unspentCoins = await wallet.GetUnspentCoins(strategyBase);
+                    var changeAddress = await change;
+                    var send = new[] { (
+                        destination: destinationAddress as IDestination, 
+                        amount: amountBTC,
+                        substractFees: subsctractFeesValue) };
+
+                    foreach (var element in send)
+                    {
+                        if (element.destination == null)
+                            throw new ArgumentNullException(nameof(element.destination));
+                        if (element.amount == null)
+                            throw new ArgumentNullException(nameof(element.amount));
+                        if (element.amount <= Money.Zero)
+                            throw new ArgumentOutOfRangeException(nameof(element.amount), "The amount should be above zero");
+                    }
+
+                    var foundKeyPath = await hw.GetKeyPath(network, strategy);
+                    if (foundKeyPath == null)
+                    {
+                        throw new HardwareWalletException($"This store is not configured to use this ledger");
+                    }
+
+                    TransactionBuilder builder = new TransactionBuilder();
+                    builder.StandardTransactionPolicy.MinRelayTxFee = summary.Status.BitcoinStatus.MinRelayTxFee;
+                    builder.SetConsensusFactory(network.NBitcoinNetwork);
+                    builder.AddCoins(unspentCoins.Select(c => c.Coin).ToArray());
+
+                    foreach (var element in send)
+                    {
+                        builder.Send(element.destination, element.amount);
+                        if (element.substractFees)
+                            builder.SubtractFees();
+                    }
+                    builder.SetChange(changeAddress.Item1);
+                    builder.SendEstimatedFees(feeRateValue);
+                    builder.Shuffle();
+                    var unsigned = builder.BuildTransaction(false);
+
+                    var keypaths = new Dictionary<Script, KeyPath>();
+                    foreach (var c in unspentCoins)
+                    {
+                        keypaths.TryAdd(c.Coin.ScriptPubKey, c.KeyPath);
+                    }
+
+                    var hasChange = unsigned.Outputs.Count == 2;
+                    var usedCoins = builder.FindSpentCoins(unsigned);
+
+                    Dictionary<uint256, Transaction> parentTransactions = new Dictionary<uint256, Transaction>();
+
+                    if(!strategy.Segwit)
+                    {
+                        var parentHashes = usedCoins.Select(c => c.Outpoint.Hash).ToHashSet();
+                        var explorer = _ExplorerProvider.GetExplorerClient(network);
+                        var getTransactionAsyncs = parentHashes.Select(h => (Op: explorer.GetTransactionAsync(h), Hash: h)).ToList();
+                        foreach(var getTransactionAsync in getTransactionAsyncs)
+                        {
+                            var tx = (await getTransactionAsync.Op);
+                            if(tx == null)
+                                throw new Exception($"Parent transaction {getTransactionAsync.Hash} not found");
+                            parentTransactions.Add(tx.Transaction.GetHash(), tx.Transaction);
+                        }
+                    }
+
+                    var transaction = await hw.SignTransactionAsync(usedCoins.Select(c => new SignatureRequest
+                    {
+                        InputTransaction = parentTransactions.TryGet(c.Outpoint.Hash),
+                        InputCoin = c,
+                        KeyPath = foundKeyPath.Derive(keypaths[c.TxOut.ScriptPubKey]),
+                        PubKey = strategy.Root.Derive(keypaths[c.TxOut.ScriptPubKey]).PubKey
+                    }).ToArray(), unsigned, hasChange ? foundKeyPath.Derive(changeAddress.Item2) : null);
+                    
+                    try
+                    {
+                        var broadcastResult = await wallet.BroadcastTransactionsAsync(new List<Transaction>() { transaction });
+                        if (!broadcastResult[0].Success)
+                        {
+                            throw new Exception($"RPC Error while broadcasting: {broadcastResult[0].RPCCode} {broadcastResult[0].RPCCodeMessage} {broadcastResult[0].RPCMessage}");
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        throw new Exception("Error while broadcasting: " + ex.Message);
+                    }
+                    wallet.InvalidateCache(strategyBase);
+                    result = new SendToAddressResult() { TransactionId = transaction.GetHash().ToString() };
+                }
+            }
+            catch (OperationCanceledException)
+            { result = new LedgerTestResult() { Success = false, Error = "Timeout" }; }
+            catch (Exception ex)
+            { result = new LedgerTestResult() { Success = false, Error = ex.Message }; }
+
+            try
+            {
+                if (result != null)
+                {
+                    UTF8Encoding UTF8NOBOM = new UTF8Encoding(false);
+                    var bytes = UTF8NOBOM.GetBytes(JsonConvert.SerializeObject(result, _MvcJsonOptions.SerializerSettings));
+                    await webSocket.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Text, true, new CancellationTokenSource(2000).Token);
+                }
+            }
+            catch { }
+            finally
+            {
+                await webSocket.CloseSocket();
+            }
+
+            return new EmptyResult();
+        }
+
+        private DirectDerivationStrategy GetDirectDerivationStrategy(StoreData store, BTCPayNetwork network)
+        {
+            var strategy = GetDerivationStrategy(store, network);
+            var directStrategy = strategy as DirectDerivationStrategy;
+            if (directStrategy == null)
+                directStrategy = (strategy as P2SHDerivationStrategy).Inner as DirectDerivationStrategy;
+            return directStrategy;
+        }
+
+        private DerivationStrategyBase GetDerivationStrategy(StoreData store, BTCPayNetwork network)
+        {
+            var strategy = store
+                            .GetSupportedPaymentMethods(_NetworkProvider)
+                            .OfType<DerivationStrategy>()
+                            .FirstOrDefault(s => s.Network.NBitcoinNetwork == network.NBitcoinNetwork);
+            if (strategy == null)
+            {
+                throw new Exception($"Derivation strategy for {network.CryptoCode} is not set");
+            }
+
+            return strategy.DerivationStrategyBase;
+        }
+    }
+}

BTCPayServer/Controllers/StoresController.LightningLike.cs

@@ -0,0 +1,154 @@
+using System;
+using Microsoft.Extensions.DependencyInjection;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Models.StoreViewModels;
+using BTCPayServer.Payments;
+using BTCPayServer.Payments.Lightning.CLightning;
+using Microsoft.AspNetCore.Mvc;
+using BTCPayServer.Payments.Lightning;
+using System.Net;
+using BTCPayServer.Data;
+using System.Threading;
+
+namespace BTCPayServer.Controllers
+{
+    public partial class StoresController
+    {
+
+        [HttpGet]
+        [Route("{storeId}/lightning/{cryptoCode}")]
+        public IActionResult AddLightningNode(string storeId, string cryptoCode)
+        {
+            var store = HttpContext.GetStoreData();
+            if (store == null)
+                return NotFound();
+            LightningNodeViewModel vm = new LightningNodeViewModel();
+            vm.CryptoCode = cryptoCode;
+            vm.InternalLightningNode = GetInternalLighningNode(cryptoCode)?.ToUri(true)?.AbsoluteUri;
+            SetExistingValues(store, vm);
+            return View(vm);
+        }
+
+        private void SetExistingValues(StoreData store, LightningNodeViewModel vm)
+        {
+            vm.Url = GetExistingLightningSupportedPaymentMethod(vm.CryptoCode, store)?.GetLightningUrl()?.ToString();
+        }
+
+        private LightningSupportedPaymentMethod GetExistingLightningSupportedPaymentMethod(string cryptoCode, StoreData store)
+        {
+            var id = new PaymentMethodId(cryptoCode, PaymentTypes.LightningLike);
+            var existing = store.GetSupportedPaymentMethods(_NetworkProvider)
+                .OfType<LightningSupportedPaymentMethod>()
+                .FirstOrDefault(d => d.PaymentId == id);
+            return existing;
+        }
+
+        private LightningConnectionString GetInternalLighningNode(string cryptoCode)
+        {
+            if (_BtcpayServerOptions.InternalLightningByCryptoCode.TryGetValue(cryptoCode, out var connectionString))
+            {
+                return CanUseInternalLightning() ? connectionString : null;
+            }
+            return null;
+        }
+
+        [HttpPost]
+        [Route("{storeId}/lightning/{cryptoCode}")]
+        public async Task<IActionResult> AddLightningNode(string storeId, LightningNodeViewModel vm, string command, string cryptoCode)
+        {
+            vm.CryptoCode = cryptoCode;
+            var store = HttpContext.GetStoreData();
+            if (store == null)
+                return NotFound();
+            var network = vm.CryptoCode == null ? null : _ExplorerProvider.GetNetwork(vm.CryptoCode);
+
+            var internalLightning = GetInternalLighningNode(network.CryptoCode);
+            vm.InternalLightningNode = internalLightning?.ToUri(true)?.AbsoluteUri;
+            if (network == null)
+            {
+                ModelState.AddModelError(nameof(vm.CryptoCode), "Invalid network");
+                return View(vm);
+            }
+
+            PaymentMethodId paymentMethodId = new PaymentMethodId(network.CryptoCode, PaymentTypes.LightningLike);
+            Payments.Lightning.LightningSupportedPaymentMethod paymentMethod = null;
+            if (!string.IsNullOrEmpty(vm.Url))
+            {
+                if (!LightningConnectionString.TryParse(vm.Url, out var connectionString, out var error))
+                {
+                    ModelState.AddModelError(nameof(vm.Url), $"Invalid URL ({error})");
+                    return View(vm);
+                }
+
+                var internalDomain = internalLightning?.ToUri(false)?.DnsSafeHost;
+                bool isLocal = (internalDomain == "127.0.0.1" || internalDomain == "localhost");
+
+                bool isInternalNode = connectionString.ConnectionType == LightningConnectionType.CLightning ||
+                                      connectionString.BaseUri.DnsSafeHost == internalDomain ||
+                                      isLocal;
+
+                if (connectionString.BaseUri.Scheme == "http" && !isLocal)
+                {
+                    if (!isInternalNode || (isInternalNode && !CanUseInternalLightning()))
+                    {
+                        ModelState.AddModelError(nameof(vm.Url), "The url must be HTTPS");
+                        return View(vm);
+                    }
+                }
+
+                if (isInternalNode && !CanUseInternalLightning())
+                {
+                    ModelState.AddModelError(nameof(vm.Url), "Unauthorized url");
+                    return View(vm);
+                }
+
+                paymentMethod = new Payments.Lightning.LightningSupportedPaymentMethod()
+                {
+                    CryptoCode = paymentMethodId.CryptoCode
+                };
+                paymentMethod.SetLightningUrl(connectionString);
+            }
+            if (command == "save")
+            {
+                store.SetSupportedPaymentMethod(paymentMethodId, paymentMethod);
+                await _Repo.UpdateStore(store);
+                StatusMessage = $"Lightning node modified ({network.CryptoCode})";
+                return RedirectToAction(nameof(UpdateStore), new { storeId = storeId });
+            }
+            else // if(command == "test")
+            {
+                if (paymentMethod == null)
+                {
+                    ModelState.AddModelError(nameof(vm.Url), "Missing url parameter");
+                    return View(vm);
+                }
+                var handler = (LightningLikePaymentHandler)_ServiceProvider.GetRequiredService<IPaymentMethodHandler<Payments.Lightning.LightningSupportedPaymentMethod>>();
+                try
+                {
+                    var info = await handler.Test(paymentMethod, network);
+                    if (!vm.SkipPortTest)
+                    {
+                        using (CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromSeconds(20)))
+                        {
+                            await handler.TestConnection(info, cts.Token);
+                        }
+                    }
+                    vm.StatusMessage = $"Connection to the lightning node succeed ({info})";
+                }
+                catch (Exception ex)
+                {
+                    vm.StatusMessage = $"Error: {ex.Message}";
+                    return View(vm);
+                }
+                return View(vm);
+            }
+        }
+
+        private bool CanUseInternalLightning()
+        {
+            return (_BTCPayEnv.IsDevelopping || User.IsInRole(Roles.ServerAdmin));
+        }
+    }
+}

BTCPayServer/Controllers/UserStoresController.cs

@@ -0,0 +1,148 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Models;
+using BTCPayServer.Models.StoreViewModels;
+using BTCPayServer.Security;
+using BTCPayServer.Services.Stores;
+using BTCPayServer.Services.Wallets;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc;
+using NBXplorer.DerivationStrategy;
+
+namespace BTCPayServer.Controllers
+{
+    [Route("stores")]
+    [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
+    [AutoValidateAntiforgeryToken]
+    public partial class UserStoresController : Controller
+    {
+        private StoreRepository _Repo;
+        private BTCPayNetworkProvider _NetworkProvider;
+        private UserManager<ApplicationUser> _UserManager;
+        private BTCPayWalletProvider _WalletProvider;
+
+        public UserStoresController(
+            UserManager<ApplicationUser> userManager,
+            BTCPayNetworkProvider networkProvider,
+            BTCPayWalletProvider walletProvider,
+            StoreRepository storeRepository)
+        {
+            _Repo = storeRepository;
+            _NetworkProvider = networkProvider;
+            _UserManager = userManager;
+            _WalletProvider = walletProvider;
+        }
+        [HttpGet]
+        [Route("{storeId}/delete")]
+        public IActionResult DeleteStore(string storeId)
+        {
+            var store = HttpContext.GetStoreData();
+            if (store == null)
+                return NotFound();
+            return View("Confirm", new ConfirmModel()
+            {
+                Title = "Delete store " + store.StoreName,
+                Description = "This store will still be accessible to users sharing it",
+                Action = "Delete"
+            });
+        }
+
+        [HttpGet]
+        [Route("create")]
+        public IActionResult CreateStore()
+        {
+            return View();
+        }
+
+        public string CreatedStoreId
+        {
+            get; set;
+        }
+
+        [HttpPost]
+        [Route("{storeId}/delete")]
+        public async Task<IActionResult> DeleteStorePost(string storeId)
+        {
+            var userId = GetUserId();
+            var store = HttpContext.GetStoreData();
+            if (store == null)
+                return NotFound();
+            await _Repo.RemoveStore(storeId, userId);
+            StatusMessage = "Store removed successfully";
+            return RedirectToAction(nameof(ListStores));
+        }
+
+        [TempData]
+        public string StatusMessage { get; set; }
+
+        [HttpGet]
+        public async Task<IActionResult> ListStores()
+        {
+            StoresViewModel result = new StoresViewModel();
+            var stores = await _Repo.GetStoresByUserId(GetUserId());
+
+            var balances = stores
+                                .Select(s => s.GetSupportedPaymentMethods(_NetworkProvider)
+                                              .OfType<DerivationStrategy>()
+                                              .Select(d => ((Wallet: _WalletProvider.GetWallet(d.Network),
+                                                            DerivationStrategy: d.DerivationStrategyBase)))
+                                              .Where(_ => _.Wallet != null)
+                                              .Select(async _ => (await GetBalanceString(_)) + " " + _.Wallet.Network.CryptoCode))
+                                .ToArray();
+
+            await Task.WhenAll(balances.SelectMany(_ => _));
+            for (int i = 0; i < stores.Length; i++)
+            {
+                var store = stores[i];
+                result.Stores.Add(new StoresViewModel.StoreViewModel()
+                {
+                    Id = store.Id,
+                    Name = store.StoreName,
+                    WebSite = store.StoreWebsite,
+                    IsOwner = store.HasClaim(Policies.CanModifyStoreSettings.Key),
+                    Balances = store.HasClaim(Policies.CanModifyStoreSettings.Key) ? balances[i].Select(t => t.Result).ToArray() : Array.Empty<string>()
+                });
+            }
+            return View(result);
+        }
+
+        [HttpPost]
+        [Route("create")]
+        public async Task<IActionResult> CreateStore(CreateStoreViewModel vm)
+        {
+            if (!ModelState.IsValid)
+            {
+                return View(vm);
+            }
+            var store = await _Repo.CreateStore(GetUserId(), vm.Name);
+            CreatedStoreId = store.Id;
+            StatusMessage = "Store successfully created";
+            return RedirectToAction(nameof(ListStores));
+        }
+
+        private static async Task<string> GetBalanceString((BTCPayWallet Wallet, DerivationStrategyBase DerivationStrategy) _)
+        {
+            using (CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromSeconds(10)))
+            {
+                try
+                {
+                    return (await _.Wallet.GetBalance(_.DerivationStrategy, cts.Token)).ToString();
+                }
+                catch
+                {
+                    return "--";
+                }
+            }
+        }
+
+
+        private string GetUserId()
+        {
+            return _UserManager.GetUserId(User);
+        }
+    }
+}

BTCPayServer/CurrencyValue.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Rates;
+
+namespace BTCPayServer
+{
+    public class CurrencyValue
+    {
+        static Regex _Regex = new Regex("^([0-9]+(\\.[0-9]+)?)\\s*([a-zA-Z]+)$");
+        static CurrencyNameTable _CurrencyTable = new CurrencyNameTable();
+        public static bool TryParse(string str, out CurrencyValue value)
+        {
+            value = null;
+            var match = _Regex.Match(str);
+            if (!match.Success ||
+                !decimal.TryParse(match.Groups[1].Value, out var v))
+                return false;
+
+            var currency = match.Groups.Last().Value.ToUpperInvariant();
+            var currencyData = _CurrencyTable.GetCurrencyData(currency, false);
+            if (currencyData == null)
+                return false;
+            v = Math.Round(v, currencyData.Divisibility);
+            value = new CurrencyValue()
+            {
+                Value = v,
+                Currency = currency
+            };
+            return true;
+        }
+
+        public decimal Value { get; set; }
+        public string Currency { get; set; }
+
+        public override string ToString()
+        {
+            return Value.ToString(CultureInfo.InvariantCulture) + " " + Currency;
+        }
+    }
+}

BTCPayServer/CustomThreadPool.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace BTCPayServer
+{
+    class CustomThreadPool : IDisposable
+    {
+        CancellationTokenSource _Cancel = new CancellationTokenSource();
+        TaskCompletionSource<bool> _Exited;
+        int _ExitedCount = 0;
+        Thread[] _Threads;
+        Exception _UnhandledException;
+        BlockingCollection<(Action, TaskCompletionSource<object>)> _Actions = new BlockingCollection<(Action, TaskCompletionSource<object>)>(new ConcurrentQueue<(Action, TaskCompletionSource<object>)>());
+
+        public CustomThreadPool(int threadCount, string threadName)
+        {
+            if (threadCount <= 0)
+                throw new ArgumentOutOfRangeException(nameof(threadCount));
+            _Exited = new TaskCompletionSource<bool>();
+            _Threads = Enumerable.Range(0, threadCount).Select(_ => new Thread(RunLoop) { Name = threadName }).ToArray();
+            foreach (var t in _Threads)
+                t.Start();
+        }
+
+        public void Do(Action act)
+        {
+            DoAsync(act).GetAwaiter().GetResult();
+        }
+
+        public T Do<T>(Func<T> act)
+        {
+            return DoAsync(act).GetAwaiter().GetResult();
+        }
+
+        public async Task<T> DoAsync<T>(Func<T> act)
+        {
+            TaskCompletionSource<object> done = new TaskCompletionSource<object>();
+            _Actions.Add((() =>
+            {
+                try
+                {
+                    done.TrySetResult(act());
+                }
+                catch (Exception ex) { done.TrySetException(ex); }
+            }
+            , done));
+            return (T)(await done.Task.ConfigureAwait(false));
+        }
+
+        public Task DoAsync(Action act)
+        {
+            return DoAsync<object>(() =>
+            {
+                act();
+                return null;
+            });
+        }
+
+        void RunLoop()
+        {
+            try
+            {
+                foreach (var act in _Actions.GetConsumingEnumerable(_Cancel.Token))
+                {
+                    act.Item1();
+                }
+            }
+            catch (OperationCanceledException) when (_Cancel.IsCancellationRequested) { }
+            catch (Exception ex)
+            {
+                _Cancel.Cancel();
+                _UnhandledException = ex;
+            }
+            if (Interlocked.Increment(ref _ExitedCount) == _Threads.Length)
+            {
+                foreach (var action in _Actions)
+                {
+                    try
+                    {
+                        action.Item2.TrySetCanceled();
+                    }
+                    catch { }
+                }
+                _Exited.TrySetResult(true);
+            }
+        }
+
+        public void Dispose()
+        {
+            _Cancel.Cancel();
+            _Exited.Task.GetAwaiter().GetResult();
+        }
+    }
+}

BTCPayServer/Data/APIKeyData.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Data
+{
+    public class APIKeyData
+    {
+        [MaxLength(50)]
+        public string Id
+        {
+            get; set;
+        }
+
+        [MaxLength(50)]
+        public string StoreId
+        {
+            get; set;
+        }
+    }
+}

BTCPayServer/Data/AddressInvoiceData.cs

@@ -2,24 +2,67 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using BTCPayServer.Payments;
+using BTCPayServer.Services.Invoices;
+using NBitcoin;
 
 namespace BTCPayServer.Data
 {
-	public class AddressInvoiceData
-	{
-		public string Address
-		{
-			get; set;
-		}
+    public class AddressInvoiceData
+    {
+        /// <summary>
+        /// Some crypto currencies share same address prefix
+        /// For not having exceptions thrown by two address on different network, we suffix by "#CRYPTOCODE" 
+        /// </summary>
+        [Obsolete("Use GetHash instead")]
+        public string Address
+        {
+            get; set;
+        }
 
-		public InvoiceData InvoiceData
-		{
-			get; set;
-		}
 
-		public string InvoiceDataId
-		{
-			get; set;
-		}
-	}
+#pragma warning disable CS0618
+        public string GetAddress()
+        {
+            if (Address == null)
+                return null;
+            var index = Address.LastIndexOf("#", StringComparison.InvariantCulture);
+            if (index == -1)
+                return Address;
+            return Address.Substring(0, index);
+        }
+        public AddressInvoiceData Set(string address, PaymentMethodId paymentMethodId)
+        {
+            Address = address + "#" + paymentMethodId.ToString();
+            return this;
+        }
+        public PaymentMethodId GetpaymentMethodId()
+        {
+            if (Address == null)
+                return null;
+            var index = Address.LastIndexOf("#", StringComparison.InvariantCulture);
+            // Legacy AddressInvoiceData does not have the paymentMethodId attached to the Address
+            if (index == -1)
+                return PaymentMethodId.Parse("BTC");
+            /////////////////////////
+            return PaymentMethodId.Parse(Address.Substring(index + 1));
+        }
+#pragma warning restore CS0618
+
+        public InvoiceData InvoiceData
+        {
+            get; set;
+        }
+
+        public string InvoiceDataId
+        {
+            get; set;
+        }
+
+        public DateTimeOffset? CreatedTime
+        {
+            get; set;
+        }
+
+    }
 }

BTCPayServer/Data/AppData.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Data
+{
+    public class AppData
+    {
+        public string Id { get; set; }
+        public string Name { get; set; }
+        public string StoreDataId
+        {
+            get; set;
+        }
+        public string AppType { get; set; }
+        public StoreData StoreData
+        {
+            get; set;
+        }
+        public DateTimeOffset Created
+        {
+            get; set;
+        }
+        public string Settings { get; set; }
+
+        public T GetSettings<T>() where T : class, new()
+        {
+            if (String.IsNullOrEmpty(Settings))
+                return new T();
+            return JsonConvert.DeserializeObject<T>(Settings);
+        }
+
+        public void SetSettings(object value)
+        {
+            Settings = value == null ? null : JsonConvert.SerializeObject(value);
+        }
+    }
+}

BTCPayServer/Data/ApplicationDbContext.cs

@@ -10,110 +10,160 @@ using Microsoft.EntityFrameworkCore.Infrastructure;
 
 namespace BTCPayServer.Data
 {
-	public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
-	{
-		public ApplicationDbContext()
-		{
+    public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
+    {
+        public ApplicationDbContext()
+        {
 
-		}
-		public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
-			: base(options)
-		{
-		}
+        }
+        public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
+            : base(options)
+        {
+        }
 
-		public DbSet<InvoiceData> Invoices
-		{
-			get; set;
-		}
+        public DbSet<InvoiceData> Invoices
+        {
+            get; set;
+        }
 
-		public DbSet<RefundAddressesData> RefundAddresses
-		{
-			get; set;
-		}
+        public DbSet<AppData> Apps
+        {
+            get; set;
+        }
 
-		public DbSet<PaymentData> Payments
-		{
-			get; set;
-		}
+        public DbSet<InvoiceEventData> InvoiceEvents
+        {
+            get; set;
+        }
 
-		public DbSet<StoreData> Stores
-		{
-			get; set;
-		}
+        public DbSet<HistoricalAddressInvoiceData> HistoricalAddressInvoices
+        {
+            get; set;
+        }
 
-		public DbSet<UserStore> UserStore
-		{
-			get; set;
-		}
+        public DbSet<PendingInvoiceData> PendingInvoices
+        {
+            get; set;
+        }
+        public DbSet<RefundAddressesData> RefundAddresses
+        {
+            get; set;
+        }
 
-		public DbSet<AddressInvoiceData> AddressInvoices
-		{
-			get; set;
-		}
+        public DbSet<PaymentData> Payments
+        {
+            get; set;
+        }
 
-		public DbSet<SettingData> Settings
-		{
-			get; set;
-		}
+        public DbSet<StoreData> Stores
+        {
+            get; set;
+        }
+
+        public DbSet<UserStore> UserStore
+        {
+            get; set;
+        }
+
+        public DbSet<AddressInvoiceData> AddressInvoices
+        {
+            get; set;
+        }
+
+        public DbSet<SettingData> Settings
+        {
+            get; set;
+        }
 
 
-		public DbSet<PairingCodeData> PairingCodes
-		{
-			get; set;
-		}
+        public DbSet<PairingCodeData> PairingCodes
+        {
+            get; set;
+        }
 
-		public DbSet<PairedSINData> PairedSINData
-		{
-			get; set;
-		}
+        public DbSet<PairedSINData> PairedSINData
+        {
+            get; set;
+        }
 
-		protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
-		{
-			var isConfigured = optionsBuilder.Options.Extensions.OfType<RelationalOptionsExtension>().Any();
-			if(!isConfigured)
-				optionsBuilder.UseSqlite("Data Source=temp.db");
-		}
+        public DbSet<APIKeyData> ApiKeys
+        {
+            get; set;
+        }
 
-		protected override void OnModelCreating(ModelBuilder builder)
-		{
-			base.OnModelCreating(builder);
-			builder.Entity<InvoiceData>()
-				.HasIndex(o => o.StoreDataId);
+        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+        {
+            var isConfigured = optionsBuilder.Options.Extensions.OfType<RelationalOptionsExtension>().Any();
+            if (!isConfigured)
+                optionsBuilder.UseSqlite("Data Source=temp.db");
+        }
 
-			builder.Entity<PaymentData>()
-				.HasIndex(o => o.InvoiceDataId);
+        protected override void OnModelCreating(ModelBuilder builder)
+        {
+            base.OnModelCreating(builder);
+            builder.Entity<InvoiceData>()
+                .HasIndex(o => o.StoreDataId);
 
-			builder.Entity<RefundAddressesData>()
-				.HasIndex(o => o.InvoiceDataId);
+            builder.Entity<PaymentData>()
+                .HasIndex(o => o.InvoiceDataId);
 
-			builder.Entity<UserStore>()
-				   .HasKey(t => new
-				   {
-					   t.ApplicationUserId,
-					   t.StoreDataId
-				   });
+            builder.Entity<RefundAddressesData>()
+                .HasIndex(o => o.InvoiceDataId);
 
-			builder.Entity<UserStore>()
-				 .HasOne(pt => pt.ApplicationUser)
-				 .WithMany(p => p.UserStores)
-				 .HasForeignKey(pt => pt.ApplicationUserId);
+            builder.Entity<UserStore>()
+                   .HasKey(t => new
+                   {
+                       t.ApplicationUserId,
+                       t.StoreDataId
+                   });
 
-			builder.Entity<UserStore>()
-				.HasOne(pt => pt.StoreData)
-				.WithMany(t => t.UserStores)
-				.HasForeignKey(pt => pt.StoreDataId);
+            builder.Entity<APIKeyData>()
+                .HasIndex(o => o.StoreId);
 
-			builder.Entity<AddressInvoiceData>()
-				.HasKey(o => o.Address);
+            builder.Entity<AppData>()
+                    .HasOne(a => a.StoreData);
 
-			builder.Entity<PairingCodeData>()
-				.HasKey(o => o.Id);
+            builder.Entity<UserStore>()
+                 .HasOne(pt => pt.ApplicationUser)
+                 .WithMany(p => p.UserStores)
+                 .HasForeignKey(pt => pt.ApplicationUserId);
 
-			builder.Entity<PairedSINData>(b =>
-			{
-				b.HasIndex(o => o.SIN);
-				b.HasIndex(o => o.StoreDataId);
-			});
-		}
-	}
+            builder.Entity<UserStore>()
+                .HasOne(pt => pt.StoreData)
+                .WithMany(t => t.UserStores)
+                .HasForeignKey(pt => pt.StoreDataId);
+
+            builder.Entity<AddressInvoiceData>()
+#pragma warning disable CS0618
+                .HasKey(o => o.Address);
+#pragma warning restore CS0618
+
+            builder.Entity<PairingCodeData>()
+                .HasKey(o => o.Id);
+
+            builder.Entity<PairedSINData>(b =>
+            {
+                b.HasIndex(o => o.SIN);
+                b.HasIndex(o => o.StoreDataId);
+            });
+
+            builder.Entity<HistoricalAddressInvoiceData>()
+                .HasKey(o => new
+                {
+                    o.InvoiceDataId,
+#pragma warning disable CS0618
+                    o.Address
+#pragma warning restore CS0618
+                });
+
+            builder.Entity<InvoiceEventData>()
+                .HasKey(o => new
+                {
+                    o.InvoiceDataId,
+#pragma warning disable CS0618
+                    o.UniqueId
+#pragma warning restore CS0618
+                });
+        }
+    }
 }

BTCPayServer/Data/ApplicationDbContextFactory.cs

@@ -6,45 +6,96 @@ using System.Threading.Tasks;
 using Hangfire;
 using Hangfire.MemoryStorage;
 using Hangfire.PostgreSql;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Migrations;
+using JetBrains.Annotations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Migrations.Operations;
+using Microsoft.EntityFrameworkCore.Metadata;
 
 namespace BTCPayServer.Data
 {
-	public enum DatabaseType
-	{
-		Sqlite,
-		Postgres
-	}
-	public class ApplicationDbContextFactory
-	{
-		string _ConnectionString;
-		DatabaseType _Type;
-		public ApplicationDbContextFactory(DatabaseType type, string connectionString)
-		{
-			_ConnectionString = connectionString ?? throw new ArgumentNullException(nameof(connectionString));
-			_Type = type;
-		}
+    public enum DatabaseType
+    {
+        Sqlite,
+        Postgres
+    }
+    public class ApplicationDbContextFactory
+    {
+        string _ConnectionString;
+        DatabaseType _Type;
+        public ApplicationDbContextFactory(DatabaseType type, string connectionString)
+        {
+            _ConnectionString = connectionString ?? throw new ArgumentNullException(nameof(connectionString));
+            _Type = type;
+        }
 
-		public ApplicationDbContext CreateContext()
-		{
-			var builder = new DbContextOptionsBuilder<ApplicationDbContext>();
-			ConfigureBuilder(builder);
-			return new ApplicationDbContext(builder.Options);
-		}
+        public ApplicationDbContext CreateContext()
+        {
+            var builder = new DbContextOptionsBuilder<ApplicationDbContext>();
+            ConfigureBuilder(builder);
+            return new ApplicationDbContext(builder.Options);
+        }
 
-		public void ConfigureBuilder(DbContextOptionsBuilder builder)
-		{
-			if(_Type == DatabaseType.Sqlite)
-				builder.UseSqlite(_ConnectionString);
-			else if(_Type == DatabaseType.Postgres)
-				builder.UseNpgsql(_ConnectionString);
-		}
+        class CustomNpgsqlMigrationsSqlGenerator : NpgsqlMigrationsSqlGenerator
+        {
+            public CustomNpgsqlMigrationsSqlGenerator(MigrationsSqlGeneratorDependencies dependencies) : base(dependencies)
+            {
+            }
 
-		public void ConfigureHangfireBuilder(IGlobalConfiguration builder)
-		{
-			if(_Type == DatabaseType.Sqlite)
-				builder.UseMemoryStorage(); //Sql provider does not support multiple workers
-			else if(_Type == DatabaseType.Postgres)
-				builder.UsePostgreSqlStorage(_ConnectionString);
-		}
-	}
+            protected override void Generate(NpgsqlCreateDatabaseOperation operation, IModel model, MigrationCommandListBuilder builder)
+            {
+                builder
+                     .Append("CREATE DATABASE ")
+                     .Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Name));
+
+                // POSTGRES gotcha: Indexed Text column (even if PK) are not used if we are not using C locale
+                builder
+                    .Append(" TEMPLATE ")
+                    .Append(Dependencies.SqlGenerationHelper.DelimitIdentifier("template0"));
+
+                builder
+                    .Append(" LC_CTYPE ")
+                    .Append(Dependencies.SqlGenerationHelper.DelimitIdentifier("C"));
+
+                builder
+                    .Append(" LC_COLLATE ")
+                    .Append(Dependencies.SqlGenerationHelper.DelimitIdentifier("C"));
+
+                builder
+                    .Append(" ENCODING ")
+                    .Append(Dependencies.SqlGenerationHelper.DelimitIdentifier("UTF8"));
+
+                if (operation.Tablespace != null)
+                {
+                    builder
+                        .Append(" TABLESPACE ")
+                        .Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Tablespace));
+                }
+
+                builder.AppendLine(Dependencies.SqlGenerationHelper.StatementTerminator);
+
+                EndStatement(builder, suppressTransaction: true);
+            }
+        }
+
+        public void ConfigureBuilder(DbContextOptionsBuilder builder)
+        {
+            if (_Type == DatabaseType.Sqlite)
+                builder.UseSqlite(_ConnectionString);
+            else if (_Type == DatabaseType.Postgres)
+                builder
+                    .UseNpgsql(_ConnectionString)
+                    .ReplaceService<IMigrationsSqlGenerator, CustomNpgsqlMigrationsSqlGenerator>();
+        }
+
+        public void ConfigureHangfireBuilder(IGlobalConfiguration builder)
+        {
+            builder.UseMemoryStorage();
+            //We always use memory storage because of incompatibilities with the latest postgres in 2.1
+            //if (_Type == DatabaseType.Sqlite)
+            //    builder.UseMemoryStorage(); //Sqlite provider does not support multiple workers
+            //else if (_Type == DatabaseType.Postgres)
+            //    builder.UsePostgreSqlStorage(_ConnectionString);
+        }
+    }
 }

BTCPayServer/Data/HistoricalAddressInvoiceData.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Data
+{
+    public class HistoricalAddressInvoiceData
+    {
+        public string InvoiceDataId
+        {
+            get; set;
+        }
+
+        /// <summary>
+        /// Some crypto currencies share same address prefix
+        /// For not having exceptions thrown by two address on different network, we suffix by "#CRYPTOCODE" 
+        /// </summary>
+        [Obsolete("Use GetCryptoCode instead")]
+        public string Address
+        {
+            get; set;
+        }
+
+
+        [Obsolete("Use GetCryptoCode instead")]
+        public string CryptoCode { get; set; }
+
+#pragma warning disable CS0618
+        public Payments.PaymentMethodId GetPaymentMethodId()
+        {
+            return string.IsNullOrEmpty(CryptoCode) ? new Payments.PaymentMethodId("BTC", Payments.PaymentTypes.BTCLike)
+                                                    : Payments.PaymentMethodId.Parse(CryptoCode);
+        }
+        public string GetAddress()
+        {
+            if (Address == null)
+                return null;
+            var index = Address.IndexOf("#", StringComparison.InvariantCulture);
+            if (index == -1)
+                return Address;
+            return Address.Substring(0, index);
+        }
+        public HistoricalAddressInvoiceData SetAddress(string depositAddress, string cryptoCode)
+        {
+            Address = depositAddress + "#" + cryptoCode;
+            CryptoCode = cryptoCode;
+            return this;
+        }
+#pragma warning restore CS0618
+
+        public DateTimeOffset Assigned
+        {
+            get; set;
+        }
+
+        public DateTimeOffset? UnAssigned
+        {
+            get; set;
+        }
+    }
+}

BTCPayServer/Data/InvoiceData.cs

@@ -6,65 +6,79 @@ using System.Threading.Tasks;
 
 namespace BTCPayServer.Data
 {
-	public class InvoiceData
-	{
-		public string StoreDataId
-		{
-			get; set;
-		}
-		public StoreData StoreData
-		{
-			get; set;
-		}
+    public class InvoiceData
+    {
+        public string StoreDataId
+        {
+            get; set;
+        }
+        public StoreData StoreData
+        {
+            get; set;
+        }
 
-		public string Id
-		{
-			get; set;
-		}
+        public string Id
+        {
+            get; set;
+        }
 
-		public DateTimeOffset Created
-		{
-			get; set;
-		}
+        public DateTimeOffset Created
+        {
+            get; set;
+        }
 
-		public List<PaymentData> Payments
-		{
-			get; set;
-		}
+        public List<PaymentData> Payments
+        {
+            get; set;
+        }
 
-		public List<RefundAddressesData> RefundAddresses
-		{
-			get; set;
-		}
+        public List<InvoiceEventData> Events
+        {
+            get; set;
+        }
 
-		public byte[] Blob
-		{
-			get; set;
-		}
-		public string ItemCode
-		{
-			get;
-			set;
-		}
-		public string OrderId
-		{
-			get;
-			set;
-		}
-		public string Status
-		{
-			get;
-			set;
-		}
-		public string ExceptionStatus
-		{
-			get;
-			set;
-		}
-		public string CustomerEmail
-		{
-			get;
-			set;
-		}
-	}
+        public List<RefundAddressesData> RefundAddresses
+        {
+            get; set;
+        }
+
+        public List<HistoricalAddressInvoiceData> HistoricalAddressInvoices
+        {
+            get; set;
+        }
+
+        public byte[] Blob
+        {
+            get; set;
+        }
+        public string ItemCode
+        {
+            get;
+            set;
+        }
+        public string OrderId
+        {
+            get;
+            set;
+        }
+        public string Status
+        {
+            get;
+            set;
+        }
+        public string ExceptionStatus
+        {
+            get;
+            set;
+        }
+        public string CustomerEmail
+        {
+            get;
+            set;
+        }
+        public List<AddressInvoiceData> AddressInvoices
+        {
+            get; set;
+        }
+    }
 }

BTCPayServer/Data/InvoiceEventData.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Data
+{
+    public class InvoiceEventData
+    {
+        public string InvoiceDataId
+        {
+            get; set;
+        }
+        public string UniqueId { get; internal set; }
+        public DateTimeOffset Timestamp
+        {
+            get; set;
+        }
+
+        public string Message { get; set; }
+    }
+}

BTCPayServer/Data/PairedSINData.cs

@@ -7,33 +7,33 @@ namespace BTCPayServer.Data
 {
     public class PairedSINData
     {
-		public string Id
-		{
-			get; set;
-		}
+        public string Id
+        {
+            get; set;
+        }
 
-		public string Facade
-		{
-			get; set;
-		}
-		
-		public string StoreDataId
-		{
-			get; set;
-		}
-		public string Label
-		{
-			get;
-			set;
-		}
-		public DateTimeOffset PairingTime
-		{
-			get;
-			set;
-		}
-		public string SIN
-		{
-			get; set;
-		}
-	}
+        public string Facade
+        {
+            get; set;
+        }
+
+        public string StoreDataId
+        {
+            get; set;
+        }
+        public string Label
+        {
+            get;
+            set;
+        }
+        public DateTimeOffset PairingTime
+        {
+            get;
+            set;
+        }
+        public string SIN
+        {
+            get; set;
+        }
+    }
 }

BTCPayServer/Data/PairingCodeData.cs

@@ -7,44 +7,44 @@ namespace BTCPayServer.Data
 {
     public class PairingCodeData
     {
-		public string Id
-		{
-			get; set;
-		}
-		
-		public string Facade
-		{
-			get; set;
-		}
-		public string StoreDataId
-		{
-			get; set;
-		}
-		public DateTimeOffset Expiration
-		{
-			get;
-			set;
-		}
+        public string Id
+        {
+            get; set;
+        }
 
-		public string Label
-		{
-			get;
-			set;
-		}
-		public string SIN
-		{
-			get;
-			set;
-		}
-		public DateTime DateCreated
-		{
-			get;
-			set;
-		}
-		public string TokenValue
-		{
-			get;
-			set;
-		}
-	}
+        public string Facade
+        {
+            get; set;
+        }
+        public string StoreDataId
+        {
+            get; set;
+        }
+        public DateTimeOffset Expiration
+        {
+            get;
+            set;
+        }
+
+        public string Label
+        {
+            get;
+            set;
+        }
+        public string SIN
+        {
+            get;
+            set;
+        }
+        public DateTime DateCreated
+        {
+            get;
+            set;
+        }
+        public string TokenValue
+        {
+            get;
+            set;
+        }
+    }
 }

BTCPayServer/Data/PaymentData.cs

@@ -5,25 +5,29 @@ using System.Threading.Tasks;
 
 namespace BTCPayServer.Data
 {
-	public class PaymentData
-	{
-		public string Id
-		{
-			get; set;
-		}
+    public class PaymentData
+    {
+        public string Id
+        {
+            get; set;
+        }
 
-		public string InvoiceDataId
-		{
-			get; set;
-		}
-		public InvoiceData InvoiceData
-		{
-			get; set;
-		}
+        public string InvoiceDataId
+        {
+            get; set;
+        }
+        public InvoiceData InvoiceData
+        {
+            get; set;
+        }
 
-		public byte[] Blob
-		{
-			get; set;
-		}
-	}
+        public byte[] Blob
+        {
+            get; set;
+        }
+        public bool Accounted
+        {
+            get; set;
+        }
+    }
 }

BTCPayServer/Data/PendingInvoiceData.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Data
+{
+    public class PendingInvoiceData
+    {
+        public string Id
+        {
+            get; set;
+        }
+    }
+}

BTCPayServer/Data/RefundData.cs

@@ -7,21 +7,21 @@ namespace BTCPayServer.Data
 {
     public class RefundAddressesData
     {
-		public string Id
-		{
-			get; set;
-		}
-		public string InvoiceDataId
-		{
-			get; set;
-		}
-		public InvoiceData InvoiceData
-		{
-			get; set;
-		}
-		public byte[] Blob
-		{
-			get; set;
-		}
-	}
+        public string Id
+        {
+            get; set;
+        }
+        public string InvoiceDataId
+        {
+            get; set;
+        }
+        public InvoiceData InvoiceData
+        {
+            get; set;
+        }
+        public byte[] Blob
+        {
+            get; set;
+        }
+    }
 }

BTCPayServer/Data/SettingData.cs

@@ -7,14 +7,14 @@ namespace BTCPayServer.Data
 {
     public class SettingData
     {
-		public string Id
-		{
-			get; set;
-		}
+        public string Id
+        {
+            get; set;
+        }
 
-		public string Value
-		{
-			get; set;
-		}
-	}
+        public string Value
+        {
+            get; set;
+        }
+    }
 }

BTCPayServer/Data/StoreData.cs

@@ -1,55 +1,374 @@
 using BTCPayServer.Models;
-using BTCPayServer.Servcices.Invoices;
+using BTCPayServer.Services.Invoices;
+using NBitcoin;
+using NBXplorer;
 using System;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations.Schema;
 using System.Linq;
+using System.Text;
 using System.Threading.Tasks;
+using System.ComponentModel;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using BTCPayServer.Services.Rates;
+using BTCPayServer.Payments;
+using BTCPayServer.JsonConverters;
+using System.ComponentModel.DataAnnotations;
+using BTCPayServer.Services;
+using System.Security.Claims;
+using BTCPayServer.Security;
+using BTCPayServer.Rating;
 
 namespace BTCPayServer.Data
 {
     public class StoreData
     {
-		public string Id
-		{
-			get;
-			set;
-		}
+        public string Id
+        {
+            get;
+            set;
+        }
 
-		public List<UserStore> UserStores
-		{
-			get; set;
-		}
+        public List<UserStore> UserStores
+        {
+            get; set;
+        }
 
-		public string DerivationStrategy
-		{
-			get; set;
-		}
+        public List<AppData> Apps
+        {
+            get; set;
+        }
 
-		public string StoreName
-		{
-			get; set;
-		}
+        [Obsolete("Use GetDerivationStrategies instead")]
+        public string DerivationStrategy
+        {
+            get; set;
+        }
 
-		public SpeedPolicy SpeedPolicy
-		{
-			get; set;
-		}
+        [Obsolete("Use GetDerivationStrategies instead")]
+        public string DerivationStrategies
+        {
+            get;
+            set;
+        }
 
-		public string StoreWebsite
-		{
-			get; set;
-		}
+        public IEnumerable<ISupportedPaymentMethod> GetSupportedPaymentMethods(BTCPayNetworkProvider networks)
+        {
+#pragma warning disable CS0618
+            bool btcReturned = false;
 
-		public byte[] StoreCertificate
-		{
-			get; set;
-		}
+            // Legacy stuff which should go away
+            if (!string.IsNullOrEmpty(DerivationStrategy))
+            {
+                if (networks.BTC != null)
+                {
+                    btcReturned = true;
+                    yield return BTCPayServer.DerivationStrategy.Parse(DerivationStrategy, networks.BTC);
+                }
+            }
 
-		[NotMapped]
-		public string Role
-		{
-			get; set;
-		}
-	}
+
+            if (!string.IsNullOrEmpty(DerivationStrategies))
+            {
+                JObject strategies = JObject.Parse(DerivationStrategies);
+                foreach (var strat in strategies.Properties())
+                {
+                    var paymentMethodId = PaymentMethodId.Parse(strat.Name);
+                    var network = networks.GetNetwork(paymentMethodId.CryptoCode);
+                    if (network != null)
+                    {
+                        if (network == networks.BTC && paymentMethodId.PaymentType == PaymentTypes.BTCLike && btcReturned)
+                            continue;
+                        if (strat.Value.Type == JTokenType.Null)
+                            continue;
+                        yield return PaymentMethodExtensions.Deserialize(paymentMethodId, strat.Value, network);
+                    }
+                }
+            }
+#pragma warning restore CS0618
+        }
+
+        /// <summary>
+        /// Set or remove a new supported payment method for the store
+        /// </summary>
+        /// <param name="paymentMethodId">The paymentMethodId</param>
+        /// <param name="supportedPaymentMethod">The payment method, or null to remove</param>
+        public void SetSupportedPaymentMethod(PaymentMethodId paymentMethodId, ISupportedPaymentMethod supportedPaymentMethod)
+        {
+            if (supportedPaymentMethod != null && paymentMethodId != supportedPaymentMethod.PaymentId)
+                throw new InvalidOperationException("Argument mismatch");
+
+#pragma warning disable CS0618
+            JObject strategies = string.IsNullOrEmpty(DerivationStrategies) ? new JObject() : JObject.Parse(DerivationStrategies);
+            bool existing = false;
+            foreach (var strat in strategies.Properties().ToList())
+            {
+                var stratId = PaymentMethodId.Parse(strat.Name);
+                if (stratId.IsBTCOnChain)
+                {
+                    // Legacy stuff which should go away
+                    DerivationStrategy = null;
+                }
+                if (stratId == paymentMethodId)
+                {
+                    if (supportedPaymentMethod == null)
+                    {
+                        strat.Remove();
+                    }
+                    else
+                    {
+                        strat.Value = PaymentMethodExtensions.Serialize(supportedPaymentMethod);
+                    }
+                    existing = true;
+                    break;
+                }
+            }
+
+            if (!existing && supportedPaymentMethod == null && paymentMethodId.IsBTCOnChain)
+            {
+                DerivationStrategy = null;
+            }
+            else if (!existing && supportedPaymentMethod != null)
+                strategies.Add(new JProperty(supportedPaymentMethod.PaymentId.ToString(), PaymentMethodExtensions.Serialize(supportedPaymentMethod)));
+            DerivationStrategies = strategies.ToString();
+#pragma warning restore CS0618
+        }
+
+        public string StoreName
+        {
+            get; set;
+        }
+
+        public SpeedPolicy SpeedPolicy
+        {
+            get; set;
+        }
+
+        public string StoreWebsite
+        {
+            get; set;
+        }
+
+        public byte[] StoreCertificate
+        {
+            get; set;
+        }
+
+        [NotMapped]
+        [Obsolete]
+        public string Role
+        {
+            get; set;
+        }
+
+        public Claim[] GetClaims()
+        {
+            List<Claim> claims = new List<Claim>();
+#pragma warning disable CS0612 // Type or member is obsolete
+            var role = Role;
+#pragma warning restore CS0612 // Type or member is obsolete
+            if (role == StoreRoles.Owner)
+            {
+                claims.Add(new Claim(Policies.CanModifyStoreSettings.Key, Id));
+                claims.Add(new Claim(Policies.CanUseStore.Key, Id));
+            }
+            if (role == StoreRoles.Guest)
+            {
+                claims.Add(new Claim(Policies.CanUseStore.Key, Id));
+            }
+            return claims.ToArray();
+        }
+
+        public bool HasClaim(string claim)
+        {
+            return GetClaims().Any(c => c.Type == claim);
+        }
+
+        public byte[] StoreBlob
+        {
+            get;
+            set;
+        }
+        [Obsolete("Use GetDefaultCrypto instead")]
+        public string DefaultCrypto { get; set; }
+
+#pragma warning disable CS0618
+        public string GetDefaultCrypto()
+        {
+            return DefaultCrypto ?? "BTC";
+        }
+        public void SetDefaultCrypto(string defaultCryptoCurrency)
+        {
+            DefaultCrypto = defaultCryptoCurrency;
+        }
+#pragma warning restore CS0618
+
+        static Network Dummy = Network.Main;
+
+        public StoreBlob GetStoreBlob()
+        {
+            var result = StoreBlob == null ? new StoreBlob() : new Serializer(Dummy).ToObject<StoreBlob>(Encoding.UTF8.GetString(StoreBlob));
+            if (result.PreferredExchange == null)
+                result.PreferredExchange = CoinAverageRateProvider.CoinAverageName;
+            return result;
+        }
+
+        public bool SetStoreBlob(StoreBlob storeBlob)
+        {
+            var original = new Serializer(Dummy).ToString(GetStoreBlob());
+            var newBlob = new Serializer(Dummy).ToString(storeBlob);
+            if (original == newBlob)
+                return false;
+            StoreBlob = Encoding.UTF8.GetBytes(newBlob);
+            return true;
+        }
+    }
+
+    public class RateRule_Obsolete
+    {
+        public RateRule_Obsolete()
+        {
+            RuleName = "Multiplier";
+        }
+        public string RuleName { get; set; }
+
+        public double Multiplier { get; set; }
+
+        public decimal Apply(BTCPayNetwork network, decimal rate)
+        {
+            return rate * (decimal)Multiplier;
+        }
+    }
+
+    public class StoreBlob
+    {
+        public StoreBlob()
+        {
+            InvoiceExpiration = 15;
+            MonitoringExpiration = 60;
+            PaymentTolerance = 0;
+            RequiresRefundEmail = true;
+        }
+        public bool NetworkFeeDisabled
+        {
+            get; set;
+        }
+        public bool AllowCoinConversion
+        {
+            get; set;
+        }
+
+        public bool RequiresRefundEmail { get; set; }
+
+        public string DefaultLang { get; set; }
+        [DefaultValue(60)]
+        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Populate)]
+        public int MonitoringExpiration
+        {
+            get;
+            set;
+        }
+
+        [DefaultValue(15)]
+        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Populate)]
+        public int InvoiceExpiration
+        {
+            get;
+            set;
+        }
+
+        public void SetRateMultiplier(double rate)
+        {
+            RateRules = new List<RateRule_Obsolete>();
+            RateRules.Add(new RateRule_Obsolete() { Multiplier = rate });
+        }
+        public decimal GetRateMultiplier()
+        {
+            decimal rate = 1.0m;
+            if (RateRules == null || RateRules.Count == 0)
+                return rate;
+            foreach (var rule in RateRules)
+            {
+                rate = rule.Apply(null, rate);
+            }
+            return rate;
+        }
+
+        public List<RateRule_Obsolete> RateRules { get; set; } = new List<RateRule_Obsolete>();
+        public string PreferredExchange { get; set; }
+
+        [JsonConverter(typeof(CurrencyValueJsonConverter))]
+        public CurrencyValue LightningMaxValue { get; set; }
+        [JsonConverter(typeof(CurrencyValueJsonConverter))]
+        public CurrencyValue OnChainMinValue { get; set; }
+
+        [JsonConverter(typeof(UriJsonConverter))]
+        public Uri CustomLogo { get; set; }
+        [JsonConverter(typeof(UriJsonConverter))]
+        public Uri CustomCSS { get; set; }
+        public string HtmlTitle { get; set; }
+
+        public bool RateScripting { get; set; }
+
+        public string RateScript { get; set; }
+
+
+        string _LightningDescriptionTemplate;
+        public string LightningDescriptionTemplate
+        {
+            get
+            {
+                return _LightningDescriptionTemplate ?? "Paid to {StoreName} (Order ID: {OrderId})";
+            }
+            set
+            {
+                _LightningDescriptionTemplate = value;
+            }
+        }
+
+        [DefaultValue(0)]
+        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Populate)]
+        public double PaymentTolerance { get; set; }
+
+        public BTCPayServer.Rating.RateRules GetRateRules(BTCPayNetworkProvider networkProvider)
+        {
+            if (!RateScripting || 
+                string.IsNullOrEmpty(RateScript) || 
+                !BTCPayServer.Rating.RateRules.TryParse(RateScript, out var rules))
+            {
+                return GetDefaultRateRules(networkProvider);
+            }
+            else
+            {
+                rules.GlobalMultiplier = GetRateMultiplier();
+                return rules;
+            }
+        }
+
+        public RateRules GetDefaultRateRules(BTCPayNetworkProvider networkProvider)
+        {
+            StringBuilder builder = new StringBuilder();
+            foreach (var network in networkProvider.GetAll())
+            {
+                if (network.DefaultRateRules.Length != 0)
+                {
+                    builder.AppendLine($"// Default rate rules for {network.CryptoCode}");
+                    foreach (var line in network.DefaultRateRules)
+                    {
+                        builder.AppendLine(line);
+                    }
+                    builder.AppendLine($"////////");
+                    builder.AppendLine();
+                }
+            }
+
+            var preferredExchange = string.IsNullOrEmpty(PreferredExchange) ? "coinaverage" : PreferredExchange;
+            builder.AppendLine($"X_X = {preferredExchange}(X_X);");
+
+            BTCPayServer.Rating.RateRules.TryParse(builder.ToString(), out var rules);
+            rules.GlobalMultiplier = GetRateMultiplier();
+            return rules;
+        }
+    }
 }

BTCPayServer/Data/UserStore.cs

@@ -6,29 +6,29 @@ using System.Threading.Tasks;
 
 namespace BTCPayServer.Data
 {
-	public class UserStore
-	{
-		public string ApplicationUserId
-		{
-			get; set;
-		}
-		public ApplicationUser ApplicationUser
-		{
-			get; set;
-		}
+    public class UserStore
+    {
+        public string ApplicationUserId
+        {
+            get; set;
+        }
+        public ApplicationUser ApplicationUser
+        {
+            get; set;
+        }
 
-		public string StoreDataId
-		{
-			get; set;
-		}
-		public StoreData StoreData
-		{
-			get; set;
-		}
-		public string Role
-		{
-			get;
-			set;
-		}
-	}
+        public string StoreDataId
+        {
+            get; set;
+        }
+        public StoreData StoreData
+        {
+            get; set;
+        }
+        public string Role
+        {
+            get;
+            set;
+        }
+    }
 }

BTCPayServer/DerivationSchemeParser.cs

@@ -0,0 +1,181 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using NBitcoin;
+using NBitcoin.DataEncoders;
+using NBXplorer;
+using NBXplorer.DerivationStrategy;
+
+namespace BTCPayServer
+{
+    public class DerivationSchemeParser
+    {
+        public Network Network { get; set; }
+        public Script HintScriptPubKey { get; set; }
+
+        public DerivationSchemeParser(Network expectedNetwork)
+        {
+            Network = expectedNetwork;
+        }
+
+        public DerivationStrategyBase Parse(string str)
+        {
+            if (str == null)
+                throw new ArgumentNullException(nameof(str));
+            str = str.Trim();
+
+            HashSet<string> hintedLabels = new HashSet<string>();
+
+            var hintDestination = HintScriptPubKey?.GetDestination();
+            if (hintDestination != null)
+            {
+                if (hintDestination is KeyId)
+                {
+                    hintedLabels.Add("legacy");
+                }
+                if (hintDestination is ScriptId)
+                {
+                    hintedLabels.Add("p2sh");
+                }
+            }
+
+            if(!Network.Consensus.SupportSegwit)
+                hintedLabels.Add("legacy");
+
+            try
+            {
+                var result = new DerivationStrategyFactory(Network).Parse(str);
+                return FindMatch(hintedLabels, result);
+            }
+            catch
+            {
+            }
+
+            Dictionary<uint, string[]> electrumMapping = new Dictionary<uint, string[]>();
+            //Source https://github.com/spesmilo/electrum/blob/9edffd17542de5773e7284a8c8a2673c766bb3c3/lib/bitcoin.py
+            var standard = 0x0488b21eU;
+            electrumMapping.Add(standard, new[] { "legacy" });
+            var p2wpkh_p2sh = 0x049d7cb2U;
+            electrumMapping.Add(p2wpkh_p2sh, new string[] { "p2sh" });
+            var p2wpkh = 0x4b24746U;
+            electrumMapping.Add(p2wpkh, Array.Empty<string>());
+
+            var parts = str.Split('-');
+            for (int i = 0; i < parts.Length; i++)
+            {
+                if (IsLabel(parts[i]))
+                {
+                    hintedLabels.Add(parts[i].Substring(1, parts[i].Length - 2).ToLowerInvariant());
+                    continue;
+                }
+                try
+                {
+                    var data = Encoders.Base58Check.DecodeData(parts[i]);
+                    if (data.Length < 4)
+                        continue;
+                    var prefix = Utils.ToUInt32(data, false);
+                    var standardPrefix = Utils.ToBytes(Network.NetworkType == NetworkType.Mainnet ? 0x0488b21eU : 0x043587cf, false);
+                    for (int ii = 0; ii < 4; ii++)
+                        data[ii] = standardPrefix[ii];
+
+                    var derivationScheme = new BitcoinExtPubKey(Encoders.Base58Check.EncodeData(data), Network).ToString();
+                    electrumMapping.TryGetValue(prefix, out string[] labels);
+                    if (labels != null)
+                    {
+                        foreach (var label in labels)
+                        {
+                            hintedLabels.Add(label.ToLowerInvariant());
+                        }
+                    }
+                    parts[i] = derivationScheme;
+                }
+                catch { continue; }
+            }
+
+            if (hintDestination != null)
+            {
+                if (hintDestination is WitKeyId)
+                {
+                    hintedLabels.Remove("legacy");
+                    hintedLabels.Remove("p2sh");
+                }
+            }
+
+            str = string.Join('-', parts.Where(p => !IsLabel(p)));
+            foreach (var label in hintedLabels)
+            {
+                str = $"{str}-[{label}]";
+            }
+
+            return FindMatch(hintedLabels, new DerivationStrategyFactory(Network).Parse(str));
+        }
+
+        private DerivationStrategyBase FindMatch(HashSet<string> hintLabels, DerivationStrategyBase result)
+        {
+            var facto = new DerivationStrategyFactory(Network);
+            var firstKeyPath = new KeyPath("0/0");
+            if (HintScriptPubKey == null)
+                return result;
+            if (HintScriptPubKey == result.Derive(firstKeyPath).ScriptPubKey)
+                return result;
+
+            if (result is MultisigDerivationStrategy)
+                hintLabels.Add("keeporder");
+
+            var resultNoLabels = result.ToString();
+            resultNoLabels = string.Join('-', resultNoLabels.Split('-').Where(p => !IsLabel(p)));
+            foreach (var labels in ItemCombinations(hintLabels.ToList()))
+            {
+                var hinted = facto.Parse(resultNoLabels + '-' + string.Join('-', labels.Select(l=>$"[{l}]").ToArray()));
+                if (HintScriptPubKey == hinted.Derive(firstKeyPath).ScriptPubKey)
+                    return hinted;
+            }
+            throw new FormatException("Could not find any match");
+        }
+
+        private static bool IsLabel(string v)
+        {
+            return v.StartsWith('[') && v.EndsWith(']');
+        }
+
+        /// <summary>
+		/// Method to create lists containing possible combinations of an input list of items. This is 
+		/// basically copied from code by user "jaolho" on this thread:
+		/// http://stackoverflow.com/questions/7802822/all-possible-combinations-of-a-list-of-values
+		/// </summary>
+		/// <typeparam name="T">type of the items on the input list</typeparam>
+		/// <param name="inputList">list of items</param>
+		/// <param name="minimumItems">minimum number of items wanted in the generated combinations, 
+		///                            if zero the empty combination is included,
+		///                            default is one</param>
+		/// <param name="maximumItems">maximum number of items wanted in the generated combinations,
+		///                            default is no maximum limit</param>
+		/// <returns>list of lists for possible combinations of the input items</returns>
+		public static List<List<T>> ItemCombinations<T>(List<T> inputList, int minimumItems = 1,
+                                                        int maximumItems = int.MaxValue)
+        {
+            int nonEmptyCombinations = (int)Math.Pow(2, inputList.Count) - 1;
+            List<List<T>> listOfLists = new List<List<T>>(nonEmptyCombinations + 1);
+
+            if (minimumItems == 0)  // Optimize default case
+                listOfLists.Add(new List<T>());
+
+            for (int i = 1; i <= nonEmptyCombinations; i++)
+            {
+                List<T> thisCombination = new List<T>(inputList.Count);
+                for (int j = 0; j < inputList.Count; j++)
+                {
+                    if ((i >> j & 1) == 1)
+                        thisCombination.Add(inputList[j]);
+                }
+
+                if (thisCombination.Count >= minimumItems && thisCombination.Count <= maximumItems)
+                    listOfLists.Add(thisCombination);
+            }
+
+            return listOfLists;
+        }
+    }
+}

BTCPayServer/DerivationStrategy.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Payments;
+using BTCPayServer.Services.Invoices;
+using NBitcoin;
+using NBXplorer.DerivationStrategy;
+
+namespace BTCPayServer
+{
+    public class DerivationStrategy : ISupportedPaymentMethod
+    {
+        private DerivationStrategyBase _DerivationStrategy;
+        private BTCPayNetwork _Network;
+
+        public DerivationStrategy(DerivationStrategyBase result, BTCPayNetwork network)
+        {
+            this._DerivationStrategy = result;
+            this._Network = network;
+        }
+        
+        public static DerivationStrategy Parse(string derivationStrategy, BTCPayNetwork network)
+        {
+            if (network == null)
+                throw new ArgumentNullException(nameof(network));
+            if (derivationStrategy == null)
+                throw new ArgumentNullException(nameof(derivationStrategy));
+            var result = new NBXplorer.DerivationStrategy.DerivationStrategyFactory(network.NBitcoinNetwork).Parse(derivationStrategy);
+            return new DerivationStrategy(result, network);
+        }
+
+        public BTCPayNetwork Network { get { return this._Network; } }
+
+        public DerivationStrategyBase DerivationStrategyBase { get { return this._DerivationStrategy; } }
+
+        public PaymentMethodId PaymentId => new PaymentMethodId(Network.CryptoCode, PaymentTypes.BTCLike);
+
+        public override string ToString()
+        {
+            return _DerivationStrategy.ToString();
+        }
+    }
+}

BTCPayServer/EventAggregator.cs

@@ -0,0 +1,154 @@
+using System;
+using Microsoft.Extensions.Logging;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Logging;
+using System.Threading;
+
+namespace BTCPayServer
+{
+    public interface IEventAggregatorSubscription : IDisposable
+    {
+        void Unsubscribe();
+        void Resubscribe();
+    }
+    public class EventAggregator : IDisposable
+    {
+        class Subscription : IEventAggregatorSubscription
+        {
+            private EventAggregator aggregator;
+            Type t;
+            public Subscription(EventAggregator aggregator, Type t)
+            {
+                this.aggregator = aggregator;
+                this.t = t;
+            }
+
+            public Action<Object> Act { get; set; }
+
+            bool _Disposed;
+            public void Dispose()
+            {
+                if (_Disposed)
+                    return;
+                _Disposed = true;
+                lock (this.aggregator._Subscriptions)
+                {
+                    if (this.aggregator._Subscriptions.TryGetValue(t, out Dictionary<Subscription, Action<object>> actions))
+                    {
+                        if (actions.Remove(this))
+                        {
+                            if (actions.Count == 0)
+                                this.aggregator._Subscriptions.Remove(t);
+                        }
+                    }
+                }
+            }
+
+            public void Resubscribe()
+            {
+                aggregator.Subscribe(t, this);
+            }
+
+            public void Unsubscribe()
+            {
+                Dispose();
+            }
+        }
+        public Task<T> WaitNext<T>(CancellationToken cancellation = default(CancellationToken))
+        {
+            return WaitNext<T>(o => true, cancellation);
+        }
+        public async Task<T> WaitNext<T>(Func<T, bool> predicate, CancellationToken cancellation = default(CancellationToken))
+        {
+            TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
+            var subscription = Subscribe<T>((a, b) => { if (predicate(b)) { tcs.TrySetResult(b); a.Unsubscribe(); } });
+            using (cancellation.Register(() => { tcs.TrySetCanceled(); subscription.Unsubscribe(); }))
+            {
+                return await tcs.Task.ConfigureAwait(false);
+            }
+        }
+
+        public void Publish<T>(T evt) where T : class
+        {
+            Publish(evt, typeof(T));
+        }
+
+        public void Publish(object evt, Type evtType)
+        {
+            if (evt == null)
+                throw new ArgumentNullException(nameof(evt));
+            List<Action<object>> actionList = new List<Action<object>>();
+            lock (_Subscriptions)
+            {
+                if (_Subscriptions.TryGetValue(evtType, out Dictionary<Subscription, Action<object>> actions))
+                {
+                    actionList = actions.Values.ToList();
+                }
+            }
+
+            var log = evt.ToString();
+            if(!String.IsNullOrEmpty(log))
+                Logs.Events.LogInformation(log);
+            foreach (var sub in actionList)
+            {
+                try
+                {
+                    sub(evt);
+                }
+                catch (Exception ex)
+                {
+                    Logs.Events.LogError(ex, $"Error while calling event handler");
+                }
+            }
+        }
+
+        public IEventAggregatorSubscription Subscribe<T>(Action<IEventAggregatorSubscription, T> subscription)
+        {
+            var eventType = typeof(T);
+            var s = new Subscription(this, eventType);
+            s.Act = (o) => subscription(s, (T)o);
+            return Subscribe(eventType, s);
+        }
+
+        private IEventAggregatorSubscription Subscribe(Type eventType, Subscription subscription)
+        {
+            lock (_Subscriptions)
+            {
+                if (!_Subscriptions.TryGetValue(eventType, out Dictionary<Subscription, Action<object>> actions))
+                {
+                    actions = new Dictionary<Subscription, Action<object>>();
+                    _Subscriptions.Add(eventType, actions);
+                }
+                actions.Add(subscription, subscription.Act);
+            }
+            return subscription;
+        }
+
+        Dictionary<Type, Dictionary<Subscription, Action<object>>> _Subscriptions = new Dictionary<Type, Dictionary<Subscription, Action<object>>>();
+
+        public IEventAggregatorSubscription Subscribe<T, TReturn>(Func<T, TReturn> subscription)
+        {
+            return Subscribe(new Action<T>((t) => subscription(t)));
+        }
+
+        public IEventAggregatorSubscription Subscribe<T, TReturn>(Func<IEventAggregatorSubscription, T, TReturn> subscription)
+        {
+            return Subscribe(new Action<IEventAggregatorSubscription, T>((sub, t) => subscription(sub, t)));
+        }
+
+        public IEventAggregatorSubscription Subscribe<T>(Action<T> subscription)
+        {
+            return Subscribe(new Action<IEventAggregatorSubscription, T>((sub, t) => subscription(t)));
+        }
+
+        public void Dispose()
+        {
+            lock (_Subscriptions)
+            {
+                _Subscriptions.Clear();
+            }
+        }
+    }
+}

BTCPayServer/Events/InvoiceDataChangedEvent.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Invoices;
+
+namespace BTCPayServer.Events
+{
+    public class InvoiceDataChangedEvent
+    {
+        public InvoiceDataChangedEvent(InvoiceEntity invoice)
+        {
+            InvoiceId = invoice.Id;
+            Status = invoice.Status;
+            ExceptionStatus = invoice.ExceptionStatus;
+        }
+        public string InvoiceId { get; set; }
+        public string Status { get; internal set; }
+        public string ExceptionStatus { get; internal set; }
+
+        public override string ToString()
+        {
+            if (string.IsNullOrEmpty(ExceptionStatus) || ExceptionStatus == "false")
+            { 
+                return $"Invoice status is {Status}";
+            }
+            else
+            {
+                return $"Invoice status is {Status} (Exception status: {ExceptionStatus})";
+            }
+        }
+    }
+}

BTCPayServer/Events/InvoiceEvent.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Invoices;
+
+namespace BTCPayServer.Events
+{
+    public class InvoiceEvent
+    {
+        public InvoiceEvent(InvoiceEntity invoice, int code, string name) : this(invoice.Id, code, name)
+        {
+
+        }
+        public InvoiceEvent(string invoiceId, int code, string name)
+        {
+            InvoiceId = invoiceId;
+            EventCode = code;
+            Name = name;
+        }
+
+        public string InvoiceId { get; set; }
+        public int EventCode { get; set; }
+        public string Name { get; set; }
+
+        public override string ToString()
+        {
+            return $"Invoice {InvoiceId} new event: {Name} ({EventCode})";
+        }
+    }
+}

BTCPayServer/Events/InvoiceIPNEvent.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Events
+{
+    public class InvoiceIPNEvent
+    {
+        public InvoiceIPNEvent(string invoiceId, int? eventCode, string name)
+        {
+            InvoiceId = invoiceId;
+            EventCode = eventCode;
+            Name = name;
+        }
+
+        public int? EventCode { get; set; }
+        public string Name { get; set; }
+
+        public string InvoiceId { get; set; }
+        public string Error { get; set; }
+
+        public override string ToString()
+        {
+            string ipnType = "IPN";
+            if(EventCode.HasValue)
+            {
+                ipnType = $"IPN ({EventCode.Value} {Name})";
+            }
+            if (Error == null)
+                return $"{ipnType} sent for invoice {InvoiceId}";
+            return $"Error while sending {ipnType}: {Error}";
+        }
+    }
+}

BTCPayServer/Events/InvoiceNeedUpdateEvent.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Events
+{
+    public class InvoiceNeedUpdateEvent
+    {
+        public InvoiceNeedUpdateEvent(string invoiceId)
+        {
+            if (invoiceId == null)
+                throw new ArgumentNullException(nameof(invoiceId));
+            InvoiceId = invoiceId;
+        }
+
+        public string InvoiceId { get; set; }
+
+        public override string ToString()
+        {
+            return string.Empty;
+        }
+    }
+}

BTCPayServer/Events/InvoiceNewAddressEvent.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Events
+{
+    public class InvoiceNewAddressEvent
+    {
+        public InvoiceNewAddressEvent(string invoiceId, string address, BTCPayNetwork network)
+        {
+            Address = address;
+            InvoiceId = invoiceId;
+            Network = network;
+        }
+
+        public string Address { get; set; }
+        public string InvoiceId { get; set; }
+        public BTCPayNetwork Network { get; set; }
+        public override string ToString()
+        {
+            return $"{Network.CryptoCode}: New address {Address} for invoice {InvoiceId}";
+        }
+    }
+}

BTCPayServer/Events/InvoiceStopWatchedEvent.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Events
+{
+    public class InvoiceStopWatchedEvent
+    {
+        public InvoiceStopWatchedEvent(string invoiceId)
+        {
+            this.InvoiceId = invoiceId;
+        }
+        public string InvoiceId { get; set; }
+        public override string ToString()
+        {
+            return $"Invoice {InvoiceId} is not monitored anymore.";
+        }
+    }
+}

BTCPayServer/Events/NBXplorerStateChangedEvent.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.HostedServices;
+
+namespace BTCPayServer.Events
+{
+    public class NBXplorerStateChangedEvent
+    {
+        public NBXplorerStateChangedEvent(BTCPayNetwork network, NBXplorerState old, NBXplorerState newState)
+        {
+            Network = network;
+            NewState = newState;
+            OldState = old;
+        }
+
+        public BTCPayNetwork Network { get; set; }
+        public NBXplorerState NewState { get; set; }
+        public NBXplorerState OldState { get; set; }
+
+        public override string ToString()
+        {
+            return $"NBXplorer {Network.CryptoCode}: {OldState} => {NewState}";
+        }
+    }
+}

BTCPayServer/Events/NewBlockEvent.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Events
+{
+    public class NewBlockEvent
+    {
+        public string CryptoCode { get; set; }
+        public override string ToString()
+        {
+            return $"{CryptoCode}: New block";
+        }
+    }
+}

BTCPayServer/ExplorerClientProvider.cs

@@ -0,0 +1,104 @@
+using System;
+using Microsoft.Extensions.Logging;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Configuration;
+using BTCPayServer.Logging;
+using NBXplorer;
+using BTCPayServer.HostedServices;
+
+namespace BTCPayServer
+{
+    public class ExplorerClientProvider
+    {
+        BTCPayNetworkProvider _NetworkProviders;
+        BTCPayServerOptions _Options;
+
+        public BTCPayNetworkProvider NetworkProviders => _NetworkProviders;
+        NBXplorerDashboard _Dashboard;
+        public ExplorerClientProvider(BTCPayNetworkProvider networkProviders, BTCPayServerOptions options, NBXplorerDashboard dashboard)
+        {
+            _Dashboard = dashboard;
+            _NetworkProviders = networkProviders;
+            _Options = options;
+
+            foreach (var setting in options.NBXplorerConnectionSettings)
+            {
+                var cookieFile = setting.CookieFile;
+                if (cookieFile.Trim() == "0" || string.IsNullOrEmpty(cookieFile.Trim()))
+                    cookieFile = null;
+                Logs.Configuration.LogInformation($"{setting.CryptoCode}: Explorer url is {(setting.ExplorerUri.AbsoluteUri ?? "not set")}");
+                Logs.Configuration.LogInformation($"{setting.CryptoCode}: Cookie file is {(setting.CookieFile ?? "not set")}");
+                if (setting.ExplorerUri != null)
+                {
+                    _Clients.TryAdd(setting.CryptoCode, CreateExplorerClient(_NetworkProviders.GetNetwork(setting.CryptoCode), setting.ExplorerUri, setting.CookieFile));
+                }
+            }
+        }
+
+        private static ExplorerClient CreateExplorerClient(BTCPayNetwork n, Uri uri, string cookieFile)
+        {
+            var explorer = new ExplorerClient(n.NBXplorerNetwork, uri);
+            if (cookieFile == null)
+            {
+                Logs.Configuration.LogWarning($"{n.CryptoCode}: Not using cookie authentication");
+                explorer.SetNoAuth();
+            }
+            if(!explorer.SetCookieAuth(cookieFile))
+            {
+                Logs.Configuration.LogWarning($"{n.CryptoCode}: Using cookie auth against NBXplorer, but {cookieFile} is not found");
+            }
+            return explorer;
+        }
+
+        Dictionary<string, ExplorerClient> _Clients = new Dictionary<string, ExplorerClient>();
+
+        public ExplorerClient GetExplorerClient(string cryptoCode)
+        {
+            var network = _NetworkProviders.GetNetwork(cryptoCode);
+            if (network == null)
+                return null;
+            _Clients.TryGetValue(network.CryptoCode, out ExplorerClient client);
+            return client;
+        }
+
+        public ExplorerClient GetExplorerClient(BTCPayNetwork network)
+        {
+            if (network == null)
+                throw new ArgumentNullException(nameof(network));
+            return GetExplorerClient(network.CryptoCode);
+        }
+
+        public bool IsAvailable(BTCPayNetwork network)
+        {
+            return IsAvailable(network.CryptoCode);
+        }
+
+        public bool IsAvailable(string cryptoCode)
+        {
+            return _Clients.ContainsKey(cryptoCode) && _Dashboard.IsFullySynched(cryptoCode, out var unused);
+        }
+
+        public BTCPayNetwork GetNetwork(string cryptoCode)
+        {
+            var network = _NetworkProviders.GetNetwork(cryptoCode);
+            if (network == null)
+                return null;
+            if (_Clients.ContainsKey(network.CryptoCode))
+                return network;
+            return null;
+        }
+
+        public IEnumerable<(BTCPayNetwork, ExplorerClient)> GetAll()
+        {
+            foreach (var net in _NetworkProviders.GetAll())
+            {
+                if (_Clients.TryGetValue(net.CryptoCode, out ExplorerClient explorer))
+                {
+                    yield return (net, explorer);
+                }
+            }
+        }
+    }
+}

BTCPayServer/Extensions.cs

@@ -1,48 +1,182 @@
 using BTCPayServer.Authentication;
 using BTCPayServer.Configuration;
+using Microsoft.AspNetCore.Html;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
 using System;
 using System.Collections.Generic;
 using System.Text;
+using System.Text.Encodings.Web;
+using NBitcoin;
+using System.Threading.Tasks;
+using NBXplorer;
+using NBXplorer.Models;
+using System.Linq;
+using System.Threading;
+using BTCPayServer.Services.Wallets;
+using System.IO;
+using BTCPayServer.Logging;
+using Microsoft.Extensions.Logging;
+using System.Net.WebSockets;
+using BTCPayServer.Services.Invoices;
+using NBitpayClient;
+using BTCPayServer.Payments;
+using Microsoft.AspNetCore.Identity;
+using BTCPayServer.Models;
+using System.Security.Claims;
+using System.Globalization;
+using BTCPayServer.Services;
+using BTCPayServer.Data;
 
 namespace BTCPayServer
 {
     public static class Extensions
     {
-		public static string WithTrailingSlash(this string str)
-		{
-			if(str.EndsWith("/"))
-				return str;
-			return str + "/";
-		}
+        public static string PrettyPrint(this TimeSpan expiration)
+        {
+            StringBuilder builder = new StringBuilder();
+            if (expiration.Days >= 1)
+                builder.Append(expiration.Days.ToString(CultureInfo.InvariantCulture));
+            if (expiration.Hours >= 1)
+                builder.Append(expiration.Hours.ToString("00", CultureInfo.InvariantCulture));
+            builder.Append($"{expiration.Minutes.ToString("00", CultureInfo.InvariantCulture)}:{expiration.Seconds.ToString("00", CultureInfo.InvariantCulture)}");
+            return builder.ToString();
+        }
+        public static decimal RoundUp(decimal value, int precision)
+        {
+            for (int i = 0; i < precision; i++)
+            {
+                value = value * 10m;
+            }
+            value = Math.Ceiling(value);
+            for (int i = 0; i < precision; i++)
+            {
+                value = value / 10m;
+            }
+            return value;
+        }
+        public static PaymentMethodId GetpaymentMethodId(this InvoiceCryptoInfo info)
+        {
+            return new PaymentMethodId(info.CryptoCode, Enum.Parse<PaymentTypes>(info.PaymentType));
+        }
+        public static async Task CloseSocket(this WebSocket webSocket)
+        {
+            try
+            {
+                if (webSocket.State == WebSocketState.Open)
+                {
+                    CancellationTokenSource cts = new CancellationTokenSource();
+                    cts.CancelAfter(5000);
+                    await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", cts.Token);
+                }
+            }
+            catch { }
+            finally { try { webSocket.Dispose(); } catch { } }
+        }
+        public static bool SupportDropColumn(this Microsoft.EntityFrameworkCore.Migrations.Migration migration, string activeProvider)
+        {
+            return activeProvider != "Microsoft.EntityFrameworkCore.Sqlite";
+        }
 
-		public static string GetAbsoluteRoot(this HttpRequest request)
-		{
-			return string.Concat(
-						request.Scheme,
-						"://",
-						request.Host.ToUriComponent(),
-						request.PathBase.ToUriComponent());
-		}
+        public static async Task<Dictionary<uint256, TransactionResult>> GetTransactions(this BTCPayWallet client, uint256[] hashes, CancellationToken cts = default(CancellationToken))
+        {
+            hashes = hashes.Distinct().ToArray();
+            var transactions = hashes
+                                        .Select(async o => await client.GetTransactionAsync(o, cts))
+                                        .ToArray();
+            await Task.WhenAll(transactions).ConfigureAwait(false);
+            return transactions.Select(t => t.Result).Where(t => t != null).ToDictionary(o => o.Transaction.GetHash());
+        }
+        public static string WithTrailingSlash(this string str)
+        {
+            if (str.EndsWith("/", StringComparison.InvariantCulture))
+                return str;
+            return str + "/";
+        }
 
-		public static IServiceCollection ConfigureBTCPayServer(this IServiceCollection services, IConfiguration conf)
-		{
-			services.Configure<BTCPayServerOptions>(o =>
-			{
-				o.LoadArgs(conf);
-			});
-			return services;
-		}
+        public static string GetAbsoluteRoot(this HttpRequest request)
+        {
+            return string.Concat(
+                        request.Scheme,
+                        "://",
+                        request.Host.ToUriComponent(),
+                        request.PathBase.ToUriComponent());
+        }
 
+        public static string GetAbsoluteUri(this HttpRequest request, string redirectUrl)
+        {
+            bool isRelative = 
+                (redirectUrl.Length > 0 && redirectUrl[0] == '/')
+                || !new Uri(redirectUrl, UriKind.RelativeOrAbsolute).IsAbsoluteUri;
+            return isRelative ? request.GetAbsoluteRoot() + redirectUrl : redirectUrl;
+        }
 
-		public static BitIdentity GetBitIdentity(this Controller controller, bool throws = true)
-		{
-			if(!(controller.User.Identity is BitIdentity))
-				return throws ? throw new UnauthorizedAccessException("no-bitid") : (BitIdentity)null;
-			return (BitIdentity)controller.User.Identity;
-		}
-	}
+        public static IServiceCollection ConfigureBTCPayServer(this IServiceCollection services, IConfiguration conf)
+        {
+            services.Configure<BTCPayServerOptions>(o =>
+            {
+                o.LoadArgs(conf);
+            });
+            return services;
+        }
+
+        public static string GetSIN(this ClaimsPrincipal principal)
+        {
+            return principal.Claims.Where(c => c.Type == Claims.SIN).Select(c => c.Value).FirstOrDefault();
+        }
+
+        public static string GetStoreId(this ClaimsPrincipal principal)
+        {
+            return principal.Claims.Where(c => c.Type == Claims.OwnStore).Select(c => c.Value).FirstOrDefault();
+        }
+
+        public static void SetIsBitpayAPI(this HttpContext ctx, bool value)
+        {
+            NBitcoin.Extensions.TryAdd(ctx.Items, "IsBitpayAPI", value);
+        }
+
+        public static void AddRange<T>(this HashSet<T> hashSet, IEnumerable<T> items)
+        {
+            foreach(var item in items)
+            {
+                hashSet.Add(item);
+            }
+        }
+        public static bool GetIsBitpayAPI(this HttpContext ctx)
+        {
+            return ctx.Items.TryGetValue("IsBitpayAPI", out object obj) &&
+                  obj is bool b && b;
+        }
+
+        public static void SetBitpayAuth(this HttpContext ctx, (string Signature, String Id, String Authorization) value)
+        {
+            NBitcoin.Extensions.TryAdd(ctx.Items, "BitpayAuth", value);
+        }
+
+        public static (string Signature, String Id, String Authorization) GetBitpayAuth(this HttpContext ctx)
+        {
+            ctx.Items.TryGetValue("BitpayAuth", out object obj);
+            return ((string Signature, String Id, String Authorization))obj;
+        }
+
+        public static StoreData GetStoreData(this HttpContext ctx)
+        {
+            return ctx.Items.TryGet("BTCPAY.STOREDATA") as StoreData;
+        }
+        public static void SetStoreData(this HttpContext ctx, StoreData storeData)
+        {
+            ctx.Items["BTCPAY.STOREDATA"] = storeData;
+        }
+
+        private static JsonSerializerSettings jsonSettings = new JsonSerializerSettings { ContractResolver = new CamelCasePropertyNamesContractResolver() };
+        public static string ToJson(this object o)
+        {
+            var res = JsonConvert.SerializeObject(o, Formatting.None, jsonSettings);
+            return res;
+        }
+    }
 }

BTCPayServer/Filters/OnlyMediaTypeAttribute.cs

@@ -7,70 +7,70 @@ using System.Text;
 
 namespace BTCPayServer.Filters
 {
-    public class MediaTypeConstraintAttribute : Attribute,  IActionConstraint
-	{
-		public MediaTypeConstraintAttribute(string mediaType)
-		{
-			MediaType = mediaType ?? throw new ArgumentNullException(nameof(mediaType));
-		}
+    public class MediaTypeConstraintAttribute : Attribute, IActionConstraint
+    {
+        public MediaTypeConstraintAttribute(string mediaType)
+        {
+            MediaType = mediaType ?? throw new ArgumentNullException(nameof(mediaType));
+        }
 
-		public string MediaType
-		{
-			get; set;
-		}
+        public string MediaType
+        {
+            get; set;
+        }
 
-		public int Order => 100;
+        public int Order => 100;
 
-		public bool Accept(ActionConstraintContext context)
-		{
-			var match = context.RouteContext.HttpContext.Request.ContentType?.StartsWith(MediaType, StringComparison.Ordinal);
-			return match.HasValue && match.Value;
-		}
-	}
+        public bool Accept(ActionConstraintContext context)
+        {
+            var match = context.RouteContext.HttpContext.Request.ContentType?.StartsWith(MediaType, StringComparison.Ordinal);
+            return match.HasValue && match.Value;
+        }
+    }
 
-	public class BitpayAPIConstraintAttribute : Attribute, IActionConstraint
-	{
-		public BitpayAPIConstraintAttribute(bool isBitpayAPI = true)
-		{
-			IsBitpayAPI = isBitpayAPI;
-		}
+    public class BitpayAPIConstraintAttribute : Attribute, IActionConstraint
+    {
+        public BitpayAPIConstraintAttribute(bool isBitpayAPI = true)
+        {
+            IsBitpayAPI = isBitpayAPI;
+        }
 
-		public bool IsBitpayAPI
-		{
-			get; set;
-		}
-		public int Order => 100;
+        public bool IsBitpayAPI
+        {
+            get; set;
+        }
+        public int Order => 100;
 
-		public bool Accept(ActionConstraintContext context)
-		{
-			return context.RouteContext.HttpContext.Request.Headers["x-accept-version"].Where(h => h == "2.0.0").Any() == IsBitpayAPI;
-		}
-	}
+        public bool Accept(ActionConstraintContext context)
+        {
+            return context.RouteContext.HttpContext.GetIsBitpayAPI() == IsBitpayAPI;
+        }
+    }
 
-	public class AcceptMediaTypeConstraintAttribute : Attribute, IActionConstraint
-	{
-		public AcceptMediaTypeConstraintAttribute(string mediaType, bool expectedValue = true)
-		{
-			MediaType = mediaType ?? throw new ArgumentNullException(nameof(mediaType));
-			ExpectedValue = expectedValue;
-		}
+    public class AcceptMediaTypeConstraintAttribute : Attribute, IActionConstraint
+    {
+        public AcceptMediaTypeConstraintAttribute(string mediaType, bool expectedValue = true)
+        {
+            MediaType = mediaType ?? throw new ArgumentNullException(nameof(mediaType));
+            ExpectedValue = expectedValue;
+        }
 
-		public bool ExpectedValue
-		{
-			get; set;
-		}
+        public bool ExpectedValue
+        {
+            get; set;
+        }
 
-		public string MediaType
-		{
-			get; set;
-		}
+        public string MediaType
+        {
+            get; set;
+        }
 
-		public int Order => 100;
+        public int Order => 100;
 
-		public bool Accept(ActionConstraintContext context)
-		{
-			var match = context.RouteContext.HttpContext.Request.Headers["Accept"].FirstOrDefault()?.StartsWith(MediaType, StringComparison.Ordinal);
-			return (match.HasValue && match.Value) == ExpectedValue;
-		}
-	}
+        public bool Accept(ActionConstraintContext context)
+        {
+            var hasHeader = context.RouteContext.HttpContext.Request.Headers["Accept"].Any(m => m.StartsWith(MediaType, StringComparison.Ordinal));
+            return hasHeader == ExpectedValue;
+        }
+    }
 }