try to better respect event ordering

Payment Tolerance

.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

@@ -4,10 +4,11 @@
     <TargetFramework>netcoreapp2.0</TargetFramework>
 
     <IsPackable>false</IsPackable>
+    <NoWarn>NU1701,CA1816,CA1308,CA1810,CA2208</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.7.0" />
     <PackageReference Include="xunit" Version="2.3.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />
   </ItemGroup>

BTCPayServer.Tests/BTCPayServerTester.cs

@@ -1,7 +1,12 @@
 using BTCPayServer.Configuration;
 using BTCPayServer.Hosting;
+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;
@@ -43,21 +48,15 @@ namespace BTCPayServer.Tests
         {
             get; set;
         }
-        public string CookieFile
-        {
-            get; set;
-        }
+
+        public Uri LTCNBXplorerUri { get; set; }
+
         public Uri ServerUri
         {
             get;
             set;
         }
 
-        public ExtKey HDPrivateKey
-        {
-            get; set;
-        }
-
         public string Postgres
         {
             get; set;
@@ -69,31 +68,45 @@ namespace BTCPayServer.Tests
             get; set;
         }
 
+
+        public bool MockRates { get; set; } = true;
+
         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);
+
 
-            HDPrivateKey = new ExtKey();
             StringBuilder config = new StringBuilder();
-            config.AppendLine($"regtest=1");
+            config.AppendLine($"{chain.ToLowerInvariant()}=1");
             config.AppendLine($"port={Port}");
-            config.AppendLine($"explorer.url={NBXplorerUri.AbsoluteUri}");
-            config.AppendLine($"explorer.cookiefile={CookieFile}");
-            config.AppendLine($"hdpubkey={HDPrivateKey.Neuter().ToString(Network.RegTest)}");
+            config.AppendLine($"chains=btc,ltc");
+
+            config.AppendLine($"btc.explorer.url={NBXplorerUri.AbsoluteUri}");
+            config.AppendLine($"btc.explorer.cookiefile=0");
+
+            config.AppendLine($"ltc.explorer.url={LTCNBXplorerUri.AbsoluteUri}");
+            config.AppendLine($"ltc.explorer.cookiefile=0");
+
+            config.AppendLine($"btc.lightning={IntegratedLightning.AbsoluteUri}");
+
             if (Postgres != null)
                 config.AppendLine($"postgres=" + Postgres);
-            File.WriteAllText(Path.Combine(_Directory, "settings.config"), config.ToString());
+            var confPath = Path.Combine(chainDirectory, "settings.config");
+            File.WriteAllText(confPath, config.ToString());
 
             ServerUri = new Uri("http://" + HostName + ":" + Port + "/");
 
-            var conf = new DefaultConfiguration() { Logger = Logs.LogProvider.CreateLogger("Console") }.CreateConfiguration(new[] { "--datadir", _Directory });
-
+            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.AddSingleton<IRateProvider>(new MockRateProvider(new Rate("USD", 5000m)));
                         s.AddLogging(l =>
                         {
                             l.SetMinimumLevel(LogLevel.Information)
@@ -108,26 +121,46 @@ namespace BTCPayServer.Tests
             _Host.Start();
             InvoiceRepository = (InvoiceRepository)_Host.Services.GetService(typeof(InvoiceRepository));
 
-            var waiter = ((NBXplorerWaiterAccessor)_Host.Services.GetService(typeof(NBXplorerWaiterAccessor))).Instance;
-            while(waiter.State != NBXplorerState.Ready)
+            var rateProvider = (BTCPayRateProviderFactory)_Host.Services.GetService(typeof(BTCPayRateProviderFactory));
+            rateProvider.DirectProviders.Clear();
+
+            var coinAverageMock = new MockRateProvider();
+            coinAverageMock.ExchangeRates.Add(new Rating.ExchangeRate()
             {
-                Thread.Sleep(10);
-            }
+                Exchange = "coinaverage",
+                CurrencyPair = CurrencyPair.Parse("BTC_USD"),
+                Value = 5000m
+            });
+            coinAverageMock.ExchangeRates.Add(new Rating.ExchangeRate()
+            {
+                Exchange = "coinaverage",
+                CurrencyPair = CurrencyPair.Parse("BTC_CAD"),
+                Value = 4500m
+            });
+            coinAverageMock.ExchangeRates.Add(new Rating.ExchangeRate()
+            {
+                Exchange = "coinaverage",
+                CurrencyPair = CurrencyPair.Parse("LTC_USD"),
+                Value = 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) where T : Controller
+        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");
@@ -135,7 +168,11 @@ namespace BTCPayServer.Tests
             context.Request.Protocol = "http";
             if (userId != null)
             {
-                context.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim(ClaimTypes.NameIdentifier, userId) }));
+                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;

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/Dockerfile

@@ -1,4 +1,4 @@
-FROM microsoft/dotnet:2.0.0-sdk
+FROM microsoft/dotnet:2.0.6-sdk-2.1.101-stretch
 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/EclairTester.cs

@@ -1,37 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Threading.Tasks;
-using BTCPayServer.Eclair;
-
-namespace BTCPayServer.Tests
-{
-    public class EclairTester
-    {
-        ServerTester parent;
-        public EclairTester(ServerTester parent, string environmentName, string defaultRPC, string defaultHost)
-        {
-            this.parent = parent;
-            RPC = new EclairRPCClient(new Uri(parent.GetEnvironment(environmentName, defaultRPC)), parent.Network);
-            P2PHost = parent.GetEnvironment(environmentName + "_HOST", defaultHost);
-        }
-
-        public EclairRPCClient RPC { get; }
-        public string P2PHost { get; }
-
-        NodeInfo _NodeInfo;
-        public async Task<NodeInfo> GetNodeInfoAsync()
-        {
-            if (_NodeInfo != null)
-                return _NodeInfo;
-            var info = await RPC.GetInfoAsync();
-            _NodeInfo = new NodeInfo(info.NodeId, P2PHost, info.Port);
-            return _NodeInfo;
-        }
-
-        public NodeInfo GetNodeInfo()
-        {
-            return GetNodeInfoAsync().GetAwaiter().GetResult();
-        }
-    }
-}

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

@@ -71,7 +71,11 @@ namespace BTCPayServer.Tests.Logging
         public void LogInformation(string msg)
         {
             if (msg != null)
-                _Helper.WriteLine(DateTimeOffset.UtcNow + " :" + Name + ":   " + msg);
+                try
+                {
+                    _Helper.WriteLine(DateTimeOffset.UtcNow + " :" + Name + ":   " + msg);
+                }
+                catch { }
         }
     }
     public class Logs

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/README.md

@@ -1,12 +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
@@ -24,7 +26,7 @@ docker-compose down
 If you want to stop, and remove all existing data
 
 ```
-docker-compose down -v
+docker-compose down --v
 ```
 
 You can run the tests inside a container by running
@@ -33,14 +35,50 @@ You can run the tests inside a container by running
 docker-compose run --rm tests
 ```
 
-## Send commands to bitcoind
+## 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 exec -ti btcpayserver_dev_bitcoind bitcoin-cli -regtest -conf="/data/bitcoin.conf" -datadir="/data" sendtoaddress "mohu16LH66ptoWGEL1GtP6KHTBJYXMWhEf" 0.23111090
+./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:
+
+```
+{ "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,134 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Text;
+using BTCPayServer.Rating;
+using Xunit;
+
+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: "BTC_USD", Expected: "gdax(BTC_USD)"),
+                (Pair: "BTC_CAD", Expected: "coinbase(BTC_CAD)"),
+                (Pair: "DOGE_USD", Expected: "bittrex(DOGE_BTC) * gdax(BTC_USD) * 1.1"),
+                (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: "BTC_USD", Expected: "gdax(BTC_USD)", ExpectedExchangeRates: "gdax(BTC_USD)"),
+                (Pair: "BTC_CAD", Expected: "coinbase(BTC_CAD)", ExpectedExchangeRates: "coinbase(BTC_CAD)"),
+                (Pair: "DOGE_USD", Expected: "bittrex(DOGE_BTC) * gdax(BTC_USD) * 1.1", ExpectedExchangeRates: "bittrex(DOGE_BTC),gdax(BTC_USD)"),
+                (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"), 5000);
+            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"), 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"), 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"), 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);
+            ////////
+        }
+    }
+}

BTCPayServer.Tests/ServerTester.cs

@@ -17,7 +17,9 @@ using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading.Tasks;
 using System.Threading;
-using BTCPayServer.Eclair;
+using System.Globalization;
+using BTCPayServer.Payments.Lightning.CLightning;
+using BTCPayServer.Payments.Lightning.Charge;
 
 namespace BTCPayServer.Tests
 {
@@ -32,6 +34,34 @@ namespace BTCPayServer.Tests
         public ServerTester(string scope)
         {
             _Directory = scope;
+            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);
+
+            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/")));
+
+            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);
+
+            MerchantCharge = new ChargeTester(this, "TEST_MERCHANTCHARGE", "http://api-token:foiewnccewuify@127.0.0.1:54938/", "merchant_lightningd", btc);
+
+            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 bool Dockerized
@@ -41,57 +71,89 @@ namespace BTCPayServer.Tests
 
         public void Start()
         {
-            if (Directory.Exists(_Directory))
-                Utils.DeleteDirectory(_Directory);
-            if (!Directory.Exists(_Directory))
-                Directory.CreateDirectory(_Directory);
-
-
-            FakeCallback = bool.Parse(GetEnvironment("TESTS_FAKECALLBACK", "true"));
-            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.Port = int.Parse(GetEnvironment("TESTS_PORT", Utils.FreeTcpPort().ToString()));
-            PayTester.HostName = GetEnvironment("TESTS_HOSTNAME", "127.0.0.1");
             PayTester.Start();
-
-            MerchantEclair = new EclairTester(this, "TEST_ECLAIR1", "http://127.0.0.1:30992/", "eclair1");
-            CustomerEclair = new EclairTester(this, "TEST_ECLAIR2", "http://127.0.0.1:30993/", "eclair2");
         }
 
 
         /// <summary>
-        /// This will setup a channel going from customer to merchant
+        /// 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()
         {
-            // Activate segwit
-            var blockCount = ExplorerNode.GetBlockCountAsync();
-            // Fetch node info, but that in cache
-            var merchant = MerchantEclair.GetNodeInfoAsync();
-            var customer = CustomerEclair.GetNodeInfoAsync();
-            var channels = CustomerEclair.RPC.ChannelsAsync();
-            var connect = CustomerEclair.RPC.ConnectAsync(merchant.Result);
-            await Task.WhenAll(blockCount, merchant, customer, channels, connect);
-
-            // Mine until segwit is activated
-            if (blockCount.Result <= 432)
+            while (true)
             {
-                ExplorerNode.Generate(433 - blockCount.Result);
+                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 ?? "");
+                }
             }
         }
 
-        public EclairTester MerchantEclair { get; set; }
-        public EclairTester CustomerEclair { get; set; }
+        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)
         {
@@ -104,20 +166,22 @@ namespace BTCPayServer.Tests
             return new TestAccount(this);
         }
 
-        public bool FakeCallback
-        {
-            get;
-            set;
-        }
+        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();
 
@@ -213,55 +277,12 @@ namespace BTCPayServer.Tests
             }
         }
 
-        /// <summary>
-        /// Simulating callback from NBXplorer. NBXplorer can't reach the host during tests as it is not running on localhost.
-        /// </summary>
-        /// <param name="address"></param>
-        public void SimulateCallback(BitcoinAddress address = null)
-        {
-            if (!FakeCallback) //The callback of NBXplorer should work
-                return;
-
-            var req = new MockHttpRequest(PayTester.ServerUri);
-            var controller = PayTester.GetController<CallbackController>();
-            if (address != null)
-            {
-
-                var match = new TransactionMatch();
-                match.Outputs.Add(new KeyPathInformation() { ScriptPubKey = address.ScriptPubKey });
-                var content = new StringContent(new NBXplorer.Serializer(Network).ToString(match), new UTF8Encoding(false), "application/json");
-                var uri = controller.GetCallbackUriAsync().GetAwaiter().GetResult();
-
-                HttpRequestMessage message = new HttpRequestMessage();
-                message.Method = HttpMethod.Post;
-                message.RequestUri = uri;
-                message.Content = content;
-
-                _Http.SendAsync(message).GetAwaiter().GetResult();
-            }
-            else
-            {
-
-                var uri = controller.GetCallbackBlockUriAsync().GetAwaiter().GetResult();
-                HttpRequestMessage message = new HttpRequestMessage();
-                message.Method = HttpMethod.Post;
-                message.RequestUri = uri;
-                _Http.SendAsync(message).GetAwaiter().GetResult();
-            }
-        }
-
 
         public BTCPayServerTester PayTester
         {
             get; set;
         }
 
-        public Network Network
-        {
-            get;
-            set;
-        } = Network.RegTest;
-
         public void Dispose()
         {
             if (PayTester != null)

BTCPayServer.Tests/TestAccount.cs

@@ -1,4 +1,5 @@
 using BTCPayServer.Controllers;
+using System.Linq;
 using BTCPayServer.Models.AccountViewModels;
 using BTCPayServer.Models.StoreViewModels;
 using BTCPayServer.Services.Invoices;
@@ -11,6 +12,8 @@ using System.Text;
 using System.Threading.Tasks;
 using Xunit;
 using NBXplorer.DerivationStrategy;
+using BTCPayServer.Payments;
+using BTCPayServer.Payments.Lightning;
 
 namespace BTCPayServer.Tests
 {
@@ -41,28 +44,50 @@ namespace BTCPayServer.Tests
         public async Task GrantAccessAsync()
         {
             await RegisterAsync();
-            var store = await CreateStoreAsync();
+            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 StoresController CreateStore()
+        public void CreateStore()
         {
-            return CreateStoreAsync().GetAwaiter().GetResult();
+            CreateStoreAsync().GetAwaiter().GetResult();
         }
-        public async Task<StoresController> CreateStoreAsync()
+
+        public T GetController<T>(bool setImplicitStore = true) where T : Controller
         {
-            ExtKey = new ExtKey().GetWif(parent.Network);
-            var store = parent.PayTester.GetController<StoresController>(UserId);
+            return parent.PayTester.GetController<T>(UserId, setImplicitStore ? StoreId : null);
+        }
+
+        public async Task CreateStoreAsync()
+        {
+            var store = this.GetController<UserStoresController>();
             await store.CreateStore(new CreateStoreViewModel() { Name = "Test Store" });
             StoreId = store.CreatedStoreId;
-            DerivationScheme = new DerivationStrategyFactory(parent.Network).Parse(ExtKey.Neuter().ToString() + "-[legacy]");
-            await store.UpdateStore(StoreId, new StoreViewModel()
+        }
+
+        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(),
-                SpeedPolicy = SpeedPolicy.MediumSpeed
-            }, "Save");
-            return store;
+                Confirmation = true
+            }, cryptoCode);
         }
 
         public DerivationStrategyBase DerivationScheme { get; set; }
@@ -92,5 +117,24 @@ namespace BTCPayServer.Tests
         {
             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/UnitTestPeusa.cs

@@ -1,50 +0,0 @@
-using NBitcoin;
-using NBitcoin.DataEncoders;
-using NBitpayClient;
-using System;
-using System.Collections.Generic;
-using System.Text;
-using Xunit;
-
-namespace BTCPayServer.Tests
-{
-    // Helper class for testing functionality and generating data needed during coding/debuging
-    public class UnitTestPeusa
-    {
-        // Unit test that generates temorary checkout Bitpay page
-        // https://forkbitpay.slack.com/archives/C7M093Z55/p1508293682000217
-        [Fact]
-        public void BitpayCheckout()
-        {
-            var key = new Key(Encoders.Hex.DecodeData("7b70a06f35562873e3dcb46005ed0fe78e1991ad906e56adaaafa40ba861e056"));
-            var url = new Uri("https://test.bitpay.com/");
-            var btcpay = new Bitpay(key, url);
-            var invoice = btcpay.CreateInvoice(new Invoice()
-            {
-
-                Price = 5.0,
-                Currency = "USD",
-                PosData = "posData",
-                OrderId = "cdfd8a5f-6928-4c3b-ba9b-ddf438029e73",
-                ItemDesc = "Hello from the otherside"
-            }, Facade.Merchant);
-
-            // go to invoice.Url
-            Console.WriteLine(invoice.Url);
-        }
-
-        // Generating Extended public key to use on http://localhost:14142/stores/{storeId}
-        [Fact]
-        public void GeneratePubkey()
-        {
-            var network = Network.RegTest;
-
-            ExtKey masterKey = new ExtKey();
-            Console.WriteLine("Master key : " + masterKey.ToString(network));
-            ExtPubKey masterPubKey = masterKey.Neuter();
-
-            ExtPubKey pubkey = masterPubKey.Derive(0);
-            Console.WriteLine("PubKey " + 0 + " : " + pubkey.ToString(network));
-        }
-    }
-}

BTCPayServer.Tests/docker-bitcoin-cli.ps1

@@ -1 +1 @@
-docker exec -ti btcpayserver_dev_bitcoind bitcoin-cli -regtest -conf="/data/bitcoin.conf" -datadir="/data" $args
+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,7 +1,7 @@
-version: "3"
+version: "3"    
 
 # Run `docker-compose up dev` for bootstrapping your development environment
-# Doing so will expose eclair API, NBXplorer, Bitcoind RPC and postgres port to the host so that tests can Run,
+# 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:
 
@@ -10,101 +10,67 @@ 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_FAKECALLBACK: 'false'
       TESTS_PORT: 80
       TESTS_HOSTNAME: tests
-      TEST_ECLAIR1: http://eclair1:8080/
-      TEST_ECLAIR2: http://eclair2:8080/
+      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:
-      - bitcoind
-      - nbxplorer
-      - eclair1
-      - eclair2
+      - 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.15.0.1
+    image: nicolasdorier/docker-bitcoin:0.16.0
     environment:
       BITCOIN_EXTRA_ARGS: |
         regtest=1
         connect=bitcoind:39388
     links:
-      - bitcoind
       - nbxplorer
-      - eclair1
-      - eclair2
+      - postgres
+      - customer_lightningd
+      - merchant_lightningd
+      - lightning-charged
 
   nbxplorer:
-    image: nicolasdorier/nbxplorer:1.0.0.32
+    image: nicolasdorier/nbxplorer:1.0.2.3
     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
-
-  eclair1:
-    image: acinq/eclair:latest
-    environment:
-      JAVA_OPTS: >
-        -Xmx512m 
-        -Declair.printToConsole 
-        -Declair.bitcoind.host=bitcoind 
-        -Declair.bitcoind.rpcport=43782 
-        -Declair.bitcoind.rpcuser=ceiwHEbqWI83 
-        -Declair.bitcoind.rpcpassword=DwubwWsoo3 
-        -Declair.bitcoind.zmq=tcp://bitcoind:29000
-        -Declair.chain=regtest
-        -Declair.api.binding-ip=0.0.0.0
-    links:
-      - bitcoind
-    ports:
-      - "30992:8080" # api port
-    expose:
-      - "9735" # server port
-      - "8080" # api port
-
-  eclair2:
-    image: acinq/eclair:latest
-    environment:
-      JAVA_OPTS: >
-        -Xmx512m 
-        -Declair.printToConsole 
-        -Declair.bitcoind.host=bitcoind 
-        -Declair.bitcoind.rpcport=43782 
-        -Declair.bitcoind.rpcuser=ceiwHEbqWI83 
-        -Declair.bitcoind.rpcpassword=DwubwWsoo3 
-        -Declair.bitcoind.zmq=tcp://bitcoind:29000
-        -Declair.chain=regtest
-        -Declair.api.binding-ip=0.0.0.0
-    links:
-      - bitcoind
-    ports:
-      - "30993:8080" # api port
-    expose:
-      - "9735" # server port
-      - "8080" # api port
+      - litecoind
 
   bitcoind:
-    container_name: btcpayserver_dev_bitcoind
-    image: nicolasdorier/docker-bitcoin:0.15.0.1
+    image: nicolasdorier/docker-bitcoin:0.16.0
     environment:
       BITCOIN_EXTRA_ARGS: |
         rpcuser=ceiwHEbqWI83
@@ -114,15 +80,93 @@ services:
         rpcport=43782
         port=39388
         whitelist=0.0.0.0/0
-        zmqpubrawblock=tcp://0.0.0.0:29000
-        zmqpubrawtx=tcp://0.0.0.0:29000
-        txindex=1
-    ports:
-      - "43782:43782" # RPC
+    ports: 
+      - "43782:43782"
+    expose:
+      - "43782" # RPC
+      - "39388" # P2P
+    volumes:
+      - "bitcoin_datadir:/data"
+
+  customer_lightningd:
+    image: nicolasdorier/clightning:0.0.0.12-dev
+    environment: 
+      EXPOSE_TCP: "true"
+      LIGHTNINGD_OPT: |
+        bitcoin-datadir=/etc/bitcoin
+        bitcoin-rpcconnect=bitcoind
+        network=regtest
+        ipaddr=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.9
+    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.11-dev
+    environment: 
+      EXPOSE_TCP: "true"
+      LIGHTNINGD_OPT: |
+        bitcoin-datadir=/etc/bitcoin
+        bitcoin-rpcconnect=bitcoind
+        ipaddr=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
-      - "29000" # zmq
 
   postgres:
     image:  postgres:9.6.5
@@ -130,3 +174,9 @@ services:
       - "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/TokenRepository.cs

@@ -33,6 +33,8 @@ namespace BTCPayServer.Authentication
 
         public async Task<BitTokenEntity[]> GetTokens(string sin)
         {
+            if (sin == null)
+                return Array.Empty<BitTokenEntity>();
             using (var ctx = _Factory.CreateContext())
             {
                 return (await ctx.PairedSINData
@@ -43,6 +45,46 @@ namespace BTCPayServer.Authentication
             }
         }
 
+        public async Task<String> GetStoreIdFromAPIKey(string apiKey)
+        {
+            using (var ctx = _Factory.CreateContext())
+            {
+                return await ctx.ApiKeys.Where(o => o.Id == apiKey).Select(o => o.StoreId).FirstOrDefaultAsync();
+            }
+        }
+
+        public async Task GenerateLegacyAPIKey(string storeId)
+        {
+            // It is legacy support and Bitpay generate string of unknown format, trying to replicate them
+            // as good as possible. The string below got generated for me.
+            var chars = "ERo0vkBMOYhyU0ZHvirCplbLDIGWPdi1ok77VnW7QdE";
+            var rand = new Random(Math.Abs(RandomUtils.GetInt32()));
+            var generated = new char[chars.Length];
+            for (int i = 0; i < generated.Length; i++)
+            {
+                generated[i] = chars[rand.Next(0, generated.Length)];
+            }
+
+            using (var ctx = _Factory.CreateContext())
+            {
+                var existing = await ctx.ApiKeys.Where(o => o.StoreId == storeId).FirstOrDefaultAsync();
+                if (existing != null)
+                {
+                    ctx.ApiKeys.Remove(existing);
+                }
+                ctx.ApiKeys.Add(new APIKeyData() { Id = new string(generated), StoreId = storeId });
+                await ctx.SaveChangesAsync().ConfigureAwait(false);
+            }
+        }
+
+        public async Task<string[]> GetLegacyAPIKeys(string storeId)
+        {
+            using (var ctx = _Factory.CreateContext())
+            {
+                return await ctx.ApiKeys.Where(o => o.StoreId == storeId).Select(c => c.Id).ToArrayAsync();
+            }
+        }
+
         private BitTokenEntity CreateTokenEntity(PairedSINData data)
         {
             return new BitTokenEntity()

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

@@ -0,0 +1,97 @@
+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();
+        }
+
+        /// <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

@@ -2,13 +2,26 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp2.0</TargetFramework>
-		<Version>1.0.0.45</Version>
+		<Version>1.0.2.6</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,26 +30,33 @@
     <EmbeddedResource Include="Currencies.txt" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Hangfire" Version="1.6.17" />
+    <PackageReference Include="BuildBundlerMinifier" Version="2.6.375" />
+    <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.1" />
+    <PackageReference Include="LedgerWallet" Version="1.0.1.36" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="2.6.1" />
+    <PackageReference Include="Meziantou.AspNetCore.BundleTagHelpers" Version="1.0.1" />
     <PackageReference Include="Microsoft.Extensions.Logging.Filter" Version="1.1.2" />
-    <PackageReference Include="NBitcoin" Version="4.0.0.50" />
-    <PackageReference Include="NBitpayClient" Version="1.0.0.13" />	  
+    <PackageReference Include="Microsoft.NetCore.Analyzers" Version="2.6.0" />
+    <PackageReference Include="NBitcoin" Version="4.1.1.4" />
+    <PackageReference Include="NBitpayClient" Version="1.0.0.18" />	  
     <PackageReference Include="DBreeze" Version="1.87.0" />
-    <PackageReference Include="NBXplorer.Client" Version="1.0.0.20" />
+    <PackageReference Include="NBXplorer.Client" Version="1.0.2.4" />
     <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="Npgsql.EntityFrameworkCore.PostgreSQL" Version="2.0.1" />
     <PackageReference Include="System.ValueTuple" Version="4.4.0" />
     <PackageReference Include="System.Xml.XmlSerializer" Version="4.0.11" />
+    <PackageReference Include="Text.Analyzers" Version="2.6.0" />
   </ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="Microsoft.AspNetCore.All" Version="2.0.3" />
-		<PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="2.0.1" PrivateAssets="All" />
-		<PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="2.0.1" PrivateAssets="All" />
+		<PackageReference Include="Microsoft.AspNetCore.All" Version="2.0.6" />
+		<PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="2.0.2" PrivateAssets="All" />
+		<PackageReference Include="YamlDotNet" Version="4.3.1" />
 	</ItemGroup>
 
 	<ItemGroup>
@@ -46,13 +66,8 @@
 	</ItemGroup>
 
 	<ItemGroup>
-	  <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" />
@@ -98,5 +113,12 @@
 
 	<ItemGroup>
 	  <Folder Include="Build\" />
+	  <Folder Include="wwwroot\vendor\clipboard.js\" />
+	</ItemGroup>
+
+	<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/CompositeDisposable.cs

@@ -1,19 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-
-namespace BTCPayServer
-{
-    public class CompositeDisposable : IDisposable
-    {
-        List<IDisposable> _Disposables = new List<IDisposable>();
-        public void Add(IDisposable disposable) { _Disposables.Add(disposable); }
-        public void Dispose()
-        {
-            foreach (var d in _Disposables)
-                d.Dispose();
-            _Disposables.Clear();
-        }
-    }
-}

BTCPayServer/Configuration/BTCPayServerOptions.cs

@@ -9,21 +9,21 @@ using System.Net;
 using System.Text;
 using StandardConfiguration;
 using Microsoft.Extensions.Configuration;
+using NBXplorer;
+using BTCPayServer.Payments.Lightning;
 
 namespace BTCPayServer.Configuration
 {
+    public class NBXplorerConnectionSetting
+    {
+        public string CryptoCode { get; internal set; }
+        public Uri ExplorerUri { get; internal set; }
+        public string CookieFile { get; internal set; }
+    }
+
     public class BTCPayServerOptions
     {
-        public Network Network
-        {
-            get; set;
-        }
-        public Uri Explorer
-        {
-            get; set;
-        }
-
-        public string CookieFile
+        public NetworkType NetworkType
         {
             get; set;
         }
@@ -43,22 +43,67 @@ namespace BTCPayServer.Configuration
             set;
         }
 
+        public List<NBXplorerConnectionSetting> NBXplorerConnectionSettings
+        {
+            get;
+            set;
+        } = new List<NBXplorerConnectionSetting>();
+
         public void LoadArgs(IConfiguration conf)
         {
-            var networkInfo = DefaultConfiguration.GetNetwork(conf);
-            Network = networkInfo?.Network;
-            if (Network == null)
-                throw new ConfigException("Invalid network");
+            NetworkType = DefaultConfiguration.GetNetworkType(conf);
+            var defaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType);
+            DataDir = conf.GetOrDefault<string>("datadir", defaultSettings.DefaultDataDirectory);
+            Logs.Configuration.LogInformation("Network: " + NetworkType.ToString());
 
-            DataDir = conf.GetOrDefault<string>("datadir", networkInfo.DefaultDataDirectory);
-            Logs.Configuration.LogInformation("Network: " + Network);
+            var supportedChains = conf.GetOrDefault<string>("chains", "btc")
+                                      .Split(',', StringSplitOptions.RemoveEmptyEntries)
+                                      .Select(t => t.ToUpperInvariant());
+            NetworkProvider = new BTCPayNetworkProvider(NetworkType).Filter(supportedChains.ToArray());
+            foreach (var chain in supportedChains)
+            {
+                if (NetworkProvider.GetNetwork(chain) == null)
+                    throw new ConfigException($"Invalid chains \"{chain}\"");
+            }
+
+            var validChains = new List<string>();
+            foreach (var net in NetworkProvider.GetAll())
+            {
+                NBXplorerConnectionSetting setting = new NBXplorerConnectionSetting();
+                setting.CryptoCode = net.CryptoCode;
+                setting.ExplorerUri = conf.GetOrDefault<Uri>($"{net.CryptoCode}.explorer.url", net.NBXplorerNetwork.DefaultSettings.DefaultUrl);
+                setting.CookieFile = conf.GetOrDefault<string>($"{net.CryptoCode}.explorer.cookiefile", net.NBXplorerNetwork.DefaultSettings.DefaultCookieFile);
+                NBXplorerConnectionSettings.Add(setting);
+                var lightning = conf.GetOrDefault<string>($"{net.CryptoCode}.lightning", string.Empty);
+                if(lightning.Length != 0)
+                {
+                    if(!LightningConnectionString.TryParse(lightning, 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()));
 
-            Explorer = conf.GetOrDefault<Uri>("explorer.url", networkInfo.DefaultExplorerUrl);
-            CookieFile = conf.GetOrDefault<string>("explorer.cookiefile", networkInfo.DefaultExplorerCookieFile);
             PostgresConnectionString = conf.GetOrDefault<string>("postgres", null);
+            BundleJsCss = conf.GetOrDefault<bool>("bundlejscss", true);
             ExternalUrl = conf.GetOrDefault<Uri>("externalurl", null);
-            InternalUrl = conf.GetOrDefault<Uri>("internalurl", 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;
@@ -69,6 +114,19 @@ namespace BTCPayServer.Configuration
             get;
             set;
         }
-        public Uri InternalUrl { get; private 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/ConfigurationExtensions.cs

@@ -13,7 +13,7 @@ namespace BTCPayServer.Configuration
     {
         public static T GetOrDefault<T>(this IConfiguration configuration, string key, T defaultValue)
         {
-            var str = configuration[key] ?? configuration[key.Replace(".", string.Empty)];
+            var str = configuration[key] ?? configuration[key.Replace(".", string.Empty, StringComparison.InvariantCulture)];
             if (str == null)
                 return defaultValue;
             if (typeof(T) == typeof(bool))
@@ -27,17 +27,24 @@ namespace BTCPayServer.Configuration
                 throw new FormatException();
             }
             else if (typeof(T) == typeof(Uri))
-                return (T)(object)new Uri(str, UriKind.Absolute);
+                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(":");
+                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));
+                return (T)(object)new IPEndPoint(IPAddress.Parse(ip), int.Parse(port, CultureInfo.InvariantCulture));
             }
             else if (typeof(T) == typeof(int))
             {

BTCPayServer/Configuration/DefaultConfiguration.cs

@@ -10,6 +10,7 @@ using System.Threading.Tasks;
 using NBitcoin;
 using System.Text;
 using CommandLine;
+using NBXplorer;
 
 namespace BTCPayServer.Configuration
 {
@@ -17,20 +18,29 @@ namespace BTCPayServer.Configuration
     {
         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 ({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("-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("--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);
             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("--internalurl", $"The expected internal url of this service, this set NBXplorer callback addresses (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;
         }
 
@@ -38,54 +48,68 @@ namespace BTCPayServer.Configuration
 
         protected override string GetDefaultDataDir(IConfiguration conf)
         {
-            return GetNetwork(conf).DefaultDataDirectory;
+            return BTCPayDefaultSettings.GetDefaultSettings(GetNetworkType(conf)).DefaultDataDirectory;
         }
 
         protected override string GetDefaultConfigurationFile(IConfiguration conf)
         {
-            var network = GetNetwork(conf);
+            var network = BTCPayDefaultSettings.GetDefaultSettings(GetNetworkType(conf));
             var dataDir = conf["datadir"];
             if (dataDir == null)
                 return network.DefaultConfigurationFile;
             var fileName = Path.GetFileName(network.DefaultConfigurationFile);
-            return Path.Combine(dataDir, fileName);
+            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);
         }
 
-        public static NetworkInformation GetNetwork(IConfiguration conf)
+        public static NetworkType GetNetworkType(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;
+                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;
 
-            var net = conf.GetOrDefault<bool>("regtest", false) ? Network.RegTest :
-                        conf.GetOrDefault<bool>("testnet", false) ? Network.TestNet : Network.Main;
-
-            return NetworkInformation.GetNetworkByName(net.Name);
+            return net;
         }
 
         protected override string GetDefaultConfigurationFileTemplate(IConfiguration conf)
         {
-            var network = GetNetwork(conf);
+            var networkType = GetNetworkType(conf);
+            var defaultSettings = BTCPayDefaultSettings.GetDefaultSettings(networkType);
             StringBuilder builder = new StringBuilder();
             builder.AppendLine("### Global settings ###");
-            builder.AppendLine("#testnet=0");
-            builder.AppendLine("#regtest=0");
+            builder.AppendLine("#network=mainnet");
             builder.AppendLine();
             builder.AppendLine("### Server settings ###");
-            builder.AppendLine("#port=" + network.DefaultPort);
+            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 ###");
-            builder.AppendLine("#explorer.url=" + network.DefaultExplorerUrl.AbsoluteUri);
-            builder.AppendLine("#explorer.cookiefile=" + network.DefaultExplorerCookieFile);
+            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();
         }
 
@@ -93,7 +117,7 @@ namespace BTCPayServer.Configuration
 
         protected override IPEndPoint GetDefaultEndpoint(IConfiguration conf)
         {
-            return new IPEndPoint(IPAddress.Parse("127.0.0.1"), GetNetwork(conf).DefaultPort);
+            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,6 +12,7 @@ using System.Threading.Tasks;
 
 namespace BTCPayServer.Controllers
 {
+    [BitpayAPIConstraint]
     public class AccessTokenController : Controller
     {
         TokenRepository _TokenRepository;
@@ -23,7 +24,7 @@ namespace BTCPayServer.Controllers
         [Route("tokens")]
         public async Task<GetTokensResponse> Tokens()
         {
-            var tokens = await _TokenRepository.GetTokens(this.GetBitIdentity().SIN);
+            var tokens = await _TokenRepository.GetTokens(this.User.GetSIN());
             return new GetTokensResponse(tokens);
         }
 
@@ -51,7 +52,7 @@ namespace BTCPayServer.Controllers
             }
             else
             {
-                var sin = this.GetBitIdentity(false)?.SIN ?? request.Id;
+                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");
 

BTCPayServer/Controllers/AccountController.cs

@@ -15,20 +15,22 @@ 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]
+    [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;
-        private readonly ILogger _logger;
         StoreRepository storeRepository;
         RoleManager<IdentityRole> _RoleManager;
         SettingsRepository _SettingsRepository;
+        ILogger _logger;
 
         public AccountController(
             UserManager<ApplicationUser> userManager,
@@ -36,16 +38,15 @@ namespace BTCPayServer.Controllers
             StoreRepository storeRepository,
             SignInManager<ApplicationUser> signInManager,
             IEmailSender emailSender,
-            SettingsRepository settingsRepository,
-            ILogger<AccountController> logger)
+            SettingsRepository settingsRepository)
         {
             this.storeRepository = storeRepository;
             _userManager = userManager;
             _signInManager = signInManager;
             _emailSender = emailSender;
-            _logger = logger;
             _RoleManager = roleManager;
             _SettingsRepository = settingsRepository;
+            _logger = Logs.PayServer;
         }
 
         [TempData]
@@ -150,7 +151,7 @@ namespace BTCPayServer.Controllers
                 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);
 
@@ -204,7 +205,7 @@ namespace BTCPayServer.Controllers
                 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);
 
@@ -259,12 +260,10 @@ namespace BTCPayServer.Controllers
                 var result = await _userManager.CreateAsync(user, model.Password);
                 if (result.Succeeded)
                 {
-                    _logger.LogInformation("User created a new account with password.");
-
                     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)
                     {
-                        _logger.LogInformation("Admin created.");
                         await _RoleManager.CreateAsync(new IdentityRole(Roles.ServerAdmin));
                         await _userManager.AddToRoleAsync(user, Roles.ServerAdmin);
                     }
@@ -273,7 +272,6 @@ namespace BTCPayServer.Controllers
                     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);
@@ -292,7 +290,7 @@ namespace BTCPayServer.Controllers
             return View(model);
         }
 
-        /// <summary>
+        /// <summary> 
         /// Test property
         /// </summary>
         public string RegisteredUserId

BTCPayServer/Controllers/AppsController.PointOfSale.cs

@@ -0,0 +1,225 @@
+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;
+
+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>();
+            return View(new UpdatePointOfSaleViewModel() { Title = settings.Title, ShowCustomAmount = settings.ShowCustomAmount, Currency = settings.Currency, Template = settings.Template });
+        }
+        [HttpPost]
+        [Route("{appId}/settings/pos")]
+        public async Task<IActionResult> UpdatePointOfSale(string appId, UpdatePointOfSaleViewModel vm)
+        {
+            if (_Currencies.GetCurrencyData(vm.Currency) == 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);
+            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")]
+        public async Task<IActionResult> ViewPointOfSale(string appId, double amount, 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;
+            double price = 0.0;
+            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 = (double)choice.Price.Value;
+            }
+            else
+            {
+                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,
+            }, 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,205 @@
+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)
+                   .Select(us => new
+                   {
+                       IsOwner = us.Role == StoreRoles.Owner,
+                       StoreId = us.StoreDataId,
+                       StoreName = us.StoreData.StoreName,
+                       Apps = us.StoreData.Apps
+                   })
+                   .SelectMany(us => us.Apps.Select(app => new ListAppsViewModel.ListAppViewModel()
+                   {
+                       IsOwner = us.IsOwner,
+                       AppName = app.Name,
+                       AppType = app.AppType,
+                       Id = app.Id,
+                       StoreId = us.StoreId,
+                       StoreName = us.StoreName
+                   }))
+                   .ToArrayAsync();
+            }
+        }
+
+        private string GetUserId()
+        {
+            return _UserManager.GetUserId(User);
+        }
+    }
+}

BTCPayServer/Controllers/CallbackController.cs

@@ -1,143 +0,0 @@
-using BTCPayServer.Logging;
-using BTCPayServer.Services.Invoices;
-using BTCPayServer.Services;
-using BTCPayServer.Services.Wallets;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Mvc;
-using NBitcoin;
-using NBXplorer;
-using Microsoft.Extensions.Logging;
-using NBXplorer.DerivationStrategy;
-using NBXplorer.Models;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using BTCPayServer.Configuration;
-using BTCPayServer.Events;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.AspNetCore.Hosting.Server.Features;
-using Microsoft.AspNetCore.Hosting.Server;
-
-namespace BTCPayServer.Controllers
-{
-    public class CallbackController : Controller
-    {
-        public class CallbackSettings
-        {
-            public string Token
-            {
-                get; set;
-            }
-        }
-        SettingsRepository _Settings;
-        Network _Network;
-        ExplorerClient _Explorer;
-        BTCPayServerOptions _Options;
-        EventAggregator _EventAggregator;
-        IServer _Server;
-        public CallbackController(SettingsRepository repo,
-                                  ExplorerClient explorer,
-                                  EventAggregator eventAggregator,
-                                  BTCPayServerOptions options,
-                                  IServer server,
-                                  Network network)
-        {
-            _Settings = repo;
-            _Network = network;
-            _Explorer = explorer;
-            _Options = options;
-            _EventAggregator = eventAggregator;
-            _Server = server;
-        }
-
-        [Route("callbacks/transactions")]
-        [HttpPost]
-        public async Task NewTransaction(string token)
-        {
-            await AssertToken(token);
-            //We don't want to register all the json converter at MVC level, so we parse here
-            var serializer = new NBXplorer.Serializer(_Network);
-            var content = await new StreamReader(Request.Body, new UTF8Encoding(false), false, 1024, true).ReadToEndAsync();
-            var match = serializer.ToObject<TransactionMatch>(content);
-
-            foreach (var output in match.Outputs)
-            {
-                var evt = new TxOutReceivedEvent();
-                evt.ScriptPubKey = output.ScriptPubKey;
-                evt.Address = output.ScriptPubKey.GetDestinationAddress(_Network);
-                _EventAggregator.Publish(evt);
-            }
-        }
-
-        [Route("callbacks/blocks")]
-        [HttpPost]
-        public async Task NewBlock(string token)
-        {
-            await AssertToken(token);
-            _EventAggregator.Publish(new NewBlockEvent());
-        }
-
-        private async Task AssertToken(string token)
-        {
-            var callback = await _Settings.GetSettingAsync<CallbackSettings>();
-            if (await GetToken() != token)
-                throw new BTCPayServer.BitpayHttpException(400, "invalid-callback-token");
-        }
-
-        public async Task<Uri> GetCallbackUriAsync()
-        {
-            string token = await GetToken();
-            return BuildCallbackUri("callbacks/transactions?token=" + token);
-        }
-
-        public async Task RegisterCallbackUriAsync(DerivationStrategyBase derivationScheme)
-        {
-            var uri = await GetCallbackUriAsync();
-            await _Explorer.SubscribeToWalletAsync(uri, derivationScheme);
-        }
-
-        private async Task<string> GetToken()
-        {
-            var callback = await _Settings.GetSettingAsync<CallbackSettings>();
-            if (callback == null)
-            {
-                callback = new CallbackSettings() { Token = Guid.NewGuid().ToString() };
-                await _Settings.UpdateSetting(callback);
-            }
-            var token = callback.Token;
-            return token;
-        }
-
-        public async Task<Uri> GetCallbackBlockUriAsync()
-        {
-            string token = await GetToken();
-            return BuildCallbackUri("callbacks/blocks?token=" + token);
-        }
-
-        private Uri BuildCallbackUri(string callbackPath)
-        {
-            var address = _Server.Features.Get<IServerAddressesFeature>().Addresses
-                                 .Select(c => new Uri(TransformToRoutable(c)))
-                                 .First();
-            var baseUrl = _Options.InternalUrl == null ? address.AbsoluteUri : _Options.InternalUrl.AbsoluteUri;
-            baseUrl = baseUrl.WithTrailingSlash();
-            return new Uri(baseUrl + callbackPath);
-        }
-
-        private string TransformToRoutable(string host)
-        {
-            if (host.StartsWith("http://0.0.0.0"))
-                host = host.Replace("http://0.0.0.0", "http://127.0.0.1");
-            return host;
-        }
-
-        public async Task<Uri> RegisterCallbackBlockUriAsync(Uri uri)
-        {
-            await _Explorer.SubscribeToBlocksAsync(uri);
-            return uri;
-        }
-    }
-}

BTCPayServer/Controllers/InvoiceController.API.cs

@@ -22,18 +22,15 @@ namespace BTCPayServer.Controllers
     {
         private InvoiceController _InvoiceController;
         private InvoiceRepository _InvoiceRepository;
-        private TokenRepository _TokenRepository;
-        private StoreRepository _StoreRepository;
+        private BTCPayNetworkProvider _NetworkProvider;
 
         public InvoiceControllerAPI(InvoiceController invoiceController,
                                     InvoiceRepository invoceRepository,
-                                    TokenRepository tokenRepository,
-                                    StoreRepository storeRepository)
+                                    BTCPayNetworkProvider networkProvider)
         {
             this._InvoiceController = invoiceController;
             this._InvoiceRepository = invoceRepository;
-            this._TokenRepository = tokenRepository;
-            this._StoreRepository = storeRepository;
+            this._NetworkProvider = networkProvider;
         }
 
         [HttpPost]
@@ -41,22 +38,17 @@ namespace BTCPayServer.Controllers
         [MediaTypeConstraint("application/json")]
         public async Task<DataWrapper<InvoiceResponse>> CreateInvoice([FromBody] Invoice invoice)
         {
-            var bitToken = await CheckTokenPermissionAsync(Facade.Merchant, invoice.Token);
-            var store = await FindStore(bitToken);
-            return await _InvoiceController.CreateInvoiceCore(invoice, store, HttpContext.Request.GetAbsoluteRoot());
+            return await _InvoiceController.CreateInvoiceCore(invoice, HttpContext.GetStoreData(), HttpContext.Request.GetAbsoluteRoot());
         }
 
         [HttpGet]
         [Route("invoices/{id}")]
         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);
+            var invoice = await _InvoiceRepository.GetInvoice(HttpContext.GetStoreData().Id, id);
             if (invoice == null)
                 throw new BitpayHttpException(404, "Object not found");
-
-            var resp = invoice.EntityToDTO();
+            var resp = invoice.EntityToDTO(_NetworkProvider);
             return new DataWrapper<InvoiceResponse>(resp);
         }
 
@@ -74,8 +66,7 @@ namespace BTCPayServer.Controllers
         {
             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,
@@ -84,55 +75,14 @@ namespace BTCPayServer.Controllers
                 StartDate = dateStart,
                 OrderId = orderId,
                 ItemCode = itemCode,
-                Status = status,
-                StoreId = store.Id
+                Status = status == null ? null : new[] { status },
+                StoreId = new[] { this.HttpContext.GetStoreData().Id }
             };
 
-
             var entities = (await _InvoiceRepository.GetInvoices(query))
-                            .Select((o) => o.EntityToDTO()).ToArray();
+                            .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;
-        }
-
     }
 }

BTCPayServer/Controllers/InvoiceController.PaymentProtocol.cs

@@ -9,29 +9,36 @@ 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}")]
+        [Route("i/{invoiceId}/{cryptoCode?}")]
         [AcceptMediaTypeConstraint("application/bitcoin-paymentrequest")]
-        public async Task<IActionResult> GetInvoiceRequest(string invoiceId)
+        public async Task<IActionResult> GetInvoiceRequest(string invoiceId, string cryptoCode = null)
         {
+            if (cryptoCode == null)
+                cryptoCode = "BTC";
             var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId);
-            if (invoice == null || invoice.IsExpired())
+            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();
+            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;
-            request.Details.Outputs.Add(new PaymentOutput() { Amount = dto.BTCDue, Script = BitcoinAddress.Create(dto.BitcoinAddress, _Network).ScriptPubKey });
+            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);
@@ -57,15 +64,23 @@ namespace BTCPayServer.Controllers
 
         [HttpPost]
         [Route("i/{invoiceId}", Order = 99)]
+        [Route("i/{invoiceId}/{cryptoCode}", Order = 99)]
         [MediaTypeConstraint("application/bitcoin-payment")]
-        public async Task<IActionResult> PostPayment(string invoiceId)
+        public async Task<IActionResult> PostPayment(string invoiceId, string cryptoCode = null)
         {
             var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId);
-            if (invoice == null || invoice.IsExpired())
+            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());
+            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

@@ -19,26 +19,15 @@ 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
     {
-        [HttpPost]
-        [Route("invoices/{invoiceId}")]
-        public IActionResult Invoice(string invoiceId, string command)
-        {
-            if (command == "refresh")
-            {
-                _Watcher.Watch(invoiceId);
-            }
-            StatusMessage = "Invoice is state is being refreshed, please refresh the page soon...";
-            return RedirectToAction(nameof(Invoice), new
-            {
-                invoiceId = invoiceId
-            });
-        }
-
         [HttpGet]
         [Route("invoices/{invoiceId}")]
         public async Task<IActionResult> Invoice(string invoiceId)
@@ -46,126 +35,265 @@ namespace BTCPayServer.Controllers
             var invoice = (await _InvoiceRepository.GetInvoices(new InvoiceQuery()
             {
                 UserId = GetUserId(),
-                InvoiceId = invoiceId
+                InvoiceId = invoiceId,
+                IncludeAddresses = true,
+                IncludeEvents = true
             })).FirstOrDefault();
             if (invoice == null)
                 return NotFound();
 
-            var dto = invoice.EntityToDTO();
+            var dto = invoice.EntityToDTO(_NetworkProvider);
             var store = await _StoreRepository.FindStore(invoice.StoreId);
+
             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" : "low",
                 RefundEmail = invoice.RefundMail,
                 CreatedDate = invoice.InvoiceTime,
                 ExpirationDate = invoice.ExpirationTime,
+                MonitoringDate = invoice.MonitoringExpiration,
                 OrderId = invoice.OrderId,
                 BuyerInformation = invoice.BuyerInformation,
-                Rate = invoice.Rate,
-                Fiat = dto.Price + " " + dto.Currency,
-                BTC = invoice.GetTotalCryptoDue().ToString() + " BTC",
-                BTCDue = invoice.GetCryptoDue().ToString() + " BTC",
-                BTCPaid = invoice.GetTotalPaid().ToString() + " BTC",
-                NetworkFee = invoice.GetNetworkFee().ToString() + " BTC",
+                Fiat = FormatCurrency((decimal)dto.Price, dto.Currency),
                 NotificationUrl = invoice.NotificationURL,
+                RedirectUrl = invoice.RedirectURL,
                 ProductInformation = invoice.ProductInformation,
-                BitcoinAddress = invoice.DepositAddress,
-                PaymentUrl = dto.PaymentUrls.BIP72
+                StatusException = invoice.ExceptionStatus,
+                Events = invoice.Events
             };
 
-            var payments = invoice
-                .Payments
-                .Select(async payment =>
+            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}";
+
+                var onchainMethod = data.GetPaymentMethodDetails() as Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod;
+                if (onchainMethod != null)
                 {
-                    var m = new InvoiceDetailsModel.Payment();
-                    m.DepositAddress = payment.Output.ScriptPubKey.GetDestinationAddress(_Network);
-                    m.Confirmations = (await _Explorer.GetTransactionAsync(payment.Outpoint.Hash))?.Confirmations ?? 0;
-                    m.TransactionId = payment.Outpoint.Hash.ToString();
-                    m.ReceivedTime = payment.ReceivedTime;
-                    m.TransactionLink = _Network == Network.Main ? $"https://www.smartbit.com.au/tx/{m.TransactionId}" : $"https://testnet.smartbit.com.au/tx/{m.TransactionId}";
-                    return m;
+                    cryptoPayment.Address = onchainMethod.DepositAddress;
+                }
+                cryptoPayment.Rate = FormatCurrency(data);
+                cryptoPayment.PaymentUrl = cryptoInfo.PaymentUrls.BIP21;
+                model.CryptoPayments.Add(cryptoPayment);
+            }
+
+            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);
+
+                        int confirmationCount = 0;
+                        if ((onChainPaymentData.ConfirmationCount < paymentNetwork.MaxTrackedConfirmation && payment.Accounted)
+                             && (onChainPaymentData.Legacy || invoice.MonitoringExpiration < DateTimeOffset.UtcNow)) // The confirmation count in the paymentData is not up to date
+                        {
+                            confirmationCount = (await ((ExplorerClientProvider)_ServiceProvider.GetService(typeof(ExplorerClientProvider))).GetExplorerClient(payment.GetCryptoCode())?.GetTransactionAsync(onChainPaymentData.Outpoint.Hash))?.Confirmations ?? 0;
+                            onChainPaymentData.ConfirmationCount = confirmationCount;
+                            payment.SetCryptoPaymentData(onChainPaymentData);
+                            await _InvoiceRepository.UpdatePayments(new List<PaymentEntity> { payment });
+                        }
+                        else
+                        {
+                            confirmationCount = onChainPaymentData.ConfirmationCount;
+                        }
+                        if (confirmationCount >= paymentNetwork.MaxTrackedConfirmation)
+                        {
+                            m.Confirmations = "At least " + (paymentNetwork.MaxTrackedConfirmation);
+                        }
+                        else
+                        {
+                            m.Confirmations = confirmationCount.ToString(CultureInfo.InvariantCulture);
+                        }
+
+                        m.TransactionId = onChainPaymentData.Outpoint.Hash.ToString();
+                        m.ReceivedTime = payment.ReceivedTime;
+                        m.TransactionLink = string.Format(CultureInfo.InvariantCulture, paymentNetwork.BlockExplorerLink, m.TransactionId);
+                        m.Replaced = !payment.Accounted;
+                        return m;
+                    }
+                    else
+                    {
+                        var lightningPaymentData = (Payments.Lightning.LightningLikePaymentData)paymentData;
+                        return new InvoiceDetailsModel.OffChainPayment()
+                        {
+                            Crypto = paymentNetwork.CryptoCode,
+                            BOLT11 = lightningPaymentData.BOLT11
+                        };
+                    }
                 })
                 .ToArray();
-            await Task.WhenAll(payments);
-            model.Payments = payments.Select(p => p.GetAwaiter().GetResult()).ToList();
+            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);
         }
 
+        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})";
+        }
+
         [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)
+        public async Task<IActionResult> Checkout(string invoiceId, string id = null, string paymentMethodId = null)
         {
             //Keep compatibility with Bitpay
             invoiceId = invoiceId ?? id;
             id = invoiceId;
             ////
 
-            var model = await GetInvoiceModel(invoiceId);
+            var model = await GetInvoiceModel(invoiceId, paymentMethodId);
             if (model == null)
                 return NotFound();
 
             return View(nameof(Checkout), model);
         }
 
-        private async Task<PaymentModel> GetInvoiceModel(string invoiceId)
+        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);
-            var dto = invoice.EntityToDTO();
+            bool isDefaultCrypto = false;
+            if (paymentMethodIdStr == null)
+            {
+                paymentMethodIdStr = store.GetDefaultCrypto();
+                isDefaultCrypto = true;
+            }
+
+            var paymentMethodId = PaymentMethodId.Parse(paymentMethodIdStr);
+            var network = _NetworkProvider.GetNetwork(paymentMethodId.CryptoCode);
+            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();
+            }
+
+            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,
-                BtcAddress = invoice.DepositAddress.ToString(),
-                BtcAmount = (invoice.GetTotalCryptoDue() - invoice.TxFee).ToString(),
-                BtcTotalDue = invoice.GetTotalCryptoDue().ToString(),
-                BtcDue = invoice.GetCryptoDue().ToString(),
+                DefaultLang = storeBlob.DefaultLang ?? "en-US",
+                HtmlTitle = storeBlob.HtmlTitle ?? "BTCPay Invoice",
+                CustomCSSLink = storeBlob.CustomCSS?.AbsoluteUri,
+                CustomLogoLink = storeBlob.CustomLogo?.AbsoluteUri,
+                BtcAddress = paymentMethodDetails.GetPaymentDestination(),
+                OrderAmount = (accounting.TotalDue - accounting.NetworkFee).ToString(),
+                BtcDue = accounting.Due.ToString(),
                 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 = invoice.Rate.ToString("C", _CurrencyNameTable.GetCurrencyProvider(currency)) + $" ({currency})",
+                Rate = FormatCurrency(paymentMethod),
                 MerchantRefLink = invoice.RedirectURL ?? "/",
                 StoreName = store.StoreName,
-                TxFees = invoice.TxFee.ToString(),
-                InvoiceBitcoinUrl = dto.PaymentUrls.BIP72,
-                TxCount = invoice.GetTxCount(),
-                BtcPaid = invoice.GetTotalPaid().ToString(),
-                Status = invoice.Status
+                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 = PrettyPrint(expiration);
+            model.TimeLeft = expiration.PrettyPrint();
             return model;
         }
 
-        private string PrettyPrint(TimeSpan expiration)
+        private string GetImage(PaymentMethodId paymentMethodId, BTCPayNetwork network)
         {
-            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();
+            return (paymentMethodId.PaymentType == PaymentTypes.BTCLike ? Url.Content(network.CryptoImagePath) : Url.Content(network.LightningImagePath));
+        }
+
+        private string FormatCurrency(PaymentMethod paymentMethod)
+        {
+            string currency = paymentMethod.ParentEntity.ProductInformation.Currency;
+            return FormatCurrency(paymentMethod.Rate, currency);
+        }
+        public string FormatCurrency(decimal price, string currency)
+        {
+            return price.ToString("C", _CurrencyNameTable.GetCurrencyProvider(currency)) + $" ({currency})";
         }
 
         [HttpGet]
         [Route("i/{invoiceId}/status")]
-        public async Task<IActionResult> GetStatus(string invoiceId)
+        [Route("i/{invoiceId}/{paymentMethodId}/status")]
+        public async Task<IActionResult> GetStatus(string invoiceId, string paymentMethodId = null)
         {
-            var model = await GetInvoiceModel(invoiceId);
+            var model = await GetInvoiceModel(invoiceId, paymentMethodId);
             if (model == null)
                 return NotFound();
             return Json(model);
@@ -184,9 +312,9 @@ namespace BTCPayServer.Controllers
             CompositeDisposable leases = new CompositeDisposable();
             try
             {
-                _EventAggregator.Subscribe<Events.InvoiceDataChangedEvent>(async o => await NotifySocket(webSocket, o.InvoiceId, invoiceId));
-                _EventAggregator.Subscribe<Events.InvoicePaymentEvent>(async o => await NotifySocket(webSocket, o.InvoiceId, invoiceId));
-                _EventAggregator.Subscribe<Events.InvoiceStatusChangedEvent>(async o => await NotifySocket(webSocket, o.InvoiceId, invoiceId));
+                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));
@@ -197,17 +325,9 @@ namespace BTCPayServer.Controllers
             finally
             {
                 leases.Dispose();
-                await CloseSocket(webSocket);
-            }
-            return new NoResponse();
-        }
-
-        class NoResponse : IActionResult
-        {
-            public Task ExecuteResultAsync(ActionContext context)
-            {
-                return Task.CompletedTask;
+                await webSocket.CloseSocket();
             }
+            return new EmptyResult();
         }
 
         ArraySegment<Byte> DummyBuffer = new ArraySegment<Byte>(new Byte[1]);
@@ -221,21 +341,7 @@ namespace BTCPayServer.Controllers
             {
                 await webSocket.SendAsync(DummyBuffer, WebSocketMessageType.Binary, true, cts.Token);
             }
-            catch { await CloseSocket(webSocket); }
-        }
-
-        private static async Task CloseSocket(WebSocket webSocket)
-        {
-            try
-            {
-                if (webSocket.State == WebSocketState.Open)
-                {
-                    CancellationTokenSource cts = new CancellationTokenSource();
-                    cts.CancelAfter(5000);
-                    await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", cts.Token);
-                }
-            }
-            finally { webSocket.Dispose(); }
+            catch { try { webSocket.Dispose(); } catch { } }
         }
 
         [HttpPost]
@@ -252,9 +358,9 @@ namespace BTCPayServer.Controllers
 
         [HttpGet]
         [Route("invoices")]
-        [Authorize(AuthenticationSchemes = "Identity.Application")]
+        [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
         [BitpayAPIConstraint(false)]
-        public async Task<IActionResult> ListInvoices(string searchTerm = null, int skip = 0, int count = 20)
+        public async Task<IActionResult> ListInvoices(string searchTerm = null, int skip = 0, int count = 50)
         {
             var model = new InvoicesModel();
             var filterString = new SearchString(searchTerm);
@@ -264,16 +370,20 @@ namespace BTCPayServer.Controllers
                 Count = count,
                 Skip = skip,
                 UserId = GetUserId(),
-                Status = filterString.Filters.TryGet("status"),
-                StoreId = filterString.Filters.TryGet("storeid")
+                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,
-                    Date = invoice.InvoiceTime,
+                    Status = invoice.Status + (invoice.ExceptionStatus == null ? string.Empty : $" ({invoice.ExceptionStatus})"),
+                    ShowCheckout = invoice.Status == "new",
+                    Date = (DateTimeOffset.UtcNow - invoice.InvoiceTime).Prettify() + " ago",
                     InvoiceId = invoice.Id,
+                    OrderId = invoice.OrderId ?? string.Empty,
+                    RedirectUrl = invoice.RedirectURL ?? string.Empty,
                     AmountCurrency = $"{invoice.ProductInformation.Price.ToString(CultureInfo.InvariantCulture)} {invoice.ProductInformation.Currency}"
                 });
             }
@@ -285,34 +395,51 @@ namespace BTCPayServer.Controllers
 
         [HttpGet]
         [Route("invoices/create")]
-        [Authorize(AuthenticationSchemes = "Identity.Application")]
+        [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
         [BitpayAPIConstraint(false)]
         public async Task<IActionResult> CreateInvoice()
         {
-            var stores = await GetStores(GetUserId());
+            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(StoresController.ListStores), "Stores");
+                return RedirectToAction(nameof(UserStoresController.ListStores), "UserStores");
             }
             return View(new CreateInvoiceModel() { Stores = stores });
         }
 
         [HttpPost]
         [Route("invoices/create")]
-        [Authorize(AuthenticationSchemes = "Identity.Application")]
+        [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
         [BitpayAPIConstraint(false)]
         public async Task<IActionResult> CreateInvoice(CreateInvoiceModel model)
         {
-            model.Stores = await GetStores(GetUserId(), model.StoreId);
+            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);
             }
-            var store = await _StoreRepository.FindStore(model.StoreId, GetUserId());
-            if (string.IsNullOrEmpty(store.DerivationStrategy))
+            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)
             {
-                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
@@ -337,20 +464,15 @@ namespace BTCPayServer.Controllers
                 StatusMessage = $"Invoice {result.Data.Id} just created!";
                 return RedirectToAction(nameof(ListInvoices));
             }
-            catch (RateUnavailableException)
+            catch (BitpayHttpException ex)
             {
-                ModelState.TryAddModelError(nameof(model.Currency), "Unsupported currency");
+                ModelState.TryAddModelError(nameof(model.Currency), $"Error: {ex.Message}");
                 return View(model);
             }
         }
 
-        private async Task<SelectList> GetStores(string userId, string storeId = null)
-        {
-            return new SelectList(await _StoreRepository.GetStoresByUserId(userId), nameof(StoreData.Id), nameof(StoreData.StoreName), storeId);
-        }
-
         [HttpPost]
-        [Authorize(AuthenticationSchemes = "Identity.Application")]
+        [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
         [BitpayAPIConstraint(false)]
         public IActionResult SearchInvoice(InvoicesModel invoices)
         {
@@ -364,11 +486,12 @@ namespace BTCPayServer.Controllers
 
         [HttpPost]
         [Route("invoices/invalidatepaid")]
-        [Authorize(AuthenticationSchemes = "Identity.Application")]
+        [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));
         }
 

BTCPayServer/Controllers/InvoiceController.cs

@@ -38,69 +38,67 @@ 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
     {
         InvoiceRepository _InvoiceRepository;
-        BTCPayWallet _Wallet;
-        IRateProvider _RateProvider;
-        private InvoiceWatcher _Watcher;
+        BTCPayRateProviderFactory _RateProvider;
         StoreRepository _StoreRepository;
-        Network _Network;
         UserManager<ApplicationUser> _UserManager;
-        IFeeProvider _FeeProvider;
         private CurrencyNameTable _CurrencyNameTable;
-        ExplorerClient _Explorer;
         EventAggregator _EventAggregator;
+        BTCPayNetworkProvider _NetworkProvider;
+        private readonly BTCPayWalletProvider _WalletProvider;
+        IServiceProvider _ServiceProvider;
         public InvoiceController(
-            Network network,
+            IServiceProvider serviceProvider,
             InvoiceRepository invoiceRepository,
             CurrencyNameTable currencyNameTable,
             UserManager<ApplicationUser> userManager,
-            BTCPayWallet wallet,
-            IRateProvider rateProvider,
+            BTCPayRateProviderFactory rateProvider,
             StoreRepository storeRepository,
             EventAggregator eventAggregator,
-            InvoiceWatcherAccessor watcher,
-            ExplorerClient explorerClient,
-            IFeeProvider feeProvider)
+            BTCPayWalletProvider walletProvider,
+            BTCPayNetworkProvider networkProvider)
         {
+            _ServiceProvider = serviceProvider;
             _CurrencyNameTable = currencyNameTable ?? throw new ArgumentNullException(nameof(currencyNameTable));
-            _Explorer = explorerClient ?? throw new ArgumentNullException(nameof(explorerClient));
             _StoreRepository = storeRepository ?? throw new ArgumentNullException(nameof(storeRepository));
-            _Network = network ?? throw new ArgumentNullException(nameof(network));
             _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))).Instance;
             _UserManager = userManager;
-            _FeeProvider = feeProvider ?? throw new ArgumentNullException(nameof(feeProvider));
             _EventAggregator = eventAggregator;
+            _NetworkProvider = networkProvider;
+            _WalletProvider = walletProvider;
         }
 
-        internal async Task<DataWrapper<InvoiceResponse>> CreateInvoiceCore(Invoice invoice, StoreData store, string serverUrl, double expiryMinutes = 15)
+
+        internal async Task<DataWrapper<InvoiceResponse>> CreateInvoiceCore(Invoice invoice, StoreData store, string serverUrl)
         {
-            //TODO: expiryMinutes (time before a new invoice can become paid) and monitoringMinutes (time before a paid invoice becomes invalid)  should be configurable at store level
-            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")
+                InvoiceTime = DateTimeOffset.UtcNow
             };
-            var storeBlob = store.GetStoreBlob(_Network);
+
+            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(expiryMinutes);
+            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;
+            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)
@@ -114,19 +112,165 @@ namespace BTCPayServer.Controllers
             entity.Status = "new";
             entity.SpeedPolicy = ParseSpeedPolicy(invoice.TransactionSpeed, store.SpeedPolicy);
 
-            var getFeeRate = _FeeProvider.GetFeeRateAsync();
-            var getRate = _RateProvider.GetRateAsync(invoice.Currency);
-            var getAddress = _Wallet.ReserveAddressAsync(ParseDerivationStrategy(derivationStrategy));
-            entity.TxFee = storeBlob.NetworkFeeDisabled ? Money.Zero : (await getFeeRate).GetFee(100); // assume price for 100 bytes
-            entity.Rate = (double)await getRate;
+
+            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.DepositAddress = await getAddress;
-            entity = await _InvoiceRepository.CreateInvoiceAsync(store.Id, entity);
-            _Watcher.Watch(entity.Id);
-            var resp = entity.EntityToDTO();
+            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)
@@ -155,11 +299,6 @@ namespace BTCPayServer.Controllers
             buyerInformation.BuyerZip = buyerInformation.BuyerZip ?? buyer.zip;
         }
 
-        private DerivationStrategyBase ParseDerivationStrategy(string derivationStrategy)
-        {
-            return new DerivationStrategyFactory(_Network).Parse(derivationStrategy);
-        }
-
         private TDest Map<TFrom, TDest>(TFrom data)
         {
             return JsonConvert.DeserializeObject<TDest>(JsonConvert.SerializeObject(data));

BTCPayServer/Controllers/ManageController.cs

@@ -20,10 +20,12 @@ using NBitcoin;
 using BTCPayServer.Services.Stores;
 using BTCPayServer.Services.Wallets;
 using BTCPayServer.Services.Mails;
+using System.Globalization;
+using BTCPayServer.Security;
 
 namespace BTCPayServer.Controllers
 {
-    [Authorize]
+    [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
     [Route("[controller]/[action]")]
     public class ManageController : Controller
     {
@@ -33,7 +35,6 @@ namespace BTCPayServer.Controllers
         private readonly ILogger _logger;
         private readonly UrlEncoder _urlEncoder;
         TokenRepository _TokenRepository;
-        private readonly BTCPayWallet _Wallet;
         IHostingEnvironment _Env;
         StoreRepository _StoreRepository;
 
@@ -47,7 +48,7 @@ namespace BTCPayServer.Controllers
           ILogger<ManageController> logger,
           UrlEncoder urlEncoder,
           TokenRepository tokenRepository,
-          BTCPayWallet wallet,
+          BTCPayWalletProvider walletProvider,
           StoreRepository storeRepository,
           IHostingEnvironment env)
         {
@@ -57,7 +58,6 @@ namespace BTCPayServer.Controllers
             _logger = logger;
             _urlEncoder = urlEncoder;
             _TokenRepository = tokenRepository;
-            _Wallet = wallet;
             _Env = env;
             _StoreRepository = storeRepository;
         }
@@ -369,7 +369,7 @@ namespace BTCPayServer.Controllers
 
             if (!user.TwoFactorEnabled)
             {
-                throw new ApplicationException($"Unexpected error occured disabling 2FA for user with ID '{user.Id}'.");
+                throw new ApplicationException($"Unexpected error occurred disabling 2FA for user with ID '{user.Id}'.");
             }
 
             return View(nameof(Disable2fa));
@@ -388,7 +388,7 @@ namespace BTCPayServer.Controllers
             var disable2faResult = await _userManager.SetTwoFactorEnabledAsync(user, false);
             if (!disable2faResult.Succeeded)
             {
-                throw new ApplicationException($"Unexpected error occured disabling 2FA for user with ID '{user.Id}'.");
+                throw new ApplicationException($"Unexpected error occurred disabling 2FA for user with ID '{user.Id}'.");
             }
 
             _logger.LogInformation("User with ID {UserId} has disabled 2fa.", user.Id);
@@ -436,7 +436,7 @@ namespace BTCPayServer.Controllers
             }
 
             // Strip spaces and hypens
-            var verificationCode = model.Code.Replace(" ", string.Empty).Replace("-", string.Empty);
+            var verificationCode = model.Code.Replace(" ", string.Empty, StringComparison.InvariantCulture).Replace("-", string.Empty, StringComparison.InvariantCulture);
 
             var is2faTokenValid = await _userManager.VerifyTwoFactorTokenAsync(
                 user, _userManager.Options.Tokens.AuthenticatorTokenProvider, verificationCode);
@@ -526,7 +526,7 @@ namespace BTCPayServer.Controllers
 
         private string GenerateQrCodeUri(string email, string unformattedKey)
         {
-            return string.Format(
+            return string.Format(CultureInfo.InvariantCulture,
                 AuthenicatorUriFormat,
                 _urlEncoder.Encode("BTCPayServer"),
                 _urlEncoder.Encode(email),

BTCPayServer/Controllers/RateController.cs

@@ -7,34 +7,117 @@ 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;
+        BTCPayRateProviderFactory _RateProviderFactory;
+        BTCPayNetworkProvider _NetworkProvider;
         CurrencyNameTable _CurrencyNameTable;
-        public RateController(IRateProvider rateProvider, CurrencyNameTable currencyNameTable)
+        StoreRepository _StoreRepo;
+        public RateController(
+            BTCPayRateProviderFactory rateProviderFactory,
+            BTCPayNetworkProvider networkProvider,
+            StoreRepository storeRepo,
+            CurrencyNameTable currencyNameTable)
         {
-            _RateProvider = rateProvider ?? throw new ArgumentNullException(nameof(rateProvider));
+            _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()
+        public async Task<IActionResult> GetRates(string currencyPairs, string storeId)
         {
-            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());
+            var result = await GetRates2(currencyPairs, storeId);
+            var rates = (result as JsonResult)?.Value as NBitpayClient.Rate[];
+            if (rates == null)
+                return result;
+            return Json(new DataWrapper<NBitpayClient.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 = 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,
+                                Name = _CurrencyNameTable.GetCurrencyData(r.Pair.Right)?.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 = "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,21 +13,96 @@ 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)]
+    [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)
+        public ServerController(UserManager<ApplicationUser> userManager,
+            BTCPayRateProviderFactory rateProviderFactory,
+            SettingsRepository settingsRepository)
         {
             _UserManager = userManager;
             _SettingsRepository = settingsRepository;
+            _RateProviderFactory = rateProviderFactory;
+        }
+
+        [Route("server/rates")]
+        public async Task<IActionResult> Rates()
+        {
+            var rates = (await _SettingsRepository.GetSettingAsync<RatesSetting>()) ?? new RatesSetting();
+
+            var vm = new RatesViewModel()
+            {
+                CacheMinutes = rates.CacheInMinutes,
+                PrivateKey = rates.PrivateKey,
+                PublicKey = rates.PublicKey
+            };
+            await FetchRateLimits(vm);
+            return View(vm);
+        }
+
+        private static async Task FetchRateLimits(RatesViewModel vm)
+        {
+            var coinAverage = GetCoinaverageService(vm, false);
+            if (coinAverage != null)
+            {
+                try
+                {
+                    vm.RateLimits = await coinAverage.GetRateLimitsAsync();
+                }
+                catch { }
+            }
+        }
+
+        [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")]
@@ -43,6 +120,51 @@ namespace BTCPayServer.Controllers
             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)
@@ -94,7 +216,22 @@ namespace BTCPayServer.Controllers
         public async Task<IActionResult> Policies(PoliciesSettings settings)
         {
             await _SettingsRepository.UpdateSetting(settings);
-            TempData["StatusMessage"] = "Policies upadated successfully";
+            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);
         }
 
@@ -104,10 +241,13 @@ namespace BTCPayServer.Controllers
         {
             if (command == "Test")
             {
-                if (!ModelState.IsValid)
-                    return View(model);
                 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";
@@ -118,11 +258,8 @@ namespace BTCPayServer.Controllers
                 }
                 return View(model);
             }
-            else
+            else // if(command == "Save")
             {
-                ModelState.Remove(nameof(model.TestEmail));
-                if (!ModelState.IsValid)
-                    return View(model);
                 await _SettingsRepository.UpdateSetting(model.Settings);
                 model.StatusMessage = "Email settings saved";
                 return View(model);

BTCPayServer/Controllers/StoresController.BTCLike.cs

@@ -0,0 +1,358 @@
+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 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.SupportDerivation(network, strategy))
+                    {
+                        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 transaction = await hw.SendToAddress(strategy, unspentCoins, network,
+                                            new[] { (destinationAddress as IDestination, amountBTC, subsctractFeesValue) },
+                                            feeRateValue,
+                                            changeAddress.Item1,
+                                            changeAddress.Item2, summary.Status.BitcoinStatus.MinRelayTxFee);
+                    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;
+            if (!directStrategy.Segwit)
+                return null;
+            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/StoresController.cs

@@ -1,58 +1,94 @@
 using BTCPayServer.Authentication;
+using BTCPayServer.Configuration;
 using BTCPayServer.Data;
+using BTCPayServer.HostedServices;
 using BTCPayServer.Models;
 using BTCPayServer.Models.StoreViewModels;
+using BTCPayServer.Rating;
+using BTCPayServer.Security;
+using BTCPayServer.Services;
+using BTCPayServer.Services.Rates;
 using BTCPayServer.Services.Stores;
 using BTCPayServer.Services.Wallets;
-using Microsoft.AspNetCore.Authentication.Cookies;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Identity;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Rendering;
+using Microsoft.Extensions.Options;
 using NBitcoin;
 using NBitcoin.DataEncoders;
-using NBitpayClient;
 using NBXplorer.DerivationStrategy;
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
+using System.Net.Http;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace BTCPayServer.Controllers
 {
     [Route("stores")]
-    [Authorize(AuthenticationSchemes = "Identity.Application")]
-    [Authorize(Policy = "CanAccessStore")]
+    [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
+    [Authorize(Policy = Policies.CanModifyStoreSettings.Key)]
     [AutoValidateAntiforgeryToken]
-    public class StoresController : Controller
+    public partial class StoresController : Controller
     {
+        BTCPayRateProviderFactory _RateFactory;
+        public string CreatedStoreId { get; set; }
         public StoresController(
+            NBXplorerDashboard dashboard,
+            IServiceProvider serviceProvider,
+            BTCPayServerOptions btcpayServerOptions,
+            BTCPayServerEnvironment btcpayEnv,
+            IOptions<MvcJsonOptions> mvcJsonOptions,
             StoreRepository repo,
             TokenRepository tokenRepo,
-            CallbackController callbackController,
             UserManager<ApplicationUser> userManager,
             AccessTokenController tokenController,
-            BTCPayWallet wallet,
-            Network network,
-            IHostingEnvironment env)
+            BTCPayWalletProvider walletProvider,
+            BTCPayNetworkProvider networkProvider,
+            BTCPayRateProviderFactory rateFactory,
+            ExplorerClientProvider explorerProvider,
+            IFeeProviderFactory feeRateProvider,
+            LanguageService langService,
+            IHostingEnvironment env,
+            CoinAverageSettings coinAverage)
         {
+            _RateFactory = rateFactory;
+            _Dashboard = dashboard;
             _Repo = repo;
             _TokenRepository = tokenRepo;
             _UserManager = userManager;
+            _LangService = langService;
             _TokenController = tokenController;
-            _Wallet = wallet;
+            _WalletProvider = walletProvider;
             _Env = env;
-            _Network = network;
-            _CallbackController = callbackController;
+            _NetworkProvider = networkProvider;
+            _ExplorerProvider = explorerProvider;
+            _MvcJsonOptions = mvcJsonOptions.Value;
+            _FeeRateProvider = feeRateProvider;
+            _ServiceProvider = serviceProvider;
+            _BtcpayServerOptions = btcpayServerOptions;
+            _BTCPayEnv = btcpayEnv;
+            _CoinAverage = coinAverage;
         }
-        Network _Network;
-        CallbackController _CallbackController;
-        BTCPayWallet _Wallet;
+        CoinAverageSettings _CoinAverage;
+        NBXplorerDashboard _Dashboard;
+        BTCPayServerOptions _BtcpayServerOptions;
+        BTCPayServerEnvironment _BTCPayEnv;
+        IServiceProvider _ServiceProvider;
+        BTCPayNetworkProvider _NetworkProvider;
+        private ExplorerClientProvider _ExplorerProvider;
+        private MvcJsonOptions _MvcJsonOptions;
+        private IFeeProviderFactory _FeeRateProvider;
+        BTCPayWalletProvider _WalletProvider;
         AccessTokenController _TokenController;
         StoreRepository _Repo;
         TokenRepository _TokenRepository;
         UserManager<ApplicationUser> _UserManager;
+        private LanguageService _LangService;
         IHostingEnvironment _Env;
 
         [TempData]
@@ -62,241 +98,445 @@ namespace BTCPayServer.Controllers
         }
 
         [HttpGet]
-        [Route("create")]
-        public IActionResult CreateStore()
+        [Route("{storeId}/wallet/{cryptoCode}")]
+        public IActionResult Wallet(string cryptoCode)
         {
-            return View();
+            WalletModel model = new WalletModel();
+            model.ServerUrl = GetStoreUrl(StoreData.Id);
+            model.CryptoCurrency = cryptoCode;
+            return View(model);
         }
 
-        [HttpPost]
-        [Route("create")]
-        public async Task<IActionResult> CreateStore(CreateStoreViewModel vm)
+        private string GetStoreUrl(string storeId)
         {
+            return HttpContext.Request.GetAbsoluteRoot() + "/stores/" + storeId + "/";
+        }
+
+        [HttpGet]
+        [Route("{storeId}/users")]
+        public async Task<IActionResult> StoreUsers()
+        {
+            StoreUsersViewModel vm = new StoreUsersViewModel();
+            await FillUsers(vm);
+            return View(vm);
+        }
+
+        private async Task FillUsers(StoreUsersViewModel vm)
+        {
+            var users = await _Repo.GetStoreUsers(StoreData.Id);
+            vm.StoreId = StoreData.Id;
+            vm.Users = users.Select(u => new StoreUsersViewModel.StoreUserViewModel()
+            {
+                Email = u.Email,
+                Id = u.Id,
+                Role = u.Role
+            }).ToList();
+        }
+
+        public StoreData StoreData
+        {
+            get
+            {
+                return this.HttpContext.GetStoreData();
+            }
+        }
+
+
+        [HttpPost]
+        [Route("{storeId}/users")]
+        public async Task<IActionResult> StoreUsers(StoreUsersViewModel vm)
+        {
+            await FillUsers(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));
-        }
-
-        public string CreatedStoreId
-        {
-            get; set;
-        }
-
-        [HttpGet]
-        public async Task<IActionResult> ListStores()
-        {
-            StoresViewModel result = new StoresViewModel();
-            result.StatusMessage = StatusMessage;
-            var stores = await _Repo.GetStoresByUserId(GetUserId());
-            var balances = stores.Select(async s => string.IsNullOrEmpty(s.DerivationStrategy) ? Money.Zero : await _Wallet.GetBalance(ParseDerivationStrategy(s.DerivationStrategy, null))).ToArray();
-
-            for (int i = 0; i < stores.Length; i++)
+            var user = await _UserManager.FindByEmailAsync(vm.Email);
+            if (user == null)
             {
-                var store = stores[i];
-                result.Stores.Add(new StoresViewModel.StoreViewModel()
-                {
-                    Id = store.Id,
-                    Name = store.StoreName,
-                    WebSite = store.StoreWebsite,
-                    Balance = await balances[i]
-                });
+                ModelState.AddModelError(nameof(vm.Email), "User not found");
+                return View(vm);
             }
-            return View(result);
+            if (!StoreRoles.AllRoles.Contains(vm.Role))
+            {
+                ModelState.AddModelError(nameof(vm.Role), "Invalid role");
+                return View(vm);
+            }
+            if (!await _Repo.AddStoreUser(StoreData.Id, user.Id, vm.Role))
+            {
+                ModelState.AddModelError(nameof(vm.Email), "The user already has access to this store");
+                return View(vm);
+            }
+            StatusMessage = "User added successfully";
+            return RedirectToAction(nameof(StoreUsers));
         }
 
         [HttpGet]
-        [Route("{storeId}/delete")]
-        public async Task<IActionResult> DeleteStore(string storeId)
+        [Route("{storeId}/users/{userId}/delete")]
+        public async Task<IActionResult> DeleteStoreUser(string userId)
         {
-            var store = await _Repo.FindStore(storeId, GetUserId());
-            if (store == null)
+            StoreUsersViewModel vm = new StoreUsersViewModel();
+            var user = await _UserManager.FindByIdAsync(userId);
+            if (user == null)
                 return NotFound();
             return View("Confirm", new ConfirmModel()
             {
-                Title = "Delete store " + store.StoreName,
-                Description = "This store will still be accessible to users sharing it",
+                Title = $"Remove store user",
+                Description = $"Are you sure to remove access to remove access to {user.Email}?",
                 Action = "Delete"
             });
         }
 
         [HttpPost]
-        [Route("{storeId}/delete")]
-        public async Task<IActionResult> DeleteStorePost(string storeId)
+        [Route("{storeId}/users/{userId}/delete")]
+        public async Task<IActionResult> DeleteStoreUserPost(string storeId, string userId)
         {
-            var userId = GetUserId();
-            var store = await _Repo.FindStore(storeId, GetUserId());
-            if (store == null)
-                return NotFound();
-            await _Repo.RemoveStore(storeId, userId);
-            StatusMessage = "Store removed successfully";
-            return RedirectToAction(nameof(ListStores));
+            await _Repo.RemoveStoreUser(storeId, userId);
+            StatusMessage = "User removed successfully";
+            return RedirectToAction(nameof(StoreUsers), new { storeId = storeId, userId = userId });
+        }
+
+        [HttpGet]
+        [Route("{storeId}/rates")]
+        public IActionResult Rates()
+        {
+            var storeBlob = StoreData.GetStoreBlob();
+            var vm = new RatesViewModel();
+            vm.SetExchangeRates(GetSupportedExchanges(), storeBlob.PreferredExchange ?? CoinAverageRateProvider.CoinAverageName);
+            vm.RateMultiplier = (double)storeBlob.GetRateMultiplier();
+            vm.Script = storeBlob.GetRateRules(_NetworkProvider).ToString();
+            vm.DefaultScript = storeBlob.GetDefaultRateRules(_NetworkProvider).ToString();
+            vm.AvailableExchanges = GetSupportedExchanges();
+            vm.ShowScripting = storeBlob.RateScripting;
+            return View(vm);
+        }
+
+        [HttpPost]
+        [Route("{storeId}/rates")]
+        public async Task<IActionResult> Rates(RatesViewModel model, string command = null)
+        {
+            model.SetExchangeRates(GetSupportedExchanges(), model.PreferredExchange);
+            if (!ModelState.IsValid)
+            {
+                return View(model);
+            }
+            if (model.PreferredExchange != null)
+                model.PreferredExchange = model.PreferredExchange.Trim().ToLowerInvariant();
+
+            var blob = StoreData.GetStoreBlob();
+            model.DefaultScript = blob.GetDefaultRateRules(_NetworkProvider).ToString();
+            model.AvailableExchanges = GetSupportedExchanges();
+
+            blob.PreferredExchange = model.PreferredExchange;
+            blob.SetRateMultiplier(model.RateMultiplier);
+
+            if (!model.ShowScripting)
+            {
+                if (!GetSupportedExchanges().Select(c => c.Name).Contains(blob.PreferredExchange, StringComparer.OrdinalIgnoreCase))
+                {
+                    ModelState.AddModelError(nameof(model.PreferredExchange), $"Unsupported exchange ({model.RateSource})");
+                    return View(model);
+                }
+            }
+            RateRules rules = null;
+            if (model.ShowScripting)
+            {
+                if (!RateRules.TryParse(model.Script, out rules, out var errors))
+                {
+                    errors = errors ?? new List<RateRulesErrors>();
+                    var errorString = String.Join(", ", errors.ToArray());
+                    ModelState.AddModelError(nameof(model.Script), $"Parsing error ({errorString})");
+                    return View(model);
+                }
+                else
+                {
+                    blob.RateScript = rules.ToString();
+                    ModelState.Remove(nameof(model.Script));
+                    model.Script = blob.RateScript;
+                }
+            }
+            rules = blob.GetRateRules(_NetworkProvider);
+
+            if (command == "Test")
+            {
+                if (string.IsNullOrWhiteSpace(model.ScriptTest))
+                {
+                    ModelState.AddModelError(nameof(model.ScriptTest), "Fill out currency pair to test for (like BTC_USD,BTC_CAD)");
+                    return View(model);
+                }
+                var splitted = model.ScriptTest.Split(',', StringSplitOptions.RemoveEmptyEntries);
+
+                var pairs = new List<CurrencyPair>();
+                foreach (var pair in splitted)
+                {
+                    if (!CurrencyPair.TryParse(pair, out var currencyPair))
+                    {
+                        ModelState.AddModelError(nameof(model.ScriptTest), $"Invalid currency pair '{pair}' (it should be formatted like BTC_USD,BTC_CAD)");
+                        return View(model);
+                    }
+                    pairs.Add(currencyPair);
+                }
+
+                var fetchs = _RateFactory.FetchRates(pairs.ToHashSet(), rules);
+                var testResults = new List<RatesViewModel.TestResultViewModel>();
+                foreach (var fetch in fetchs)
+                {
+                    var testResult = await (fetch.Value);
+                    testResults.Add(new RatesViewModel.TestResultViewModel()
+                    {
+                        CurrencyPair = fetch.Key.ToString(),
+                        Error = testResult.Errors.Count != 0,
+                        Rule = testResult.Errors.Count == 0 ? testResult.Rule + " = " + testResult.Value.Value.ToString(CultureInfo.InvariantCulture) 
+                                                            : testResult.EvaluatedRule
+                    });
+                }
+                model.TestRateRules = testResults;
+                return View(model);
+            }
+            else // command == Save
+            {
+                if (StoreData.SetStoreBlob(blob))
+                {
+                    await _Repo.UpdateStore(StoreData);
+                    StatusMessage = "Rate settings updated";
+                }
+                return RedirectToAction(nameof(Rates), new
+                {
+                    storeId = StoreData.Id
+                });
+            }
+        }
+
+        [HttpGet]
+        [Route("{storeId}/rates/confirm")]
+        public IActionResult ShowRateRules(bool scripting)
+        {
+            return View("Confirm", new ConfirmModel()
+            {
+                Action = "Continue",
+                Title = "Rate rule scripting",
+                Description = scripting ?
+                                "This action will mofify your current rate sources. Are you sure to turn on rate rules scripting? (Advanced users)"
+                                : "This action will delete your rate script. Are you sure to turn off rate rules scripting?",
+                ButtonClass = "btn-primary"
+            });
+        }
+
+        [HttpPost]
+        [Route("{storeId}/rates/confirm")]
+        public async Task<IActionResult> ShowRateRulesPost(bool scripting)
+        {
+            var blob = StoreData.GetStoreBlob();
+            blob.RateScripting = scripting;
+            blob.RateScript = blob.GetDefaultRateRules(_NetworkProvider).ToString();
+            StoreData.SetStoreBlob(blob);
+            await _Repo.UpdateStore(StoreData);
+            StatusMessage = "Rate rules scripting activated";
+            return RedirectToAction(nameof(Rates), new { storeId = StoreData.Id });
+        }
+
+        [HttpGet]
+        [Route("{storeId}/checkout")]
+        public IActionResult CheckoutExperience()
+        {
+            var storeBlob = StoreData.GetStoreBlob();
+            var vm = new CheckoutExperienceViewModel();
+            vm.SetCryptoCurrencies(_ExplorerProvider, StoreData.GetDefaultCrypto());
+            vm.SetLanguages(_LangService, storeBlob.DefaultLang);
+            vm.LightningMaxValue = storeBlob.LightningMaxValue?.ToString() ?? "";
+            vm.OnChainMinValue = storeBlob.OnChainMinValue?.ToString() ?? "";
+            vm.AllowCoinConversion = storeBlob.AllowCoinConversion;
+            vm.RequiresRefundEmail = storeBlob.RequiresRefundEmail;
+            vm.CustomCSS = storeBlob.CustomCSS?.AbsoluteUri;
+            vm.CustomLogo = storeBlob.CustomLogo?.AbsoluteUri;
+            vm.HtmlTitle = storeBlob.HtmlTitle;
+            return View(vm);
+        }
+
+        [HttpPost]
+        [Route("{storeId}/checkout")]
+        public async Task<IActionResult> CheckoutExperience(CheckoutExperienceViewModel model)
+        {
+            CurrencyValue lightningMaxValue = null;
+            if (!string.IsNullOrWhiteSpace(model.LightningMaxValue))
+            {
+                if (!CurrencyValue.TryParse(model.LightningMaxValue, out lightningMaxValue))
+                {
+                    ModelState.AddModelError(nameof(model.LightningMaxValue), "Invalid lightning max value");
+                }
+            }
+
+            CurrencyValue onchainMinValue = null;
+            if (!string.IsNullOrWhiteSpace(model.OnChainMinValue))
+            {
+                if (!CurrencyValue.TryParse(model.OnChainMinValue, out onchainMinValue))
+                {
+                    ModelState.AddModelError(nameof(model.OnChainMinValue), "Invalid on chain min value");
+                }
+            }
+            bool needUpdate = false;
+            var blob = StoreData.GetStoreBlob();
+            if (StoreData.GetDefaultCrypto() != model.DefaultCryptoCurrency)
+            {
+                needUpdate = true;
+                StoreData.SetDefaultCrypto(model.DefaultCryptoCurrency);
+            }
+            model.SetCryptoCurrencies(_ExplorerProvider, model.DefaultCryptoCurrency);
+            model.SetLanguages(_LangService, model.DefaultLang);
+
+            if (!ModelState.IsValid)
+            {
+                return View(model);
+            }
+            blob.DefaultLang = model.DefaultLang;
+            blob.AllowCoinConversion = model.AllowCoinConversion;
+            blob.RequiresRefundEmail = model.RequiresRefundEmail;
+            blob.LightningMaxValue = lightningMaxValue;
+            blob.OnChainMinValue = onchainMinValue;
+            blob.CustomLogo = string.IsNullOrWhiteSpace(model.CustomLogo) ? null : new Uri(model.CustomLogo, UriKind.Absolute);
+            blob.CustomCSS = string.IsNullOrWhiteSpace(model.CustomCSS) ? null : new Uri(model.CustomCSS, UriKind.Absolute);
+            blob.HtmlTitle = string.IsNullOrWhiteSpace(model.HtmlTitle) ? null : model.HtmlTitle;
+            if (StoreData.SetStoreBlob(blob))
+            {
+                needUpdate = true;
+            }
+            if (needUpdate)
+            {
+                await _Repo.UpdateStore(StoreData);
+                StatusMessage = "Store successfully updated";
+            }
+
+            return RedirectToAction(nameof(CheckoutExperience), new
+            {
+                storeId = StoreData.Id
+            });
         }
 
         [HttpGet]
         [Route("{storeId}")]
-        public async Task<IActionResult> UpdateStore(string storeId)
+        public IActionResult UpdateStore()
         {
-            var store = await _Repo.FindStore(storeId, GetUserId());
+            var store = HttpContext.GetStoreData();
             if (store == null)
                 return NotFound();
 
-            var storeBlob = store.GetStoreBlob(_Network);
+            var storeBlob = store.GetStoreBlob();
             var vm = new StoreViewModel();
             vm.Id = store.Id;
             vm.StoreName = store.StoreName;
             vm.StoreWebsite = store.StoreWebsite;
             vm.NetworkFee = !storeBlob.NetworkFeeDisabled;
             vm.SpeedPolicy = store.SpeedPolicy;
-            vm.DerivationScheme = store.DerivationStrategy;
-            vm.StatusMessage = StatusMessage;
+            AddPaymentMethods(store, vm);
             vm.MonitoringExpiration = storeBlob.MonitoringExpiration;
+            vm.InvoiceExpiration = storeBlob.InvoiceExpiration;
+            vm.LightningDescriptionTemplate = storeBlob.LightningDescriptionTemplate;
+            vm.PaymentTolerance = storeBlob.PaymentTolerance;
             return View(vm);
         }
 
+
+        private void AddPaymentMethods(StoreData store, StoreViewModel vm)
+        {
+            var derivationByCryptoCode =
+                store
+                .GetSupportedPaymentMethods(_NetworkProvider)
+                .OfType<DerivationStrategy>()
+                .ToDictionary(c => c.Network.CryptoCode);
+            foreach (var network in _NetworkProvider.GetAll())
+            {
+                var strategy = derivationByCryptoCode.TryGet(network.CryptoCode);
+                vm.DerivationSchemes.Add(new StoreViewModel.DerivationScheme()
+                {
+                    Crypto = network.CryptoCode,
+                    Value = strategy?.DerivationStrategyBase?.ToString() ?? string.Empty
+                });
+            }
+
+            var lightningByCryptoCode = store
+                                        .GetSupportedPaymentMethods(_NetworkProvider)
+                                        .OfType<Payments.Lightning.LightningSupportedPaymentMethod>()
+                                        .ToDictionary(c => c.CryptoCode);
+
+            foreach (var network in _NetworkProvider.GetAll())
+            {
+                var lightning = lightningByCryptoCode.TryGet(network.CryptoCode);
+                vm.LightningNodes.Add(new StoreViewModel.LightningNode()
+                {
+                    CryptoCode = network.CryptoCode,
+                    Address = lightning?.GetLightningUrl()?.BaseUri.AbsoluteUri ?? string.Empty
+                });
+            }
+        }
+
         [HttpPost]
         [Route("{storeId}")]
-        public async Task<IActionResult> UpdateStore(string storeId, StoreViewModel model, string command)
+        public async Task<IActionResult> UpdateStore(StoreViewModel model)
         {
-            if (!ModelState.IsValid)
+            AddPaymentMethods(StoreData, model);
+
+            bool needUpdate = false;
+            if (StoreData.SpeedPolicy != model.SpeedPolicy)
             {
-                return View(model);
+                needUpdate = true;
+                StoreData.SpeedPolicy = model.SpeedPolicy;
             }
-            var store = await _Repo.FindStore(storeId, GetUserId());
-            if (store == null)
-                return NotFound();
-
-            if (command == "Save")
+            if (StoreData.StoreName != model.StoreName)
             {
-                bool needUpdate = false;
-                if (store.SpeedPolicy != model.SpeedPolicy)
-                {
-                    needUpdate = true;
-                    store.SpeedPolicy = model.SpeedPolicy;
-                }
-                if (store.StoreName != model.StoreName)
-                {
-                    needUpdate = true;
-                    store.StoreName = model.StoreName;
-                }
-                if (store.StoreWebsite != model.StoreWebsite)
-                {
-                    needUpdate = true;
-                    store.StoreWebsite = model.StoreWebsite;
-                }
-
-                if (store.DerivationStrategy != model.DerivationScheme)
-                {
-                    needUpdate = true;
-                    try
-                    {
-                        if (!string.IsNullOrEmpty(model.DerivationScheme))
-                        {
-                            var strategy = ParseDerivationStrategy(model.DerivationScheme, model.DerivationSchemeFormat);
-                            await _Wallet.TrackAsync(strategy);
-                            await _CallbackController.RegisterCallbackUriAsync(strategy);
-                            model.DerivationScheme = strategy.ToString();
-                        }
-                        store.DerivationStrategy = model.DerivationScheme;
-                    }
-                    catch
-                    {
-                        ModelState.AddModelError(nameof(model.DerivationScheme), "Invalid Derivation Scheme");
-                        return View(model);
-                    }
-                }
-
-                var blob = store.GetStoreBlob(_Network);
-                blob.NetworkFeeDisabled = !model.NetworkFee;
-                blob.MonitoringExpiration = model.MonitoringExpiration;
-
-                if (store.SetStoreBlob(blob, _Network))
-                {
-                    needUpdate = true;
-                }
-
-                if (needUpdate)
-                {
-                    await _Repo.UpdateStore(store);
-                    StatusMessage = "Store successfully updated";
-                }
-
-                return RedirectToAction(nameof(UpdateStore), new
-                {
-                    storeId = storeId
-                });
+                needUpdate = true;
+                StoreData.StoreName = model.StoreName;
             }
-            else
+            if (StoreData.StoreWebsite != model.StoreWebsite)
             {
-                if (!string.IsNullOrEmpty(model.DerivationScheme))
-                {
-                    try
-                    {
-                        var scheme = ParseDerivationStrategy(model.DerivationScheme, model.DerivationSchemeFormat);
-                        var line = scheme.GetLineFor(DerivationFeature.Deposit);
-
-                        for (int i = 0; i < 10; i++)
-                        {
-                            var address = line.Derive((uint)i);
-                            model.AddressSamples.Add((line.Path.Derive((uint)i).ToString(), address.ScriptPubKey.GetDestinationAddress(_Network).ToString()));
-                        }
-                    }
-                    catch
-                    {
-                        ModelState.AddModelError(nameof(model.DerivationScheme), "Invalid Derivation Scheme");
-                    }
-                }
-                return View(model);
+                needUpdate = true;
+                StoreData.StoreWebsite = model.StoreWebsite;
             }
+
+            var blob = StoreData.GetStoreBlob();
+            blob.NetworkFeeDisabled = !model.NetworkFee;
+            blob.MonitoringExpiration = model.MonitoringExpiration;
+            blob.InvoiceExpiration = model.InvoiceExpiration;
+            blob.LightningDescriptionTemplate = model.LightningDescriptionTemplate ?? string.Empty;
+            blob.PaymentTolerance = model.PaymentTolerance;
+
+            if (StoreData.SetStoreBlob(blob))
+            {
+                needUpdate = true;
+            }
+
+            if (needUpdate)
+            {
+                await _Repo.UpdateStore(StoreData);
+                StatusMessage = "Store successfully updated";
+            }
+
+            return RedirectToAction(nameof(UpdateStore), new
+            {
+                storeId = StoreData.Id
+            });
         }
 
-        private DerivationStrategyBase ParseDerivationStrategy(string derivationScheme, string format)
+        private CoinAverageExchange[] GetSupportedExchanges()
         {
-            if (format == "Electrum")
-            {
-                //Unsupported Electrum
-                //var p2wsh_p2sh = 0x295b43fU;
-                //var p2wsh = 0x2aa7ed3U;
-                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, new string[] { });
+            return _CoinAverage.AvailableExchanges
+                    .Select(c => c.Value)
+                    .OrderBy(s => s.Name, StringComparer.OrdinalIgnoreCase)
+                    .ToArray();
+        }
 
-                var data = Encoders.Base58Check.DecodeData(derivationScheme);
-                if (data.Length < 4)
-                    throw new FormatException("data.Length < 4");
-                var prefix = Utils.ToUInt32(data, false);
-                if (!electrumMapping.TryGetValue(prefix, out string[] labels))
-                    throw new FormatException("!electrumMapping.TryGetValue(prefix, out string[] labels)");
-                var standardPrefix = Utils.ToBytes(_Network == Network.Main ? 0x0488b21eU : 0x043587cf, false);
-
-                for (int i = 0; i < 4; i++)
-                    data[i] = standardPrefix[i];
-
-                derivationScheme = new BitcoinExtPubKey(Encoders.Base58Check.EncodeData(data), _Network).ToString();
-                foreach (var label in labels)
-                {
-                    derivationScheme = derivationScheme + $"-[{label}]";
-                }
-            }
-
-            return new DerivationStrategyFactory(_Network).Parse(derivationScheme);
+        private DerivationStrategy ParseDerivationStrategy(string derivationScheme, Script hint, BTCPayNetwork network)
+        {
+            var parser = new DerivationSchemeParser(network.NBitcoinNetwork);
+            parser.HintScriptPubKey = hint;
+            return new DerivationStrategy(parser.Parse(derivationScheme), network);
         }
 
         [HttpGet]
         [Route("{storeId}/Tokens")]
-        public async Task<IActionResult> ListTokens(string storeId)
+        public async Task<IActionResult> ListTokens()
         {
             var model = new TokensViewModel();
-            var tokens = await _TokenRepository.GetTokensByStoreIdAsync(storeId);
+            var tokens = await _TokenRepository.GetTokensByStoreIdAsync(StoreData.Id);
             model.StatusMessage = StatusMessage;
             model.Tokens = tokens.Select(t => new TokenViewModel()
             {
@@ -305,28 +545,43 @@ namespace BTCPayServer.Controllers
                 SIN = t.SIN,
                 Id = t.Value
             }).ToArray();
+
+            model.ApiKey = (await _TokenRepository.GetLegacyAPIKeys(StoreData.Id)).FirstOrDefault();
+            if (model.ApiKey == null)
+                model.EncodedApiKey = "*API Key*";
+            else
+                model.EncodedApiKey = Encoders.Base64.EncodeData(Encoders.ASCII.DecodeData(model.ApiKey));
             return View(model);
         }
 
         [HttpPost]
         [Route("/api-tokens")]
         [Route("{storeId}/Tokens/Create")]
-        public async Task<IActionResult> CreateToken(string storeId, CreateTokenViewModel model)
+        [AllowAnonymous]
+        public async Task<IActionResult> CreateToken(CreateTokenViewModel model)
         {
             if (!ModelState.IsValid)
             {
                 return View(model);
             }
             model.Label = model.Label ?? String.Empty;
-            if (storeId == null) // Permissions are not checked by Policy if the storeId is not passed by url
+            var userId = GetUserId();
+            if (userId == null)
+                return Challenge(Policies.CookieAuthentication);
+
+            var store = StoreData;
+            var storeId = StoreData?.Id;
+            if (storeId == null)
             {
                 storeId = model.StoreId;
-                var userId = GetUserId();
-                if (userId == null)
-                    return Unauthorized();
-                var store = await _Repo.FindStore(storeId, userId);
+                store = await _Repo.FindStore(storeId, userId);
                 if (store == null)
-                    return Unauthorized();
+                    return Challenge(Policies.CookieAuthentication);
+            }
+
+            if (!store.HasClaim(Policies.CanModifyStoreSettings.Key))
+            {
+                return Challenge(Policies.CookieAuthentication);
             }
 
             var tokenRequest = new TokenRequest()
@@ -354,6 +609,7 @@ namespace BTCPayServer.Controllers
                 pairingCode = ((DataWrapper<List<PairingCodeResponse>>)await _TokenController.Tokens(tokenRequest)).Data[0].PairingCode;
             }
 
+            GeneratedPairingCode = pairingCode;
             return RedirectToAction(nameof(RequestPairing), new
             {
                 pairingCode = pairingCode,
@@ -361,14 +617,25 @@ namespace BTCPayServer.Controllers
             });
         }
 
+        public string GeneratedPairingCode { get; set; }
+
         [HttpGet]
         [Route("/api-tokens")]
         [Route("{storeId}/Tokens/Create")]
-        public async Task<IActionResult> CreateToken(string storeId)
+        [AllowAnonymous]
+        public async Task<IActionResult> CreateToken()
         {
             var userId = GetUserId();
             if (string.IsNullOrWhiteSpace(userId))
-                return Unauthorized();
+                return Challenge(Policies.CookieAuthentication);
+            var storeId = StoreData?.Id;
+            if (StoreData != null)
+            {
+                if (!StoreData.HasClaim(Policies.CanModifyStoreSettings.Key))
+                {
+                    return Challenge(Policies.CookieAuthentication);
+                }
+            }
             var model = new CreateTokenViewModel();
             model.Facade = "merchant";
             ViewBag.HidePublicKey = storeId == null;
@@ -377,20 +644,25 @@ namespace BTCPayServer.Controllers
             model.StoreId = storeId;
             if (storeId == null)
             {
-                model.Stores = new SelectList(await _Repo.GetStoresByUserId(userId), nameof(StoreData.Id), nameof(StoreData.StoreName), storeId);
+                var stores = await _Repo.GetStoresByUserId(userId);
+                model.Stores = new SelectList(stores.Where(s => s.HasClaim(Policies.CanModifyStoreSettings.Key)), nameof(StoreData.Id), nameof(StoreData.StoreName), storeId);
+            }
+            if (model.Stores.Count() == 0)
+            {
+                StatusMessage = "Error: You need to be owner of at least one store before pairing";
+                return RedirectToAction(nameof(UserStoresController.ListStores), "UserStores");
             }
-
             return View(model);
         }
 
 
         [HttpPost]
         [Route("{storeId}/Tokens/Delete")]
-        public async Task<IActionResult> DeleteToken(string storeId, string tokenId)
+        public async Task<IActionResult> DeleteToken(string tokenId)
         {
             var token = await _TokenRepository.GetToken(tokenId);
             if (token == null ||
-                token.StoreId != storeId ||
+                token.StoreId != StoreData.Id ||
                !await _TokenRepository.DeleteToken(tokenId))
                 StatusMessage = "Failure to revoke this token";
             else
@@ -398,20 +670,37 @@ namespace BTCPayServer.Controllers
             return RedirectToAction(nameof(ListTokens));
         }
 
+        [HttpPost]
+        [Route("{storeId}/tokens/apikey")]
+        public async Task<IActionResult> GenerateAPIKey()
+        {
+            var store = HttpContext.GetStoreData();
+            if (store == null)
+                return NotFound();
+            await _TokenRepository.GenerateLegacyAPIKey(StoreData.Id);
+            StatusMessage = "API Key re-generated";
+            return RedirectToAction(nameof(ListTokens));
+        }
 
         [HttpGet]
         [Route("/api-access-request")]
+        [AllowAnonymous]
         public async Task<IActionResult> RequestPairing(string pairingCode, string selectedStore = null)
         {
+            var userId = GetUserId();
+            if (userId == null)
+                return Challenge(Policies.CookieAuthentication);
+            if (pairingCode == null)
+                return NotFound();
             var pairing = await _TokenRepository.GetPairingAsync(pairingCode);
             if (pairing == null)
             {
                 StatusMessage = "Unknown pairing code";
-                return RedirectToAction(nameof(ListStores));
+                return RedirectToAction(nameof(UserStoresController.ListStores), "UserStores");
             }
             else
             {
-                var stores = await _Repo.GetStoresByUserId(GetUserId());
+                var stores = await _Repo.GetStoresByUserId(userId);
                 return View(new PairingModel()
                 {
                     Id = pairing.Id,
@@ -419,7 +708,7 @@ namespace BTCPayServer.Controllers
                     Label = pairing.Label,
                     SIN = pairing.SIN ?? "Server-Initiated Pairing",
                     SelectedStore = selectedStore ?? stores.FirstOrDefault()?.Id,
-                    Stores = stores.Select(s => new PairingModel.StoreViewModel()
+                    Stores = stores.Where(u => u.HasClaim(Policies.CanModifyStoreSettings.Key)).Select(s => new PairingModel.StoreViewModel()
                     {
                         Id = s.Id,
                         Name = string.IsNullOrEmpty(s.StoreName) ? s.Id : s.StoreName
@@ -429,20 +718,29 @@ namespace BTCPayServer.Controllers
         }
 
         [HttpPost]
-        [Route("api-access-request")]
+        [Route("/api-access-request")]
+        [AllowAnonymous]
         public async Task<IActionResult> Pair(string pairingCode, string selectedStore)
         {
             if (pairingCode == null)
                 return NotFound();
-            var store = await _Repo.FindStore(selectedStore, GetUserId());
+            var userId = GetUserId();
+            if (userId == null)
+                return Challenge(Policies.CookieAuthentication);
+            var store = await _Repo.FindStore(selectedStore, userId);
             var pairing = await _TokenRepository.GetPairingAsync(pairingCode);
             if (store == null || pairing == null)
                 return NotFound();
 
+            if (!store.HasClaim(Policies.CanModifyStoreSettings.Key))
+            {
+                return Challenge(Policies.CookieAuthentication);
+            }
+
             var pairingResult = await _TokenRepository.PairWithStoreAsync(pairingCode, store.Id);
             if (pairingResult == PairingResult.Complete || pairingResult == PairingResult.Partial)
             {
-                StatusMessage = "Pairing is successfull";
+                StatusMessage = "Pairing is successful";
                 if (pairingResult == PairingResult.Partial)
                     StatusMessage = "Server initiated pairing code: " + pairingCode;
                 return RedirectToAction(nameof(ListTokens), new
@@ -462,6 +760,8 @@ namespace BTCPayServer.Controllers
 
         private string GetUserId()
         {
+            if (User.Identity.AuthenticationType != Policies.CookieAuthentication)
+                return null;
             return _UserManager.GetUserId(User);
         }
     }

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);
+            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/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,16 +2,53 @@
 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
     {
+        /// <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;
         }
 
+
+#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;
@@ -26,5 +63,6 @@ namespace BTCPayServer.Data
         {
             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

@@ -26,6 +26,16 @@ namespace BTCPayServer.Data
             get; set;
         }
 
+        public DbSet<AppData> Apps
+        {
+            get; set;
+        }
+
+        public DbSet<InvoiceEventData> InvoiceEvents
+        {
+            get; set;
+        }
+
         public DbSet<HistoricalAddressInvoiceData> HistoricalAddressInvoices
         {
             get; set;
@@ -76,6 +86,11 @@ namespace BTCPayServer.Data
             get; set;
         }
 
+        public DbSet<APIKeyData> ApiKeys
+        {
+            get; set;
+        }
+
         protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
         {
             var isConfigured = optionsBuilder.Options.Extensions.OfType<RelationalOptionsExtension>().Any();
@@ -102,6 +117,12 @@ namespace BTCPayServer.Data
                        t.StoreDataId
                    });
 
+            builder.Entity<APIKeyData>()
+                .HasIndex(o => o.StoreId);
+
+            builder.Entity<AppData>()
+                    .HasOne(a => a.StoreData);
+
             builder.Entity<UserStore>()
                  .HasOne(pt => pt.ApplicationUser)
                  .WithMany(p => p.UserStores)
@@ -113,7 +134,9 @@ namespace BTCPayServer.Data
                 .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);
@@ -128,7 +151,18 @@ namespace BTCPayServer.Data
                 .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/HistoricalAddressInvoiceData.cs

@@ -12,11 +12,43 @@ namespace BTCPayServer.Data
             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;

BTCPayServer/Data/InvoiceData.cs

@@ -32,6 +32,11 @@ namespace BTCPayServer.Data
             get; set;
         }
 
+        public List<InvoiceEventData> Events
+        {
+            get; set;
+        }
+
         public List<RefundAddressesData> RefundAddresses
         {
             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/StoreData.cs

@@ -10,6 +10,15 @@ 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
 {
@@ -26,11 +35,106 @@ namespace BTCPayServer.Data
             get; set;
         }
 
+        public List<AppData> Apps
+        {
+            get; set;
+        }
+
+        [Obsolete("Use GetDerivationStrategies instead")]
         public string DerivationStrategy
         {
             get; set;
         }
 
+        [Obsolete("Use GetDerivationStrategies instead")]
+        public string DerivationStrategies
+        {
+            get;
+            set;
+        }
+
+        public IEnumerable<ISupportedPaymentMethod> GetSupportedPaymentMethods(BTCPayNetworkProvider networks)
+        {
+#pragma warning disable CS0618
+            bool btcReturned = false;
+
+            // Legacy stuff which should go away
+            if (!string.IsNullOrEmpty(DerivationStrategy))
+            {
+                if (networks.BTC != null)
+                {
+                    btcReturned = true;
+                    yield return BTCPayServer.DerivationStrategy.Parse(DerivationStrategy, networks.BTC);
+                }
+            }
+
+
+            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;
@@ -52,25 +156,68 @@ namespace BTCPayServer.Data
         }
 
         [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; }
 
-        public StoreBlob GetStoreBlob(Network network)
+#pragma warning disable CS0618
+        public string GetDefaultCrypto()
         {
-            return StoreBlob == null ? new StoreBlob() : new Serializer(network).ToObject<StoreBlob>(Encoding.UTF8.GetString(StoreBlob));
+            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, Network network)
+        public bool SetStoreBlob(StoreBlob storeBlob)
         {
-            var original = new Serializer(network).ToString(GetStoreBlob(network));
-            var newBlob = new Serializer(network).ToString(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);
@@ -78,16 +225,43 @@ namespace BTCPayServer.Data
         }
     }
 
+    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
@@ -95,5 +269,106 @@ namespace BTCPayServer.Data
             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/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/Eclair/AllChannelResponse.cs

@@ -1,14 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-
-namespace BTCPayServer.Eclair
-{
-    public class AllChannelResponse
-    {
-        public string ShortChannelId { get; set; }
-        public string NodeId1 { get; set; }
-        public string NodeId2 { get; set; }
-    }
-}

BTCPayServer/Eclair/ChannelResponse.cs

@@ -1,21 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-
-namespace BTCPayServer.Eclair
-{
-    public class ChannelResponse
-    {
-
-        public string NodeId { get; set; }
-        public string ChannelId { get; set; }
-        public string State { get; set; }
-    }
-    public static class ChannelStates
-    {
-        public const string WAIT_FOR_FUNDING_CONFIRMED = "WAIT_FOR_FUNDING_CONFIRMED";
-
-        public const string NORMAL = "NORMAL";
-    }
-}

BTCPayServer/Eclair/EclairRPCClient.cs

@@ -1,230 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Net;
-using System.Text;
-using System.Threading.Tasks;
-using NBitcoin;
-using NBitcoin.JsonConverters;
-using NBitcoin.RPC;
-
-namespace BTCPayServer.Eclair
-{
-    public class EclairRPCClient
-    {
-        public EclairRPCClient(Uri address, Network network)
-        {
-            if (address == null)
-                throw new ArgumentNullException(nameof(address));
-            if (network == null)
-                throw new ArgumentNullException(nameof(network));
-            Address = address;
-            Network = network;
-        }
-
-        public Network Network { get; private set; }
-
-
-        public GetInfoResponse GetInfo()
-        {
-            return GetInfoAsync().GetAwaiter().GetResult();
-        }
-
-        public Task<GetInfoResponse> GetInfoAsync()
-        {
-            return SendCommandAsync<GetInfoResponse>(new RPCRequest("getinfo", new object[] { }));
-        }
-
-        public async Task<T> SendCommandAsync<T>(RPCRequest request, bool throwIfRPCError = true)
-        {
-            var response = await SendCommandAsync(request, throwIfRPCError);
-            return Serializer.ToObject<T>(response.ResultString, Network);
-        }
-
-        public async Task<RPCResponse> SendCommandAsync(RPCRequest request, bool throwIfRPCError = true)
-        {
-            RPCResponse response = null;
-            HttpWebRequest webRequest = response == null ? CreateWebRequest() : null;
-            if (response == null)
-            {
-                var writer = new StringWriter();
-                request.WriteJSON(writer);
-                writer.Flush();
-                var json = writer.ToString();
-                var bytes = Encoding.UTF8.GetBytes(json);
-#if !(PORTABLE || NETCORE)
-                webRequest.ContentLength = bytes.Length;
-#endif
-                var dataStream = await webRequest.GetRequestStreamAsync().ConfigureAwait(false);
-                await dataStream.WriteAsync(bytes, 0, bytes.Length).ConfigureAwait(false);
-                await dataStream.FlushAsync().ConfigureAwait(false);
-                dataStream.Dispose();
-            }
-            WebResponse webResponse = null;
-            WebResponse errorResponse = null;
-            try
-            {
-                webResponse = response == null ? await webRequest.GetResponseAsync().ConfigureAwait(false) : null;
-                response = response ?? RPCResponse.Load(await ToMemoryStreamAsync(webResponse.GetResponseStream()).ConfigureAwait(false));
-
-                if (throwIfRPCError)
-                    response.ThrowIfError();
-            }
-            catch (WebException ex)
-            {
-                if (ex.Response == null || ex.Response.ContentLength == 0 ||
-                    !ex.Response.ContentType.Equals("application/json", StringComparison.Ordinal))
-                    throw;
-                errorResponse = ex.Response;
-                response = RPCResponse.Load(await ToMemoryStreamAsync(errorResponse.GetResponseStream()).ConfigureAwait(false));
-                if (throwIfRPCError)
-                    response.ThrowIfError();
-            }
-            finally
-            {
-                if (errorResponse != null)
-                {
-                    errorResponse.Dispose();
-                    errorResponse = null;
-                }
-                if (webResponse != null)
-                {
-                    webResponse.Dispose();
-                    webResponse = null;
-                }
-            }
-            return response;
-        }
-
-        public AllChannelResponse[] AllChannels()
-        {
-            return AllChannelsAsync().GetAwaiter().GetResult();
-        }
-
-        public async Task<AllChannelResponse[]> AllChannelsAsync()
-        {
-            return await SendCommandAsync<AllChannelResponse[]>(new RPCRequest("allchannels", new object[] { })).ConfigureAwait(false);
-        }
-
-        public string[] Channels()
-        {
-            return ChannelsAsync().GetAwaiter().GetResult();
-        }
-
-        public async Task<string[]> ChannelsAsync()
-        {
-            return await SendCommandAsync<string[]>(new RPCRequest("channels", new object[] { })).ConfigureAwait(false);
-        }
-
-        public void Close(string channelId)
-        {
-            CloseAsync(channelId).GetAwaiter().GetResult();
-        }
-
-        public async Task CloseAsync(string channelId)
-        {
-            if (channelId == null)
-                throw new ArgumentNullException(nameof(channelId));
-            try
-            {
-                await SendCommandAsync(new RPCRequest("close", new object[] { channelId })).ConfigureAwait(false);
-            }
-            catch (RPCException ex) when (ex.Message == "closing already in progress")
-            {
-                
-            }
-        }
-
-        public ChannelResponse Channel(string channelId)
-        {
-            return ChannelAsync(channelId).GetAwaiter().GetResult();
-        }
-
-        public async Task<ChannelResponse> ChannelAsync(string channelId)
-        {
-            if (channelId == null)
-                throw new ArgumentNullException(nameof(channelId));
-            return await SendCommandAsync<ChannelResponse>(new RPCRequest("channel", new object[] { channelId })).ConfigureAwait(false);
-        }
-
-        public string[] AllNodes()
-        {
-            return AllNodesAsync().GetAwaiter().GetResult();
-        }
-
-        public async Task<string[]> AllNodesAsync()
-        {
-            return await SendCommandAsync<string[]>(new RPCRequest("allnodes", new object[] { })).ConfigureAwait(false);
-        }
-
-        public Uri Address { get; private set; }
-
-        private HttpWebRequest CreateWebRequest()
-        {
-            var webRequest = (HttpWebRequest)WebRequest.Create(Address.AbsoluteUri);
-            webRequest.ContentType = "application/json";
-            webRequest.Method = "POST";
-            return webRequest;
-        }
-
-
-        private async Task<Stream> ToMemoryStreamAsync(Stream stream)
-        {
-            MemoryStream ms = new MemoryStream();
-            await stream.CopyToAsync(ms).ConfigureAwait(false);
-            ms.Position = 0;
-            return ms;
-        }
-
-        public string Open(NodeInfo node, Money fundingSatoshi, LightMoney pushAmount = null)
-        {
-            return OpenAsync(node, fundingSatoshi, pushAmount).GetAwaiter().GetResult();
-        }
-
-        public string Connect(NodeInfo node)
-        {
-            return ConnectAsync(node).GetAwaiter().GetResult();
-        }
-
-        public async Task<string> ConnectAsync(NodeInfo node)
-        {
-            if (node == null)
-                throw new ArgumentNullException(nameof(node));
-            return (await SendCommandAsync(new RPCRequest("connect", new object[] { node.NodeId, node.Host, node.Port })).ConfigureAwait(false)).ResultString;
-        }
-
-        public string Receive(LightMoney amount, string description = null)
-        {
-            return ReceiveAsync(amount, description).GetAwaiter().GetResult();
-        }
-
-        public async Task<string> ReceiveAsync(LightMoney amount, string description = null)
-        {
-            if (amount == null)
-                throw new ArgumentNullException(nameof(amount));
-            List<object> args = new List<object>();
-            args.Add(amount.MilliSatoshi);
-            if(description != null)
-            {
-                args.Add(description);
-            }
-            return (await SendCommandAsync(new RPCRequest("receive", args.ToArray())).ConfigureAwait(false)).ResultString;
-        }
-
-        public async Task<string> OpenAsync(NodeInfo node, Money fundingSatoshi, LightMoney pushAmount = null)
-        {
-            if (fundingSatoshi == null)
-                throw new ArgumentNullException(nameof(fundingSatoshi));
-            if (node == null)
-                throw new ArgumentNullException(nameof(node));
-            pushAmount = pushAmount ?? LightMoney.Zero;
-
-            var result = await SendCommandAsync(new RPCRequest("open", new object[] { node.NodeId, node.Host, node.Port, fundingSatoshi.Satoshi, pushAmount.MilliSatoshi }));
-
-            return result.ResultString;
-        }
-
-
-    }
-}

BTCPayServer/Eclair/GetInfoResponse.cs

@@ -1,18 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using NBitcoin;
-using Newtonsoft.Json;
-
-namespace BTCPayServer.Eclair
-{
-    public class GetInfoResponse
-    {
-        public string NodeId { get; set; }
-        public string Alias { get; set; }
-        public int Port { get; set; }
-        public uint256 ChainHash { get; set; }
-        public int BlockHeight { get; set; }
-    }
-}

BTCPayServer/EventAggregator.cs

@@ -4,6 +4,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using BTCPayServer.Logging;
+using System.Threading;
 
 namespace BTCPayServer
 {
@@ -18,7 +19,6 @@ namespace BTCPayServer
         {
             private EventAggregator aggregator;
             Type t;
-            Action<object> act;
             public Subscription(EventAggregator aggregator, Type t)
             {
                 this.aggregator = aggregator;
@@ -27,8 +27,12 @@ namespace BTCPayServer
 
             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))
@@ -52,21 +56,41 @@ namespace BTCPayServer
                 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(typeof(T), out Dictionary<Subscription, Action<object>> actions))
+                if (_Subscriptions.TryGetValue(evtType, out Dictionary<Subscription, Action<object>> actions))
                 {
                     actionList = actions.Values.ToList();
                 }
             }
 
-            Logs.Events.LogInformation($"New event: {evt.ToString()}");
+            var log = evt.ToString();
+            if(!String.IsNullOrEmpty(log))
+                Logs.Events.LogInformation(log);
             foreach (var sub in actionList)
             {
                 try

BTCPayServer/Events/InvoiceDataChangedEvent.cs

@@ -2,16 +2,32 @@
 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()
         {
-            return $"Invoice {InvoiceId} data changed";
+            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

@@ -2,15 +2,15 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using BTCPayServer.Services.Invoices;
 
 namespace BTCPayServer.Events
 {
-    public class InvoicePaymentEvent
+    public class InvoiceNeedUpdateEvent
     {
-        
-        public InvoicePaymentEvent(string invoiceId)
+        public InvoiceNeedUpdateEvent(string invoiceId)
         {
+            if (invoiceId == null)
+                throw new ArgumentNullException(nameof(invoiceId));
             InvoiceId = invoiceId;
         }
 
@@ -18,7 +18,7 @@ namespace BTCPayServer.Events
 
         public override string ToString()
         {
-            return $"Invoice {InvoiceId} received a payment";
+            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/InvoiceStatusChangedEvent.cs

@@ -1,30 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using BTCPayServer.Services.Invoices;
-
-namespace BTCPayServer.Events
-{
-    public class InvoiceStatusChangedEvent
-    {
-        public InvoiceStatusChangedEvent()
-        {
-
-        }
-        public InvoiceStatusChangedEvent(InvoiceEntity invoice, string newState)
-        {
-            OldState = invoice.Status;
-            InvoiceId = invoice.Id;
-            NewState = newState;
-        }
-        public string InvoiceId { get; set; }
-        public string OldState { get; set; }
-        public string NewState { get; set; }
-
-        public override string ToString()
-        {
-            return $"Invoice {InvoiceId} changed status: {OldState} => {NewState}";
-        }
-    }
-}

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

@@ -2,23 +2,41 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using BTCPayServer.HostedServices;
 
 namespace BTCPayServer.Events
 {
+    public class NBXplorerErrorEvent
+    {
+        public NBXplorerErrorEvent(BTCPayNetwork network, string errorMessage)
+        {
+            Message = errorMessage;
+            Network = network;
+        }
+        public string Message { get; set; }
+        public BTCPayNetwork Network { get; set; }
+
+        public override string ToString()
+        {
+            return $"{Network.CryptoCode}: NBXplorer error `{Message}`";
+        }
+    }
     public class NBXplorerStateChangedEvent
     {
-        public NBXplorerStateChangedEvent(NBXplorerState old, NBXplorerState newState)
+        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: {OldState} => {NewState}";
+            return $"NBXplorer {Network.CryptoCode}: {OldState} => {NewState}";
         }
     }
 }

BTCPayServer/Events/NewBlockEvent.cs

@@ -7,9 +7,10 @@ namespace BTCPayServer.Events
 {
     public class NewBlockEvent
     {
+        public string CryptoCode { get; set; }
         public override string ToString()
         {
-            return "New block";
+            return $"{CryptoCode}: New block";
         }
     }
 }

BTCPayServer/Events/TxOutReceivedEvent.cs

@@ -1,20 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using NBitcoin;
-
-namespace BTCPayServer.Events
-{
-    public class TxOutReceivedEvent
-    {
-        public Script ScriptPubKey { get; set; }
-        public BitcoinAddress Address { get; set; }
-
-        public override string ToString()
-        {
-            String address = Address?.ToString() ?? ScriptPubKey.ToHex();
-            return $"{address} received a transaction";
-        }
-    }
-}

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

@@ -17,12 +17,94 @@ 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 async Task<Dictionary<uint256, TransactionResult>> GetTransactions(this ExplorerClient client, uint256[] hashes, CancellationToken cts = default(CancellationToken))
+        public static string Prettify(this TimeSpan timeSpan)
+        {
+            if (timeSpan.TotalMinutes < 1)
+            {
+                return $"{(int)timeSpan.TotalSeconds} second{Plural((int)timeSpan.TotalSeconds)}";
+            }
+            if (timeSpan.TotalHours < 1)
+            {
+                return $"{(int)timeSpan.TotalMinutes} minute{Plural((int)timeSpan.TotalMinutes)}";
+            }
+            if (timeSpan.Days < 1)
+            {
+                return $"{(int)timeSpan.TotalHours} hour{Plural((int)timeSpan.TotalHours)}";
+            }
+            return $"{(int)timeSpan.TotalDays} day{Plural((int)timeSpan.TotalDays)}";
+        }
+
+        private static string Plural(int totalDays)
+        {
+            return totalDays > 1 ? "s" : string.Empty;
+        }
+
+        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 async Task<Dictionary<uint256, TransactionResult>> GetTransactions(this BTCPayWallet client, uint256[] hashes, CancellationToken cts = default(CancellationToken))
         {
             hashes = hashes.Distinct().ToArray();
             var transactions = hashes
@@ -33,7 +115,7 @@ namespace BTCPayServer
         }
         public static string WithTrailingSlash(this string str)
         {
-            if (str.EndsWith("/"))
+            if (str.EndsWith("/", StringComparison.InvariantCulture))
                 return str;
             return str + "/";
         }
@@ -47,6 +129,14 @@ namespace BTCPayServer
                         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 IServiceCollection ConfigureBTCPayServer(this IServiceCollection services, IConfiguration conf)
         {
             services.Configure<BTCPayServerOptions>(o =>
@@ -56,12 +146,52 @@ namespace BTCPayServer
             return services;
         }
 
-
-        public static BitIdentity GetBitIdentity(this Controller controller, bool throws = true)
+        public static string GetSIN(this ClaimsPrincipal principal)
         {
-            if (!(controller.User.Identity is BitIdentity))
-                return throws ? throw new UnauthorizedAccessException("no-bitid") : (BitIdentity)null;
-            return (BitIdentity)controller.User.Identity;
+            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() };
@@ -70,13 +200,5 @@ namespace BTCPayServer
             var res = JsonConvert.SerializeObject(o, Formatting.None, jsonSettings);
             return res;
         }
-
-        public static HtmlString ToJSVariableModel(this object o, string variableName)
-        {
-            var encodedJson = JavaScriptEncoder.Default.Encode(o.ToJson());
-            return new HtmlString($"var {variableName} = JSON.parse('" + encodedJson + "');");
-        }
-
-
     }
 }

BTCPayServer/Filters/OnlyMediaTypeAttribute.cs

@@ -43,9 +43,7 @@ namespace BTCPayServer.Filters
 
         public bool Accept(ActionConstraintContext context)
         {
-            var hasVersion = context.RouteContext.HttpContext.Request.Headers["x-accept-version"].Where(h => h == "2.0.0").Any();
-            var hasIdentity = context.RouteContext.HttpContext.Request.Headers["x-identity"].Any();
-            return (hasVersion || hasIdentity) == IsBitpayAPI;
+            return context.RouteContext.HttpContext.GetIsBitpayAPI() == IsBitpayAPI;
         }
     }
 

BTCPayServer/HostedServices/BaseAsyncService.cs

@@ -0,0 +1,66 @@
+using System;
+using Microsoft.Extensions.Logging;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Services;
+using BTCPayServer.Services.Rates;
+using Microsoft.Extensions.Hosting;
+using BTCPayServer.Logging;
+using System.Runtime.CompilerServices;
+using System.IO;
+using System.Text;
+
+namespace BTCPayServer.HostedServices
+{
+    public abstract class BaseAsyncService : IHostedService
+    {
+        private CancellationTokenSource _Cts;
+        protected Task[] _Tasks;
+
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            _Cts = new CancellationTokenSource();
+            _Tasks = InitializeTasks();
+            return Task.CompletedTask;
+        }
+
+        internal abstract Task[] InitializeTasks();
+
+        protected CancellationToken Cancellation
+        {
+            get { return _Cts.Token; }
+        }
+
+        protected async Task CreateLoopTask(Func<Task> act, [CallerMemberName]string caller = null)
+        {
+            await new SynchronizationContextRemover();
+            while (!_Cts.IsCancellationRequested)
+            {
+                try
+                {
+                    await act();
+                }
+                catch (OperationCanceledException) when (_Cts.IsCancellationRequested)
+                {
+                }
+                catch (Exception ex)
+                {
+                    Logs.PayServer.LogWarning(ex, caller + " failed");
+                    try
+                    {
+                        await Task.Delay(TimeSpan.FromMinutes(1), _Cts.Token);
+                    }
+                    catch (OperationCanceledException) when (_Cts.IsCancellationRequested) { }
+                }
+            }
+        }
+
+        public Task StopAsync(CancellationToken cancellationToken)
+        {
+            _Cts.Cancel();
+            return Task.WhenAll(_Tasks);
+        }
+    }
+}

BTCPayServer/HostedServices/CssThemeManager.cs

@@ -0,0 +1,74 @@
+using System;
+using Microsoft.Extensions.Logging;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Logging;
+using Microsoft.Extensions.Hosting;
+using NBXplorer;
+using NBXplorer.Models;
+using System.Collections.Concurrent;
+using BTCPayServer.Events;
+using BTCPayServer.Services;
+
+namespace BTCPayServer.HostedServices
+{
+    public class CssThemeManager
+    {
+        public void Update(ThemeSettings data)
+        {
+            if (String.IsNullOrWhiteSpace(data.BootstrapCssUri))
+                _bootstrapUri = "/vendor/bootstrap4/css/bootstrap.css?v=" + DateTime.Now.Ticks;
+            else
+                _bootstrapUri = data.BootstrapCssUri;
+
+
+            if (String.IsNullOrWhiteSpace(data.CreativeStartCssUri))
+                _creativeStartUri = "/vendor/bootstrap4-creativestart/creative.css?v=" + DateTime.Now.Ticks;
+            else
+                _creativeStartUri = data.CreativeStartCssUri;
+        }
+
+        private string _bootstrapUri;
+        public string BootstrapUri
+        {
+            get { return _bootstrapUri; }
+        }
+
+        private string _creativeStartUri;
+        public string CreativeStartUri
+        {
+            get { return _creativeStartUri; }
+        }
+    }
+
+    public class CssThemeManagerHostedService : BaseAsyncService
+    {
+        private SettingsRepository _SettingsRepository;
+        private CssThemeManager _CssThemeManager;
+
+        public CssThemeManagerHostedService(SettingsRepository settingsRepository, CssThemeManager cssThemeManager)
+        {
+            _SettingsRepository = settingsRepository;
+            _CssThemeManager = cssThemeManager;
+        }
+
+        internal override Task[] InitializeTasks()
+        {
+            return new[]
+            {
+                CreateLoopTask(ListenForThemeChanges)
+            };
+        }
+
+        async Task ListenForThemeChanges()
+        {
+            await new SynchronizationContextRemover();
+            var data = (await _SettingsRepository.GetSettingAsync<ThemeSettings>()) ?? new ThemeSettings();
+            _CssThemeManager.Update(data);
+
+            await _SettingsRepository.WaitSettingsChanged<ThemeSettings>(Cancellation);
+        }
+    }
+}

BTCPayServer/HostedServices/InvoiceNotificationManager.cs

@@ -0,0 +1,370 @@
+using Hangfire;
+using Hangfire.Common;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Hangfire.Annotations;
+using System.Reflection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+using System.Net.Http;
+using System.Text;
+using System.Threading;
+using NBitpayClient;
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json;
+using System.Collections.Concurrent;
+using Microsoft.Extensions.Hosting;
+using BTCPayServer.Events;
+using NBXplorer;
+using BTCPayServer.Services.Invoices;
+using BTCPayServer.Payments;
+
+namespace BTCPayServer.HostedServices
+{
+    public class InvoiceNotificationManager : IHostedService
+    {
+        public static HttpClient _Client = new HttpClient();
+
+        public class ScheduledJob
+        {
+            public int TryCount
+            {
+                get; set;
+            }
+
+            public InvoiceEntity Invoice
+            {
+                get; set;
+            }
+
+            public int? EventCode { get; set; }
+            public string Message { get; set; }
+        }
+
+        public ILogger Logger
+        {
+            get; set;
+        }
+
+        IBackgroundJobClient _JobClient;
+        EventAggregator _EventAggregator;
+        InvoiceRepository _InvoiceRepository;
+        BTCPayNetworkProvider _NetworkProvider;
+
+        public InvoiceNotificationManager(
+            IBackgroundJobClient jobClient,
+            EventAggregator eventAggregator,
+            InvoiceRepository invoiceRepository,
+            BTCPayNetworkProvider networkProvider,
+            ILogger<InvoiceNotificationManager> logger)
+        {
+            Logger = logger as ILogger ?? NullLogger.Instance;
+            _JobClient = jobClient;
+            _EventAggregator = eventAggregator;
+            _InvoiceRepository = invoiceRepository;
+            _NetworkProvider = networkProvider;
+        }
+
+        async Task Notify(InvoiceEntity invoice, int? eventCode = null, string name = null)
+        {
+            CancellationTokenSource cts = new CancellationTokenSource(10000);
+            try
+            {
+                if (string.IsNullOrEmpty(invoice.NotificationURL))
+                    return;
+                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(invoice.Id, eventCode, name));
+                var response = await SendNotification(invoice, eventCode, name, cts.Token);
+                response.EnsureSuccessStatusCode();
+                return;
+            }
+            catch (OperationCanceledException) when (cts.IsCancellationRequested)
+            {
+                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(invoice.Id, eventCode, name)
+                {
+                    Error = "Timeout"
+                });
+            }
+            catch (Exception ex) // It fails, it is OK because we try with hangfire after
+            {
+                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(invoice.Id, eventCode, name)
+                {
+                    Error = ex.Message
+                });
+            }
+            var invoiceStr = NBitcoin.JsonConverters.Serializer.ToString(new ScheduledJob() { TryCount = 0, Invoice = invoice, EventCode = eventCode, Message = name });
+            if (!string.IsNullOrEmpty(invoice.NotificationURL))
+                _JobClient.Schedule(() => NotifyHttp(invoiceStr), TimeSpan.Zero);
+        }
+
+        ConcurrentDictionary<string, string> _Executing = new ConcurrentDictionary<string, string>();
+        public async Task NotifyHttp(string invoiceData)
+        {
+            var job = NBitcoin.JsonConverters.Serializer.ToObject<ScheduledJob>(invoiceData);
+            var jobId = GetHttpJobId(job.Invoice);
+
+            if (!_Executing.TryAdd(jobId, jobId))
+                return; //For some reason, Hangfire fire the job several time
+
+            Logger.LogInformation("Running " + jobId);
+            bool reschedule = false;
+            CancellationTokenSource cts = new CancellationTokenSource(10000);
+            try
+            {
+                HttpResponseMessage response = await SendNotification(job.Invoice, job.EventCode, job.Message, cts.Token);
+                reschedule = !response.IsSuccessStatusCode;
+                Logger.LogInformation("Job " + jobId + " returned " + response.StatusCode);
+
+                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(job.Invoice.Id, job.EventCode, job.Message)
+                {
+                    Error = reschedule ? $"Unexpected return code: {(int)response.StatusCode}" : null
+                });
+            }
+            catch (OperationCanceledException) when (cts.IsCancellationRequested)
+            {
+                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(job.Invoice.Id, job.EventCode, job.Message)
+                {
+                    Error = "Timeout"
+                });
+                reschedule = true;
+                Logger.LogInformation("Job " + jobId + " timed out");
+            }
+            catch (Exception ex) // It fails, it is OK because we try with hangfire after
+            {
+                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(job.Invoice.Id, job.EventCode, job.Message)
+                {
+                    Error = ex.Message
+                });
+                reschedule = true;
+
+                List<string> messages = new List<string>();
+                while (ex != null)
+                {
+                    messages.Add(ex.Message);
+                    ex = ex.InnerException;
+                }
+                string message = String.Join(',', messages.ToArray());
+                Logger.LogInformation("Job " + jobId + " threw exception " + message);
+
+                _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(job.Invoice.Id, job.EventCode, job.Message)
+                {
+                    Error = $"Unexpected error: {message}"
+                });
+            }
+            finally { cts.Dispose(); _Executing.TryRemove(jobId, out jobId); }
+
+            job.TryCount++;
+
+            if (job.TryCount < MaxTry && reschedule)
+            {
+                Logger.LogInformation("Rescheduling " + jobId + " in 10 minutes, remaining try " + (MaxTry - job.TryCount));
+
+                invoiceData = NBitcoin.JsonConverters.Serializer.ToString(job);
+                _JobClient.Schedule(() => NotifyHttp(invoiceData), TimeSpan.FromMinutes(10.0));
+            }
+        }
+
+        public class InvoicePaymentNotificationEvent
+        {
+            [JsonProperty("code")]
+            public int Code { get; set; }
+            [JsonProperty("name")]
+            public string Name { get; set; }
+        }
+        public class InvoicePaymentNotificationEventWrapper
+        {
+            [JsonProperty("event")]
+            public InvoicePaymentNotificationEvent Event { get; set; }
+            [JsonProperty("data")]
+            public InvoicePaymentNotification Data { get; set; }
+        }
+
+        Encoding UTF8 = new UTF8Encoding(false);
+        private async Task<HttpResponseMessage> SendNotification(InvoiceEntity invoice, int? eventCode, string name, CancellationToken cancellation)
+        {
+            var request = new HttpRequestMessage();
+            request.Method = HttpMethod.Post;
+
+            var dto = invoice.EntityToDTO(_NetworkProvider);
+            InvoicePaymentNotification notification = new InvoicePaymentNotification()
+            {
+                Id = dto.Id,
+                Currency = dto.Currency,
+                CurrentTime = dto.CurrentTime,
+                ExceptionStatus = dto.ExceptionStatus,
+                ExpirationTime = dto.ExpirationTime,
+                InvoiceTime = dto.InvoiceTime,
+                PosData = dto.PosData,
+                Price = dto.Price,
+                Status = dto.Status,
+                BuyerFields = invoice.RefundMail == null ? null : new Newtonsoft.Json.Linq.JObject() { new JProperty("buyerEmail", invoice.RefundMail) }
+            };
+
+            // We keep backward compatibility with bitpay by passing BTC info to the notification
+            // we don't pass other info, as it is a bad idea to use IPN data for logic processing (can be faked)
+            var btcCryptoInfo = dto.CryptoInfo.FirstOrDefault(c => c.GetpaymentMethodId() == new PaymentMethodId("BTC", Payments.PaymentTypes.BTCLike));
+            if (btcCryptoInfo != null)
+            {
+#pragma warning disable CS0618
+                notification.Rate = (double)dto.Rate;
+                notification.Url = dto.Url;
+                notification.BTCDue = dto.BTCDue;
+                notification.BTCPaid = dto.BTCPaid;
+                notification.BTCPrice = dto.BTCPrice;
+#pragma warning restore CS0618
+            }
+
+            string notificationString = null;
+            if (eventCode.HasValue)
+            {
+                var wrapper = new InvoicePaymentNotificationEventWrapper();
+                wrapper.Data = notification;
+                wrapper.Event = new InvoicePaymentNotificationEvent() { Code = eventCode.Value, Name = name };
+                notificationString = JsonConvert.SerializeObject(wrapper);
+            }
+            else
+            {
+                notificationString = JsonConvert.SerializeObject(notification);
+            }
+
+            request.RequestUri = new Uri(invoice.NotificationURL, UriKind.Absolute);
+            request.Content = new StringContent(notificationString, UTF8, "application/json");
+            var response = await Enqueue(invoice.Id, async () => await _Client.SendAsync(request, cancellation));
+            return response;
+        }
+
+        Dictionary<string, Task> _SendingRequestsByInvoiceId = new Dictionary<string, Task>();
+
+
+        /// <summary>
+        /// Will make sure only one callback is called at once on the same invoiceId
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="sendRequest"></param>
+        /// <returns></returns>
+        private async Task<T> Enqueue<T>(string id, Func<Task<T>> sendRequest)
+        {
+            Task<T> sending = null;
+            lock (_SendingRequestsByInvoiceId)
+            {
+                if (_SendingRequestsByInvoiceId.TryGetValue(id, out var executing))
+                {
+                    var completion = new TaskCompletionSource<T>();
+                    sending = completion.Task;
+                    _SendingRequestsByInvoiceId.Remove(id);
+                    _SendingRequestsByInvoiceId.Add(id, sending);
+                    executing.ContinueWith(_ =>
+                    {
+                        sendRequest()
+                            .ContinueWith(t =>
+                            {
+                                if(t.Status == TaskStatus.RanToCompletion)
+                                { 
+                                    completion.TrySetResult(t.Result);
+                                }
+                                if(t.Status == TaskStatus.Faulted)
+                                {
+                                    completion.TrySetException(t.Exception);
+                                }
+                                if(t.Status == TaskStatus.Canceled)
+                                {
+                                    completion.TrySetCanceled();
+                                }
+                            }, TaskScheduler.Default);
+                    }, TaskScheduler.Default);
+                }
+                else
+                {
+                    sending = sendRequest();
+                    _SendingRequestsByInvoiceId.Add(id, sending);
+                }
+                sending.ContinueWith(o =>
+                {
+                    lock (_SendingRequestsByInvoiceId)
+                    {
+                        _SendingRequestsByInvoiceId.TryGetValue(id, out var executing2);
+                        if(executing2 == sending)
+                            _SendingRequestsByInvoiceId.Remove(id);
+                    }
+                }, TaskScheduler.Default);
+            }
+            return await sending;
+        }
+
+        int MaxTry = 6;
+
+        private static string GetHttpJobId(InvoiceEntity invoice)
+        {
+            return $"{invoice.Id}-{invoice.Status}-HTTP";
+        }
+
+        CompositeDisposable leases = new CompositeDisposable();
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            leases.Add(_EventAggregator.Subscribe<InvoiceEvent>(async e =>
+            {
+                var invoice = await _InvoiceRepository.GetInvoice(null, e.InvoiceId);
+                List<Task> tasks = new List<Task>();
+
+                // Awaiting this later help make sure invoices should arrive in order
+                tasks.Add(SaveEvent(invoice.Id, e));
+
+                // we need to use the status in the event and not in the invoice. The invoice might now be in another status.
+                if (invoice.FullNotifications)
+                {
+                    if (e.Name == "invoice_expired" ||
+                       e.Name == "invoice_paidInFull" ||
+                       e.Name == "invoice_failedToConfirm" ||
+                       e.Name == "invoice_markedInvalid" ||
+                       e.Name == "invoice_failedToConfirm" ||
+                       e.Name == "invoice_completed" ||
+                       e.Name == "invoice_expiredPaidPartial"
+                     )
+                        tasks.Add(Notify(invoice));
+                }
+
+                if (e.Name == "invoice_confirmed")
+                {
+                    tasks.Add(Notify(invoice));
+                }
+
+                if (invoice.ExtendedNotifications)
+                {
+                    tasks.Add(Notify(invoice, e.EventCode, e.Name));
+                }
+                await Task.WhenAll(tasks.ToArray());
+            }));
+
+
+            leases.Add(_EventAggregator.Subscribe<InvoiceDataChangedEvent>(async e =>
+            {
+                await SaveEvent(e.InvoiceId, e);
+            }));
+
+
+            leases.Add(_EventAggregator.Subscribe<InvoiceStopWatchedEvent>(async e =>
+            {
+                await SaveEvent(e.InvoiceId, e);
+            }));
+
+            leases.Add(_EventAggregator.Subscribe<InvoiceIPNEvent>(async e =>
+            {
+                await SaveEvent(e.InvoiceId, e);
+            }));
+
+            return Task.CompletedTask;
+        }
+
+        private Task SaveEvent(string invoiceId, object evt)
+        {
+            return _InvoiceRepository.AddInvoiceEvent(invoiceId, evt);
+        }
+
+        public Task StopAsync(CancellationToken cancellationToken)
+        {
+            leases.Dispose();
+            return Task.CompletedTask;
+        }
+    }
+}

BTCPayServer/HostedServices/InvoiceWatcher.cs

@@ -0,0 +1,343 @@
+using NBXplorer;
+using Microsoft.Extensions.Logging;
+using NBXplorer.DerivationStrategy;
+using NBXplorer.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+using BTCPayServer.Logging;
+using System.Threading;
+using Microsoft.Extensions.Hosting;
+using System.Collections.Concurrent;
+using Hangfire;
+using BTCPayServer.Services.Wallets;
+using BTCPayServer.Controllers;
+using BTCPayServer.Events;
+using Microsoft.AspNetCore.Hosting;
+using BTCPayServer.Services.Invoices;
+using BTCPayServer.Services;
+
+namespace BTCPayServer.HostedServices
+{
+    public class InvoiceWatcher : IHostedService
+    {
+        class UpdateInvoiceContext
+        {
+            public UpdateInvoiceContext(InvoiceEntity invoice)
+            {
+                Invoice = invoice;
+            }
+            public InvoiceEntity Invoice { get; set; }
+            public List<object> Events { get; set; } = new List<object>();
+
+            bool _Dirty = false;
+            public void MarkDirty()
+            {
+                _Dirty = true;
+            }
+
+            public bool Dirty => _Dirty;
+        }
+
+        InvoiceRepository _InvoiceRepository;
+        EventAggregator _EventAggregator;
+        BTCPayNetworkProvider _NetworkProvider;
+
+        public InvoiceWatcher(
+            BTCPayNetworkProvider networkProvider,
+            InvoiceRepository invoiceRepository,
+            EventAggregator eventAggregator)
+        {
+            PollInterval = TimeSpan.FromMinutes(1.0);
+            _InvoiceRepository = invoiceRepository ?? throw new ArgumentNullException(nameof(invoiceRepository));
+            _EventAggregator = eventAggregator ?? throw new ArgumentNullException(nameof(eventAggregator));
+            _NetworkProvider = networkProvider;
+        }
+        CompositeDisposable leases = new CompositeDisposable();
+
+
+        private async Task UpdateInvoice(UpdateInvoiceContext context)
+        {
+            var invoice = context.Invoice;
+            if (invoice.Status == "new" && invoice.ExpirationTime < DateTimeOffset.UtcNow)
+            {
+                context.MarkDirty();
+                await _InvoiceRepository.UnaffectAddress(invoice.Id);
+
+                context.Events.Add(new InvoiceEvent(invoice, 1004, "invoice_expired"));
+                invoice.Status = "expired";
+                if(invoice.ExceptionStatus == "paidPartial")
+                    context.Events.Add(new InvoiceEvent(invoice, 2000, "invoice_expiredPaidPartial"));
+            }
+
+            var payments = invoice.GetPayments().Where(p => p.Accounted).ToArray();
+            var allPaymentMethods = invoice.GetPaymentMethods(_NetworkProvider);
+            var paymentMethod = GetNearestClearedPayment(allPaymentMethods, out var accounting, _NetworkProvider);
+            if (paymentMethod == null)
+                return;
+            var network = _NetworkProvider.GetNetwork(paymentMethod.GetId().CryptoCode);
+            if (invoice.Status == "new" || invoice.Status == "expired")
+            {
+                if (accounting.Paid >= accounting.MinimumTotalDue)
+                {
+                    if (invoice.Status == "new")
+                    {
+                        context.Events.Add(new InvoiceEvent(invoice, 1003, "invoice_paidInFull"));
+                        invoice.Status = "paid";
+                        invoice.ExceptionStatus = accounting.Paid > accounting.TotalDue ? "paidOver" : null;
+                        await _InvoiceRepository.UnaffectAddress(invoice.Id);
+                        context.MarkDirty();
+                    }
+                    else if (invoice.Status == "expired" && invoice.ExceptionStatus != "paidLate")
+                    {
+                        invoice.ExceptionStatus = "paidLate";
+                        context.Events.Add(new InvoiceEvent(invoice, 1009, "invoice_paidAfterExpiration"));
+                        context.MarkDirty();
+                    }
+                }
+
+                if (accounting.Paid < accounting.MinimumTotalDue && invoice.GetPayments().Count != 0 && invoice.ExceptionStatus != "paidPartial")
+                {
+                        invoice.ExceptionStatus = "paidPartial";
+                        context.MarkDirty();
+                }
+            }
+
+            // Just make sure RBF did not cancelled a payment
+            if (invoice.Status == "paid")
+            {
+                if (accounting.MinimumTotalDue <= accounting.Paid && accounting.Paid <= accounting.TotalDue && invoice.ExceptionStatus == "paidOver")
+                {
+                    invoice.ExceptionStatus = null;
+                    context.MarkDirty();
+                }
+
+                if (accounting.Paid > accounting.TotalDue && invoice.ExceptionStatus != "paidOver")
+                {
+                    invoice.ExceptionStatus = "paidOver";
+                    context.MarkDirty();
+                }
+
+                if (accounting.Paid < accounting.MinimumTotalDue)
+                {
+                    invoice.Status = "new";
+                    invoice.ExceptionStatus = accounting.Paid == Money.Zero ? null : "paidPartial";
+                    context.MarkDirty();
+                }
+            }
+
+            if (invoice.Status == "paid")
+            {
+                var confirmedAccounting = paymentMethod.Calculate(p => p.GetCryptoPaymentData().PaymentConfirmed(p, invoice.SpeedPolicy, network));
+
+                if (// Is after the monitoring deadline
+                   (invoice.MonitoringExpiration < DateTimeOffset.UtcNow)
+                   &&
+                   // And not enough amount confirmed
+                   (confirmedAccounting.Paid < accounting.MinimumTotalDue))
+                {
+                    await _InvoiceRepository.UnaffectAddress(invoice.Id);
+                    context.Events.Add(new InvoiceEvent(invoice, 1013, "invoice_failedToConfirm"));
+                    invoice.Status = "invalid";
+                    context.MarkDirty();
+                }
+                else if (confirmedAccounting.Paid >= accounting.MinimumTotalDue)
+                {
+                    await _InvoiceRepository.UnaffectAddress(invoice.Id);
+                    context.Events.Add(new InvoiceEvent(invoice, 1005, "invoice_confirmed"));
+                    invoice.Status = "confirmed";
+                    context.MarkDirty();
+                }
+            }
+
+            if (invoice.Status == "confirmed")
+            {
+                var completedAccounting = paymentMethod.Calculate(p => p.GetCryptoPaymentData().PaymentCompleted(p, network));
+                if (completedAccounting.Paid >= accounting.MinimumTotalDue)
+                {
+                    context.Events.Add(new InvoiceEvent(invoice, 1006, "invoice_completed"));
+                    invoice.Status = "complete";
+                    context.MarkDirty();
+                }
+            }
+
+        }
+
+        public static PaymentMethod GetNearestClearedPayment(PaymentMethodDictionary allPaymentMethods, out PaymentMethodAccounting accounting, BTCPayNetworkProvider networkProvider)
+        {
+            PaymentMethod result = null;
+            accounting = null;
+            decimal nearestToZero = 0.0m;
+            foreach (var paymentMethod in allPaymentMethods)
+            {
+                if (networkProvider != null && networkProvider.GetNetwork(paymentMethod.GetId().CryptoCode) == null)
+                    continue;
+                var currentAccounting = paymentMethod.Calculate();
+                var distanceFromZero = Math.Abs(currentAccounting.DueUncapped.ToDecimal(MoneyUnit.BTC));
+                if (result == null || distanceFromZero < nearestToZero)
+                {
+                    result = paymentMethod;
+                    nearestToZero = distanceFromZero;
+                    accounting = currentAccounting;
+                }
+            }
+            return result;
+        }
+
+        TimeSpan _PollInterval;
+        public TimeSpan PollInterval
+        {
+            get
+            {
+                return _PollInterval;
+            }
+            set
+            {
+                _PollInterval = value;
+            }
+        }
+
+        private void Watch(string invoiceId)
+        {
+            if (invoiceId == null)
+                throw new ArgumentNullException(nameof(invoiceId));
+            _WatchRequests.Add(invoiceId);
+        }
+
+        private async Task Wait(string invoiceId)
+        {
+            var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId);
+            try
+            {
+                var delay = invoice.ExpirationTime - DateTimeOffset.UtcNow;
+                if (delay > TimeSpan.Zero)
+                {
+                    await Task.Delay(delay, _Cts.Token);
+                }
+                Watch(invoiceId);
+                delay = invoice.MonitoringExpiration - DateTimeOffset.UtcNow;
+                if (delay > TimeSpan.Zero)
+                {
+                    await Task.Delay(delay, _Cts.Token);
+                }
+                Watch(invoiceId);
+            }
+            catch when (_Cts.IsCancellationRequested)
+            { }
+
+        }
+
+        BlockingCollection<string> _WatchRequests = new BlockingCollection<string>(new ConcurrentQueue<string>());
+
+        Task _Loop;
+        Task _WaitingInvoices;
+        CancellationTokenSource _Cts;
+
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            _Cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+            _Loop = StartLoop(_Cts.Token);
+            _WaitingInvoices = WaitPendingInvoices();
+
+            leases.Add(_EventAggregator.Subscribe<Events.InvoiceNeedUpdateEvent>(b =>
+            {
+                Watch(b.InvoiceId);
+            }));
+            leases.Add(_EventAggregator.Subscribe<Events.InvoiceEvent>(async b =>
+            {
+                if (b.Name == "invoice_created")
+                {
+                    Watch(b.InvoiceId);
+                    await Wait(b.InvoiceId);
+                }
+
+                if (b.Name == "invoice_receivedPayment")
+                {
+                    Watch(b.InvoiceId);
+                }
+            }));
+            return Task.CompletedTask;
+        }
+
+        private async Task WaitPendingInvoices()
+        {
+            await Task.WhenAll((await _InvoiceRepository.GetPendingInvoices())
+                .Select(id => Wait(id)).ToArray());
+            _WaitingInvoices = null;
+        }
+
+        async Task StartLoop(CancellationToken cancellation)
+        {
+            Logs.PayServer.LogInformation("Start watching invoices");
+            await Task.Delay(1).ConfigureAwait(false); // Small hack so that the caller does not block on GetConsumingEnumerable
+            try
+            {
+                foreach (var invoiceId in _WatchRequests.GetConsumingEnumerable(cancellation))
+                {
+                    int maxLoop = 5;
+                    int loopCount = -1;
+                    while (!cancellation.IsCancellationRequested && loopCount < maxLoop)
+                    {
+                        loopCount++;
+                        try
+                        {
+                            var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId, true);
+                            if (invoice == null)
+                                break;
+                            var updateContext = new UpdateInvoiceContext(invoice);
+                            await UpdateInvoice(updateContext);
+                            if (updateContext.Dirty)
+                            {
+                                await _InvoiceRepository.UpdateInvoiceStatus(invoice.Id, invoice.Status, invoice.ExceptionStatus);
+                                updateContext.Events.Add(new InvoiceDataChangedEvent(invoice));
+                            }
+
+                            foreach (var evt in updateContext.Events)
+                            {
+                                _EventAggregator.Publish(evt, evt.GetType());
+                            }
+
+                            if (invoice.Status == "complete" ||
+                               ((invoice.Status == "invalid" || invoice.Status == "expired") && invoice.MonitoringExpiration < DateTimeOffset.UtcNow))
+                            {
+                                if (await _InvoiceRepository.RemovePendingInvoice(invoice.Id))
+                                    _EventAggregator.Publish(new InvoiceStopWatchedEvent(invoice.Id));
+                                break;
+                            }
+
+                            if (updateContext.Events.Count == 0 || cancellation.IsCancellationRequested)
+                                break;
+                        }
+                        catch (OperationCanceledException) when (cancellation.IsCancellationRequested)
+                        {
+                            break;
+                        }
+                        catch (Exception ex)
+                        {
+                            Logs.PayServer.LogError(ex, "Unhandled error on watching invoice " + invoiceId);
+#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+                            Task.Delay(10000, cancellation)
+                                .ContinueWith(t => _WatchRequests.Add(invoiceId), TaskScheduler.Default);
+#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+                            break;
+                        }
+                    }
+                }
+            }
+            catch when (cancellation.IsCancellationRequested)
+            {
+            }
+            Logs.PayServer.LogInformation("Stop watching invoices");
+        }
+
+        public Task StopAsync(CancellationToken cancellationToken)
+        {
+            leases.Dispose();
+            _Cts.Cancel();
+            var waitingPendingInvoices = _WaitingInvoices ?? Task.CompletedTask;
+            return Task.WhenAll(waitingPendingInvoices, _Loop);
+        }
+    }
+}

BTCPayServer/HostedServices/NBXplorerWaiter.cs

@@ -0,0 +1,224 @@
+using System;
+using Microsoft.Extensions.Logging;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Logging;
+using Microsoft.Extensions.Hosting;
+using NBXplorer;
+using NBXplorer.Models;
+using System.Collections.Concurrent;
+using BTCPayServer.Events;
+
+namespace BTCPayServer.HostedServices
+{
+    public enum NBXplorerState
+    {
+        NotConnected,
+        Synching,
+        Ready
+    }
+
+    public class NBXplorerDashboard
+    {
+        public class NBXplorerSummary
+        {
+            public BTCPayNetwork Network { get; set; }
+            public NBXplorerState State { get; set; }
+            public StatusResult Status { get; set; }
+            public string Error { get; set; }
+        }
+        ConcurrentDictionary<string, NBXplorerSummary> _Summaries = new ConcurrentDictionary<string, NBXplorerSummary>();
+        public void Publish(BTCPayNetwork network, NBXplorerState state, StatusResult status, string error)
+        {
+            var summary = new NBXplorerSummary() { Network = network, State = state, Status = status, Error = error };
+            _Summaries.AddOrUpdate(network.CryptoCode, summary, (k, v) => summary);
+        }
+
+        public bool IsFullySynched()
+        {
+            return _Summaries.All(s => s.Value.Status != null && s.Value.Status.IsFullySynched);
+        }
+
+        public bool IsFullySynched(string cryptoCode, out NBXplorerSummary summary)
+        {
+            return _Summaries.TryGetValue(cryptoCode, out summary) && 
+                   summary.Status != null && 
+                   summary.Status.IsFullySynched;
+        }
+
+        public IEnumerable<NBXplorerSummary> GetAll()
+        {
+            return _Summaries.Values;
+        }
+    }
+
+    public class NBXplorerWaiters : IHostedService
+    {
+        List<NBXplorerWaiter> _Waiters = new List<NBXplorerWaiter>();
+        public NBXplorerWaiters(NBXplorerDashboard dashboard, ExplorerClientProvider explorerClientProvider, EventAggregator eventAggregator)
+        {
+            foreach (var explorer in explorerClientProvider.GetAll())
+            {
+                _Waiters.Add(new NBXplorerWaiter(dashboard, explorer.Item1, explorer.Item2, eventAggregator));
+            }
+        }
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            return Task.WhenAll(_Waiters.Select(w => w.StartAsync(cancellationToken)).ToArray());
+        }
+
+        public Task StopAsync(CancellationToken cancellationToken)
+        {
+            return Task.WhenAll(_Waiters.Select(w => w.StopAsync(cancellationToken)).ToArray());
+        }
+    }
+
+    public class NBXplorerWaiter : IHostedService
+    {
+
+        public NBXplorerWaiter(NBXplorerDashboard dashboard, BTCPayNetwork network, ExplorerClient client, EventAggregator aggregator)
+        {
+            _Network = network;
+            _Client = client;
+            _Aggregator = aggregator;
+            _Dashboard = dashboard;
+        }
+
+        NBXplorerDashboard _Dashboard;
+        BTCPayNetwork _Network;
+        EventAggregator _Aggregator;
+        ExplorerClient _Client;
+
+        CancellationTokenSource _Cts;
+        Task _Loop;
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            _Cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+            _Loop = StartLoop(_Cts.Token);
+            return Task.CompletedTask;
+        }
+
+        private async Task StartLoop(CancellationToken cancellation)
+        {
+            Logs.PayServer.LogInformation($"Starting listening NBXplorer ({_Network.CryptoCode})");
+            try
+            {
+                while (!cancellation.IsCancellationRequested)
+                {
+                    try
+                    {
+                        while (await StepAsync(cancellation))
+                        {
+
+                        }
+                        await Task.Delay(PollInterval, cancellation);
+                    }
+                    catch (Exception ex) when (!cancellation.IsCancellationRequested)
+                    {
+                        Logs.PayServer.LogError(ex, $"Unhandled exception in NBXplorerWaiter ({_Network.CryptoCode})");
+                        await Task.Delay(TimeSpan.FromSeconds(10), cancellation);
+                    }
+                }
+            }
+            catch when (cancellation.IsCancellationRequested) { }
+        }
+
+        private async Task<bool> StepAsync(CancellationToken cancellation)
+        {
+            var oldState = State;
+            string error = null;
+            StatusResult status = null;
+            try
+            {
+                switch (State)
+                {
+                    case NBXplorerState.NotConnected:
+                        status = await _Client.GetStatusAsync(cancellation);
+                        if (status != null)
+                        {
+                            if (status.IsFullySynched)
+                            {
+                                State = NBXplorerState.Ready;
+                            }
+                            else
+                            {
+                                State = NBXplorerState.Synching;
+                            }
+                        }
+                        break;
+                    case NBXplorerState.Synching:
+                        status = await _Client.GetStatusAsync(cancellation);
+                        if (status == null)
+                        {
+                            State = NBXplorerState.NotConnected;
+                        }
+                        else if (status.IsFullySynched)
+                        {
+                            State = NBXplorerState.Ready;
+                        }
+                        break;
+                    case NBXplorerState.Ready:
+                        status = await _Client.GetStatusAsync(cancellation);
+                        if (status == null)
+                        {
+                            State = NBXplorerState.NotConnected;
+                        }
+                        else if (!status.IsFullySynched)
+                        {
+                            State = NBXplorerState.Synching;
+                        }
+                        break;
+                }
+
+            }
+            catch (Exception ex) when (!cancellation.IsCancellationRequested)
+            {
+                error = ex.Message;
+            }
+
+
+            if(status == null && error == null)
+                error = $"{_Network.CryptoCode}: NBXplorer does not support this cryptocurrency";
+
+            if(status != null && error == null)
+            {
+                if(status.NetworkType != _Network.NBitcoinNetwork.NetworkType)
+                    error = $"{_Network.CryptoCode}: NBXplorer is on a different ChainType (actual: {status.NetworkType}, expected: {_Network.NBitcoinNetwork.NetworkType})";
+            }
+
+            if (error != null)
+            {
+                State = NBXplorerState.NotConnected;
+                status = null;
+                _Aggregator.Publish(new NBXplorerErrorEvent(_Network, error));
+            }
+
+            _Dashboard.Publish(_Network, State, status, error);
+            if (oldState != State)
+            {
+                if (State == NBXplorerState.Synching)
+                {
+                    PollInterval = TimeSpan.FromSeconds(10);
+                }
+                else
+                {
+                    PollInterval = TimeSpan.FromMinutes(1);
+                }
+                _Aggregator.Publish(new NBXplorerStateChangedEvent(_Network, oldState, State));
+            }
+            return oldState != State;
+        }
+
+        public TimeSpan PollInterval { get; set; } = TimeSpan.FromMinutes(1.0);
+
+        public NBXplorerState State { get; private set; }
+
+        public Task StopAsync(CancellationToken cancellationToken)
+        {
+            _Cts.Cancel();
+            return _Loop;
+        }
+    }
+}

BTCPayServer/HostedServices/RatesHostedService.cs

@@ -0,0 +1,71 @@
+using System;
+using Microsoft.Extensions.Logging;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Services;
+using BTCPayServer.Services.Rates;
+using Microsoft.Extensions.Hosting;
+using BTCPayServer.Logging;
+using System.Runtime.CompilerServices;
+using System.IO;
+using System.Text;
+
+namespace BTCPayServer.HostedServices
+{
+    public class RatesHostedService : BaseAsyncService
+    {
+        private SettingsRepository _SettingsRepository;
+        private CoinAverageSettings _coinAverageSettings;
+        BTCPayRateProviderFactory _RateProviderFactory;
+        public RatesHostedService(SettingsRepository repo,
+                                  BTCPayRateProviderFactory rateProviderFactory,
+                                  CoinAverageSettings coinAverageSettings)
+        {
+            this._SettingsRepository = repo;
+            _coinAverageSettings = coinAverageSettings;
+            _RateProviderFactory = rateProviderFactory;
+        }
+
+        internal override Task[] InitializeTasks()
+        {
+            return new[]
+            {
+                CreateLoopTask(RefreshCoinAverageSupportedExchanges),
+                CreateLoopTask(RefreshCoinAverageSettings)
+            };
+        }
+
+        async Task RefreshCoinAverageSupportedExchanges()
+        {
+            await new SynchronizationContextRemover();
+            var tickers = await new CoinAverageRateProvider() { Authenticator = _coinAverageSettings }.GetExchangeTickersAsync();
+            var exchanges = new CoinAverageExchanges();
+            foreach(var item in tickers
+                .Exchanges
+                .Select(c => new CoinAverageExchange(c.Name, c.DisplayName)))
+            {
+                exchanges.Add(item);
+            }
+            _coinAverageSettings.AvailableExchanges = exchanges;
+            await Task.Delay(TimeSpan.FromHours(5), Cancellation);
+        }
+
+        async Task RefreshCoinAverageSettings()
+        {
+            await new SynchronizationContextRemover();
+            var rates = (await _SettingsRepository.GetSettingAsync<RatesSetting>()) ?? new RatesSetting();
+            _RateProviderFactory.CacheSpan = TimeSpan.FromMinutes(rates.CacheInMinutes);
+            if (!string.IsNullOrWhiteSpace(rates.PrivateKey) && !string.IsNullOrWhiteSpace(rates.PublicKey))
+            {
+                _coinAverageSettings.KeyPair = (rates.PublicKey, rates.PrivateKey);
+            }
+            else
+            {
+                _coinAverageSettings.KeyPair = null;
+            }
+            await _SettingsRepository.WaitSettingsChanged<RatesSetting>(Cancellation);
+        }
+    }
+}

BTCPayServer/Hosting/BTCPayServerServices.cs

@@ -36,55 +36,15 @@ using BTCPayServer.Services.Wallets;
 using BTCPayServer.Authentication;
 using Microsoft.Extensions.Caching.Memory;
 using BTCPayServer.Logging;
+using BTCPayServer.HostedServices;
+using Meziantou.AspNetCore.BundleTagHelpers;
+using System.Security.Claims;
+using BTCPayServer.Security;
 
 namespace BTCPayServer.Hosting
 {
     public static class BTCPayServerServices
     {
-        public class OwnStoreAuthorizationRequirement : IAuthorizationRequirement
-        {
-            public OwnStoreAuthorizationRequirement()
-            {
-            }
-
-            public OwnStoreAuthorizationRequirement(string role)
-            {
-                Role = role;
-            }
-
-            public string Role
-            {
-                get; set;
-            }
-        }
-
-        public class OwnStoreHandler : AuthorizationHandler<OwnStoreAuthorizationRequirement>
-        {
-            StoreRepository _StoreRepository;
-            UserManager<ApplicationUser> _UserManager;
-            public OwnStoreHandler(StoreRepository storeRepository, UserManager<ApplicationUser> userManager)
-            {
-                _StoreRepository = storeRepository;
-                _UserManager = userManager;
-            }
-            protected override async Task HandleRequirementAsync(AuthorizationHandlerContext context, OwnStoreAuthorizationRequirement requirement)
-            {
-                object storeId = null;
-                if (!((Microsoft.AspNetCore.Mvc.ActionContext)context.Resource).RouteData.Values.TryGetValue("storeId", out storeId))
-                    context.Succeed(requirement);
-                else if (storeId != null)
-                {
-                    var user = _UserManager.GetUserId(((Microsoft.AspNetCore.Mvc.ActionContext)context.Resource).HttpContext.User);
-                    if (user != null)
-                    {
-                        var store = await _StoreRepository.FindStore((string)storeId, user);
-                        if (store != null)
-                            if (requirement.Role == null || requirement.Role == store.Role)
-                                context.Succeed(requirement);
-                    }
-                }
-            }
-        }
         public static IServiceCollection AddBTCPayServer(this IServiceCollection services)
         {
             services.AddDbContext<ApplicationDbContext>((provider, o) =>
@@ -102,12 +62,12 @@ namespace BTCPayServer.Hosting
                 var dbpath = Path.Combine(opts.DataDir, "InvoiceDB");
                 if (!Directory.Exists(dbpath))
                     Directory.CreateDirectory(dbpath);
-                return new InvoiceRepository(dbContext, dbpath, opts.Network);
+                return new InvoiceRepository(dbContext, dbpath);
             });
             services.AddSingleton<BTCPayServerEnvironment>();
             services.TryAddSingleton<TokenRepository>();
             services.TryAddSingleton<EventAggregator>();
-            services.TryAddSingleton<Network>(o => o.GetRequiredService<BTCPayServerOptions>().Network);
+            services.TryAddSingleton<CoinAverageSettings>();
             services.TryAddSingleton<ApplicationDbContextFactory>(o => 
             {
                 var opts = o.GetRequiredService<BTCPayServerOptions>();
@@ -125,64 +85,68 @@ namespace BTCPayServer.Hosting
                 }
                 return dbContext;
             });
-            services.TryAddSingleton<StoreRepository>();
-            services.TryAddSingleton<BTCPayWallet>();
-            services.TryAddSingleton<CurrencyNameTable>();
-            services.TryAddSingleton<IFeeProvider>(o => new NBXplorerFeeProvider()
-            {
-                Fallback = new FeeRate(100, 1),
-                BlockTarget = 20,
-                ExplorerClient = o.GetRequiredService<ExplorerClient>()
-            });
+            services.TryAddSingleton<Payments.Lightning.LightningClientFactory>();
 
-            services.TryAddSingleton<NBXplorerWaiterAccessor>();
-            services.AddSingleton<IHostedService, NBXplorerWaiter>();
-            services.TryAddSingleton<ExplorerClient>(o =>
+            services.TryAddSingleton<BTCPayNetworkProvider>(o => 
             {
                 var opts = o.GetRequiredService<BTCPayServerOptions>();
-                var explorer = new ExplorerClient(opts.Network, opts.Explorer);
-                if (!explorer.SetCookieAuth(opts.CookieFile))
-                    explorer.SetNoAuth();
-                return explorer;
+                return opts.NetworkProvider;
             });
+
+            services.TryAddSingleton<LanguageService>();
+            services.TryAddSingleton<NBXplorerDashboard>();
+            services.TryAddSingleton<StoreRepository>();
+            services.TryAddSingleton<BTCPayWalletProvider>();
+            services.TryAddSingleton<CurrencyNameTable>();
+            services.TryAddSingleton<IFeeProviderFactory>(o => new NBXplorerFeeProviderFactory(o.GetRequiredService<ExplorerClientProvider>())
+            {
+                Fallback = new FeeRate(100, 1),
+                BlockTarget = 20
+            });
+
+            services.AddSingleton<CssThemeManager>();
+            services.AddSingleton<IHostedService, CssThemeManagerHostedService>();
+
+            services.AddSingleton<Payments.IPaymentMethodHandler<DerivationStrategy>, Payments.Bitcoin.BitcoinLikePaymentHandler>();
+            services.AddSingleton<IHostedService, Payments.Bitcoin.NBXplorerListener>();
+
+            services.AddSingleton<Payments.IPaymentMethodHandler<Payments.Lightning.LightningSupportedPaymentMethod>, Payments.Lightning.LightningLikePaymentHandler>();
+            services.AddSingleton<IHostedService, Payments.Lightning.LightningListener>();
+
+            services.AddSingleton<IHostedService, NBXplorerWaiters>();
+            services.AddSingleton<IHostedService, InvoiceNotificationManager>();
+            services.AddSingleton<IHostedService, InvoiceWatcher>();
+            services.AddSingleton<IHostedService, RatesHostedService>();
+            services.AddTransient<IConfigureOptions<MvcOptions>, BTCPayClaimsFilter>();
+            services.AddTransient<IConfigureOptions<MvcOptions>, BitpayClaimsFilter>();
+
+            services.TryAddSingleton<ExplorerClientProvider>();
             services.TryAddSingleton<Bitpay>(o =>
             {
-                if (o.GetRequiredService<BTCPayServerOptions>().Network == Network.Main)
+                if (o.GetRequiredService<BTCPayServerOptions>().NetworkType == NetworkType.Mainnet)
                     return new Bitpay(new Key(), new Uri("https://bitpay.com/"));
                 else
                     return new Bitpay(new Key(), new Uri("https://test.bitpay.com/"));
             });
-            services.TryAddSingleton<IRateProvider>(o =>
-            {
-                var coinaverage = new CoinAverageRateProvider();
-                var bitpay = new BitpayRateProvider(new Bitpay(new Key(), new Uri("https://bitpay.com/")));
-                return new CachedRateProvider(new FallbackRateProvider(new IRateProvider[] { coinaverage, bitpay }), o.GetRequiredService<IMemoryCache>()) { CacheSpan = TimeSpan.FromMinutes(1.0) };
-            });
-            
-            services.AddSingleton<IHostedService, InvoiceNotificationManager>();
+            services.TryAddSingleton<BTCPayRateProviderFactory>();
 
-            services.TryAddSingleton<InvoiceWatcherAccessor>();
-            services.AddSingleton<IHostedService, InvoiceWatcher>();
-            services.TryAddSingleton<Initializer>();
             services.TryAddScoped<IHttpContextAccessor, HttpContextAccessor>();
-            services.TryAddSingleton<IAuthorizationHandler, OwnStoreHandler>();
             services.AddTransient<AccessTokenController>();
-            services.AddTransient<CallbackController>();
             services.AddTransient<InvoiceController>();
             // Add application services.
             services.AddTransient<IEmailSender, EmailSender>();
+            // bundling
 
-            services.AddAuthorization(o =>
+            services.AddAuthorization(o => Policies.AddBTCPayPolicies(o));
+
+            services.AddBundles();
+            services.AddTransient<BundleOptions>(provider =>
             {
-                o.AddPolicy("CanAccessStore", builder =>
-                {
-                    builder.AddRequirements(new OwnStoreAuthorizationRequirement());
-                });
-
-                o.AddPolicy("OwnStore", builder =>
-                {
-                    builder.AddRequirements(new OwnStoreAuthorizationRequirement("Owner"));
-                });
+                var opts = provider.GetRequiredService<BTCPayServerOptions>();
+                var bundle = new BundleOptions();
+                bundle.UseMinifiedFiles = opts.BundleJsCss;
+                bundle.AppendVersion = true;
+                return bundle;
             });
 
             return services;
@@ -199,12 +163,8 @@ namespace BTCPayServer.Hosting
                 });
             }
 
-
-
-            var initialize = app.ApplicationServices.GetService<Initializer>();
-            initialize.Init();
             app.UseMiddleware<BTCPayMiddleware>();
-            return app;
+            return app; 
         }
 
         static void Retry(Action act)
@@ -217,11 +177,9 @@ namespace BTCPayServer.Hosting
                     act();
                     return;
                 }
-                catch
+                catch when(!cts.IsCancellationRequested)
                 {
-                    if (cts.IsCancellationRequested)
-                        throw;
-                    Thread.Sleep(1000);
+                    Thread.Sleep(100);
                 }
             }
         }

BTCPayServer/Hosting/BTCpayMiddleware.cs

@@ -6,36 +6,25 @@ using System.Collections.Generic;
 using System.Text;
 using System.Linq;
 using System.Threading.Tasks;
-using NBitcoin;
-using NBitcoin.Crypto;
-using NBitcoin.DataEncoders;
-using Microsoft.AspNetCore.Http.Internal;
 using System.IO;
 using BTCPayServer.Authentication;
-using System.Security.Principal;
-using NBitpayClient.Extensions;
 using BTCPayServer.Logging;
 using Newtonsoft.Json;
 using BTCPayServer.Models;
 using BTCPayServer.Configuration;
-using Microsoft.AspNetCore.Mvc;
-using Microsoft.AspNetCore.Mvc.Routing;
-using Microsoft.AspNetCore.Http.Extensions;
-using BTCPayServer.Controllers;
+using System.Net.WebSockets;
+using BTCPayServer.Services.Stores;
 
 namespace BTCPayServer.Hosting
 {
     public class BTCPayMiddleware
     {
-        TokenRepository _TokenRepository;
         RequestDelegate _Next;
         BTCPayServerOptions _Options;
 
         public BTCPayMiddleware(RequestDelegate next,
-            TokenRepository tokenRepo,
             BTCPayServerOptions options)
         {
-            _TokenRepository = tokenRepo ?? throw new ArgumentNullException(nameof(tokenRepo));
             _Next = next ?? throw new ArgumentNullException(nameof(next));
             _Options = options ?? throw new ArgumentNullException(nameof(options));
         }
@@ -44,44 +33,20 @@ namespace BTCPayServer.Hosting
         public async Task Invoke(HttpContext httpContext)
         {
             RewriteHostIfNeeded(httpContext);
-            httpContext.Request.Headers.TryGetValue("x-signature", out StringValues values);
-            var sig = values.FirstOrDefault();
-            httpContext.Request.Headers.TryGetValue("x-identity", out values);
-            var id = values.FirstOrDefault();
-            if (!string.IsNullOrEmpty(sig) && !string.IsNullOrEmpty(id))
-            {
-                httpContext.Request.EnableRewind();
-
-                string body = string.Empty;
-                if (httpContext.Request.ContentLength != 0 && httpContext.Request.Body != null)
-                {
-                    using (StreamReader reader = new StreamReader(httpContext.Request.Body, Encoding.UTF8, true, 1024, true))
-                    {
-                        body = reader.ReadToEnd();
-                    }
-                    httpContext.Request.Body.Position = 0;
-                }
-
-                var url = httpContext.Request.GetEncodedUrl();
-                try
-                {
-                    var key = new PubKey(id);
-                    if (BitIdExtensions.CheckBitIDSignature(key, sig, url, body))
-                    {
-                        var bitid = new BitIdentity(key);
-                        httpContext.User = new GenericPrincipal(bitid, new string[0]);
-                        Logs.PayServer.LogDebug($"BitId signature check success for SIN {bitid.SIN}");
-                    }
-                }
-                catch (FormatException) { }
-                if (!(httpContext.User.Identity is BitIdentity))
-                    Logs.PayServer.LogDebug("BitId signature check failed");
-            }
 
             try
             {
+                var bitpayAuth = GetBitpayAuth(httpContext, out bool isBitpayAuth);
+                var isBitpayAPI = IsBitpayAPI(httpContext, isBitpayAuth);
+                httpContext.SetIsBitpayAPI(isBitpayAPI);
+                if (isBitpayAPI)
+                {
+                    httpContext.SetBitpayAuth(bitpayAuth);
+                }
                 await _Next(httpContext);
             }
+            catch (WebSocketException)
+            { }
             catch (UnauthorizedAccessException ex)
             {
                 await HandleBitpayHttpException(httpContext, new BitpayHttpException(401, ex.Message));
@@ -97,41 +62,124 @@ namespace BTCPayServer.Hosting
             }
         }
 
+        private static (string Signature, String Id, String Authorization) GetBitpayAuth(HttpContext httpContext, out bool hasBitpayAuth)
+        {
+            httpContext.Request.Headers.TryGetValue("x-signature", out StringValues values);
+            var sig = values.FirstOrDefault();
+            httpContext.Request.Headers.TryGetValue("x-identity", out values);
+            var id = values.FirstOrDefault();
+            httpContext.Request.Headers.TryGetValue("Authorization", out values);
+            var auth = values.FirstOrDefault();
+            hasBitpayAuth = auth != null || (sig != null && id != null);
+            return (sig, id, auth);
+        }
+
+        private bool IsBitpayAPI(HttpContext httpContext, bool bitpayAuth)
+        {
+            if (!httpContext.Request.Path.HasValue)
+                return false;
+
+            var path = httpContext.Request.Path.Value;
+            if (
+                bitpayAuth &&
+                path == "/invoices" &&
+              httpContext.Request.Method == "POST" &&
+              (httpContext.Request.ContentType ?? string.Empty).StartsWith("application/json", StringComparison.OrdinalIgnoreCase))
+                return true;
+
+            if (
+                bitpayAuth &&
+                path == "/invoices" &&
+              httpContext.Request.Method == "GET")
+                return true;
+
+            if (
+                bitpayAuth &&
+                path.StartsWith("/invoices/", StringComparison.OrdinalIgnoreCase) &&
+                httpContext.Request.Method == "GET")
+                return true;
+
+            if (path.Equals("/rates", StringComparison.OrdinalIgnoreCase) &&
+                httpContext.Request.Method == "GET")
+                return true;
+
+            if (
+                path.Equals("/tokens", StringComparison.Ordinal) && 
+                ( httpContext.Request.Method == "GET" || httpContext.Request.Method == "POST"))
+                return true;
+
+            return false;
+        }
+
         private void RewriteHostIfNeeded(HttpContext httpContext)
         {
+            string reverseProxyScheme = null;
+            if (httpContext.Request.Headers.TryGetValue("X-Forwarded-Proto", out StringValues proto))
+            {
+                var scheme = proto.SingleOrDefault();
+                if (scheme != null)
+                {
+                    reverseProxyScheme = scheme;
+                }
+            }
+
+            ushort? reverseProxyPort = null;
+            if (httpContext.Request.Headers.TryGetValue("X-Forwarded-Port", out StringValues port))
+            {
+                var portString = port.SingleOrDefault();
+                if (portString != null && ushort.TryParse(portString, out ushort pp))
+                {
+                    reverseProxyPort = pp;
+                }
+            }
+
             // Make sure that code executing after this point think that the external url has been hit.
             if (_Options.ExternalUrl != null)
             {
-                httpContext.Request.Scheme = _Options.ExternalUrl.Scheme;
+                if (reverseProxyScheme != null && _Options.ExternalUrl.Scheme != reverseProxyScheme)
+                {
+                    if (reverseProxyScheme == "http" && _Options.ExternalUrl.Scheme == "https")
+                        Logs.PayServer.LogWarning($"BTCPay ExternalUrl setting expected to use scheme '{_Options.ExternalUrl.Scheme}' externally, but the reverse proxy uses scheme '{reverseProxyScheme}'");
+                    httpContext.Request.Scheme = reverseProxyScheme;
+                }
+                else
+                {
+                    httpContext.Request.Scheme = _Options.ExternalUrl.Scheme;
+                }
                 if (_Options.ExternalUrl.IsDefaultPort)
                     httpContext.Request.Host = new HostString(_Options.ExternalUrl.Host);
                 else
-                    httpContext.Request.Host = new HostString(_Options.ExternalUrl.Host, _Options.ExternalUrl.Port);
+                {
+                    if (reverseProxyPort != null && _Options.ExternalUrl.Port != reverseProxyPort.Value)
+                    {
+                        Logs.PayServer.LogWarning($"BTCPay ExternalUrl setting expected to use port '{_Options.ExternalUrl.Port}' externally, but the reverse proxy uses port '{reverseProxyPort.Value}'");
+                        httpContext.Request.Host = new HostString(_Options.ExternalUrl.Host, reverseProxyPort.Value);
+                    }
+                    else
+                    {
+                        httpContext.Request.Host = new HostString(_Options.ExternalUrl.Host, _Options.ExternalUrl.Port);
+                    }
+                }
             }
             // NGINX pass X-Forwarded-Proto and X-Forwarded-Port, so let's use that to have better guess of the real domain
             else
             {
                 ushort? p = null;
-                if (httpContext.Request.Headers.TryGetValue("X-Forwarded-Proto", out StringValues proto))
+                if (reverseProxyScheme != null)
                 {
-                    var scheme = proto.SingleOrDefault();
-                    if (scheme != null)
-                    {
-                        httpContext.Request.Scheme = scheme;
-                        if (scheme == "http")
-                            p = 80;
-                        if (scheme == "https")
-                            p = 443;
-                    }
+                    httpContext.Request.Scheme = reverseProxyScheme;
+                    if (reverseProxyScheme == "http")
+                        p = 80;
+                    if (reverseProxyScheme == "https")
+                        p = 443;
                 }
-                if (httpContext.Request.Headers.TryGetValue("X-Forwarded-Port", out StringValues port))
+
+
+                if (reverseProxyPort != null)
                 {
-                    var portString = port.SingleOrDefault();
-                    if (portString != null && ushort.TryParse(portString, out ushort pp))
-                    {
-                        p = pp;
-                    }
+                    p = reverseProxyPort.Value;
                 }
+
                 if (p.HasValue)
                 {
                     bool isDefault = httpContext.Request.Scheme == "http" && p.Value == 80;

BTCPayServer/Hosting/Startup.cs

@@ -6,6 +6,7 @@ using System;
 using System.Collections.Generic;
 using System.Text;
 using Microsoft.Extensions.DependencyInjection;
+
 using Microsoft.AspNetCore.Mvc.ModelBinding.Validation;
 using Microsoft.AspNetCore.Mvc;
 using NBitpayClient;
@@ -36,6 +37,9 @@ using System.Threading;
 using Microsoft.Extensions.Options;
 using Microsoft.ApplicationInsights.AspNetCore.Extensions;
 using Microsoft.AspNetCore.Mvc.Cors.Internal;
+using Microsoft.AspNetCore.Server.Kestrel.Core;
+using System.Net;
+using Meziantou.AspNetCore.BundleTagHelpers;
 
 namespace BTCPayServer.Hosting
 {
@@ -72,41 +76,27 @@ namespace BTCPayServer.Hosting
                 .AddEntityFrameworkStores<ApplicationDbContext>()
                 .AddDefaultTokenProviders();
 
-            // Big hack, tests fails because Hangfire fail at initializing at the second test run
-            AddHangfireFix(services);
             services.AddBTCPayServer();
             services.AddMvc(o =>
             {
                 o.Filters.Add(new XFrameOptionsAttribute("DENY"));
             });
-        }
 
-        // Big hack, tests fails if only call AddHangfire because Hangfire fail at initializing at the second test run
-        private void AddHangfireFix(IServiceCollection services)
-        {
-            Action<IGlobalConfiguration> configuration = o =>
+            services.Configure<IdentityOptions>(options =>
+            {
+                options.Password.RequireDigit = false;
+                options.Password.RequiredLength = 7;
+                options.Password.RequireLowercase = false;
+                options.Password.RequireNonAlphanumeric = false;
+                options.Password.RequireUppercase = false;
+            });
+
+            services.AddHangfire((o) =>
             {
                 var scope = AspNetCoreJobActivator.Current.BeginScope(null);
                 var options = (ApplicationDbContextFactory)scope.Resolve(typeof(ApplicationDbContextFactory));
                 options.ConfigureHangfireBuilder(o);
-            };
-
-            ServiceCollectionDescriptorExtensions.TryAddSingleton<Action<IGlobalConfiguration>>(services, (IServiceProvider serviceProvider) => new Action<IGlobalConfiguration>((config) =>
-           {
-               ILoggerFactory service = ServiceProviderServiceExtensions.GetService<ILoggerFactory>(serviceProvider);
-               if (service != null)
-               {
-                   Hangfire.GlobalConfigurationExtensions.UseLogProvider<AspNetCoreLogProvider>(config, new AspNetCoreLogProvider(service));
-               }
-               IServiceScopeFactory service2 = ServiceProviderServiceExtensions.GetService<IServiceScopeFactory>(serviceProvider);
-               if (service2 != null)
-               {
-                   Hangfire.GlobalConfigurationExtensions.UseActivator<AspNetCoreJobActivator>(config, new AspNetCoreJobActivator(service2));
-               }
-               configuration(config);
-           }));
-
-            services.AddHangfire(configuration);
+            });
             services.AddCors(o =>
             {
                 o.AddPolicy("BitpayAPI", b =>
@@ -114,18 +104,44 @@ namespace BTCPayServer.Hosting
                     b.AllowAnyMethod().AllowAnyHeader().AllowAnyOrigin();
                 });
             });
-
             services.Configure<IOptions<ApplicationInsightsServiceOptions>>(o =>
             {
                 o.Value.DeveloperMode = _Env.IsDevelopment();
             });
+
+            // Needed to debug U2F for ledger support
+            //services.Configure<KestrelServerOptions>(kestrel =>
+            //{
+            //    kestrel.Listen(IPAddress.Loopback, 5012, l =>
+            //    {
+            //        l.UseHttps("devtest.pfx", "toto");
+            //    });
+            //});
         }
 
         public void Configure(
             IApplicationBuilder app,
             IHostingEnvironment env,
             IServiceProvider prov,
+            BTCPayServerOptions options,
             ILoggerFactory loggerFactory)
+        {
+            Logs.Configure(loggerFactory);
+            Logs.Configuration.LogInformation($"Root Path: {options.RootPath}");
+            if (options.RootPath.Equals("/", StringComparison.OrdinalIgnoreCase))
+            {
+                ConfigureCore(app, env, prov, loggerFactory, options);
+            }
+            else
+            {
+                app.Map(options.RootPath, appChild =>
+                {
+                    ConfigureCore(appChild, env, prov, loggerFactory, options);
+                });
+            }
+        }
+
+        private static void ConfigureCore(IApplicationBuilder app, IHostingEnvironment env, IServiceProvider prov, ILoggerFactory loggerFactory, BTCPayServerOptions options)
         {
             if (env.IsDevelopment())
             {
@@ -133,9 +149,6 @@ namespace BTCPayServer.Hosting
                 app.UseBrowserLink();
             }
 
-
-            Logs.Configure(loggerFactory);
-
             //App insight do not that by itself...
             loggerFactory.AddApplicationInsights(prov, LogLevel.Information);
 
@@ -143,7 +156,11 @@ namespace BTCPayServer.Hosting
             app.UseStaticFiles();
             app.UseAuthentication();
             app.UseHangfireServer();
-            app.UseHangfireDashboard("/hangfire", new DashboardOptions() { Authorization = new[] { new NeedRole(Roles.ServerAdmin) } });
+            app.UseHangfireDashboard("/hangfire", new DashboardOptions()
+            {
+                AppPath = options.GetRootUri(),
+                Authorization = new[] { new NeedRole(Roles.ServerAdmin) }
+            });
             app.UseWebSockets();
             app.UseMvc(routes =>
             {

BTCPayServer/Initializer.cs

@@ -1,45 +0,0 @@
-using System;
-using Microsoft.Extensions.Logging;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using BTCPayServer.Controllers;
-using BTCPayServer.Logging;
-using BTCPayServer.Events;
-
-namespace BTCPayServer
-{
-    public class Initializer
-    {
-        EventAggregator _Aggregator;
-        CallbackController _CallbackController;
-        public Initializer(EventAggregator aggregator, 
-            CallbackController callbackController
-            )
-        {
-            _Aggregator = aggregator;
-            _CallbackController = callbackController;
-        }
-        public void Init()
-        {
-            _Aggregator.Subscribe<NBXplorerStateChangedEvent>(async (s, evt) =>
-            {
-                if (evt.NewState == NBXplorerState.Ready)
-                {
-                    s.Unsubscribe();
-                    try
-                    {
-                        var callback = await _CallbackController.GetCallbackBlockUriAsync();
-                        await _CallbackController.RegisterCallbackBlockUriAsync(callback);
-                        Logs.PayServer.LogInformation($"Registering block callback to " + callback);
-                    }
-                    catch (Exception ex)
-                    {
-                        Logs.PayServer.LogError(ex, "Could not register block callback");
-                        s.Resubscribe();
-                    }
-                }
-            });
-        }
-    }
-}

BTCPayServer/JsonConverters/CurrencyValueJsonConverter.cs

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

BTCPayServer/JsonConverters/LightMoneyJsonConverter.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using System.Reflection;
+using BTCPayServer.Payments.Lightning;
+using NBitcoin.JsonConverters;
+using System.Globalization;
+
+namespace BTCPayServer.JsonConverters
+{
+    public class LightMoneyJsonConverter : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+        {
+            return typeof(LightMoneyJsonConverter).GetTypeInfo().IsAssignableFrom(objectType.GetTypeInfo());
+        }
+
+        Type longType = typeof(long).GetTypeInfo();
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            try
+            {
+                return reader.TokenType == JsonToken.Null ? null :
+                    reader.TokenType == JsonToken.Integer ?
+                                                longType.IsAssignableFrom(reader.ValueType) ? new LightMoney((long)reader.Value)
+                                                                                            : new LightMoney(long.MaxValue) :
+                    reader.TokenType == JsonToken.String ? new LightMoney(long.Parse((string)reader.Value, CultureInfo.InvariantCulture)) 
+                    : null;
+            }
+            catch (InvalidCastException)
+            {
+                throw new JsonObjectException("Money amount should be in millisatoshi", reader);
+            }
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            writer.WriteValue(((LightMoney)value).MilliSatoshi);
+        }
+    }
+}

BTCPayServer/JsonConverters/UriJsonConverter.cs

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

BTCPayServer/Logging/ConsoleLogger.cs

@@ -6,13 +6,18 @@ using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace BTCPayServer.Logging
 {
     public class CustomConsoleLogProvider : ILoggerProvider
     {
-        ConsoleLoggerProcessor _Processor = new ConsoleLoggerProcessor();
+        ConsoleLoggerProcessor _Processor;
+        public CustomConsoleLogProvider(ConsoleLoggerProcessor processor)
+        {
+            _Processor = processor;
+        }
         public ILogger CreateLogger(string categoryName)
         {
             return new CustomConsoleLogger(categoryName, (a, b) => true, false, _Processor);
@@ -329,7 +334,8 @@ namespace BTCPayServer.Logging
             _outputTask = Task.Factory.StartNew(
                 ProcessLogQueue,
                 this,
-                TaskCreationOptions.LongRunning);
+                default(CancellationToken),
+                TaskCreationOptions.LongRunning, TaskScheduler.Default);
         }
 
         public virtual void EnqueueMessage(LogMessageEntry message)

BTCPayServer/Logging/Logs.cs

@@ -17,7 +17,7 @@ namespace BTCPayServer.Logging
         {
             Configuration = factory.CreateLogger("Configuration");
             PayServer = factory.CreateLogger("PayServer");
-            Events = factory.CreateLogger("PayServer");
+            Events = factory.CreateLogger("Events");
         }
         public static ILogger Configuration
         {

BTCPayServer/Migrations/20171012020112_PendingInvoices.cs

@@ -8,7 +8,7 @@ namespace BTCPayServer.Migrations
     {
         protected override void Up(MigrationBuilder migrationBuilder)
         {
-            if (SupportDropColumn(migrationBuilder.ActiveProvider))
+            if (this.SupportDropColumn(migrationBuilder.ActiveProvider))
             {
                 migrationBuilder.DropColumn(
                     name: "Name",
@@ -30,11 +30,6 @@ namespace BTCPayServer.Migrations
                 });
         }
 
-        private bool SupportDropColumn(string activeProvider)
-        {
-            return activeProvider != "Microsoft.EntityFrameworkCore.Sqlite";
-        }
-
         protected override void Down(MigrationBuilder migrationBuilder)
         {
             migrationBuilder.DropTable(