Make sure a too high expiration do not trigger "The value needs to translate in milliseconds to -1 (signifying an infinite timeout)"

Update Icelandic

.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,5 +1,7 @@
 using BTCPayServer.Configuration;
 using BTCPayServer.Hosting;
+using BTCPayServer.Payments;
+using BTCPayServer.Payments.Lightning;
 using BTCPayServer.Services.Invoices;
 using BTCPayServer.Services.Rates;
 using BTCPayServer.Tests.Logging;
@@ -84,6 +86,8 @@ namespace BTCPayServer.Tests
             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);
             var confPath = Path.Combine(chainDirectory, "settings.config");
@@ -91,13 +95,18 @@ namespace BTCPayServer.Tests
 
             ServerUri = new Uri("http://" + HostName + ":" + Port + "/");
 
+            Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development");
             var conf = new DefaultConfiguration() { Logger = Logs.LogProvider.CreateLogger("Console") }.CreateConfiguration(new[] { "--datadir", _Directory, "--conf", confPath });
-
             _Host = new WebHostBuilder()
                     .UseConfiguration(conf)
                     .ConfigureServices(s =>
                     {
-                        s.AddSingleton<IRateProvider>(new MockRateProvider(new Rate("USD", 5000m)));
+                        var mockRates = new MockRateProviderFactory();
+                        var btc = new MockRateProvider("BTC", new Rate("USD", 5000m), new Rate("CAD", 4500m));
+                        var ltc = new MockRateProvider("LTC", new Rate("USD", 500m));
+                        mockRates.AddMock(btc);
+                        mockRates.AddMock(ltc);
+                        s.AddSingleton<IRateProviderFactory>(mockRates);
                         s.AddLogging(l =>
                         {
                             l.SetMinimumLevel(LogLevel.Information)
@@ -111,6 +120,7 @@ namespace BTCPayServer.Tests
                     .Build();
             _Host.Start();
             InvoiceRepository = (InvoiceRepository)_Host.Services.GetService(typeof(InvoiceRepository));
+            ((LightningLikePaymentHandler)_Host.Services.GetService(typeof(IPaymentMethodHandler<LightningSupportedPaymentMethod>))).SkipP2PTest = !InContainer;
         }
         
         public string HostName
@@ -119,6 +129,8 @@ namespace BTCPayServer.Tests
             internal set;
         }
         public InvoiceRepository InvoiceRepository { get; private set; }
+        public Uri IntegratedLightning { get; internal set; }
+        public bool InContainer { get; internal set; }
 
         public T GetService<T>()
         {

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.5-sdk-2.1.4
+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/README.md

@@ -26,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
@@ -35,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/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
 {
@@ -54,49 +56,105 @@ namespace BTCPayServer.Tests
             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")
+                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()));
+            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"));
             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)
         {

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
 {
@@ -46,32 +49,24 @@ namespace BTCPayServer.Tests
             Assert.IsType<ViewResult>(await store.RequestPairing(pairingCode.ToString()));
             await store.Pair(pairingCode.ToString(), StoreId);
         }
-        public StoresController CreateStore(string cryptoCode = null)
+        public StoresController CreateStore()
         {
-            return CreateStoreAsync(cryptoCode).GetAwaiter().GetResult();
+            return CreateStoreAsync().GetAwaiter().GetResult();
         }
 
-        public string CryptoCode { get; set; } = "BTC";
-        public async Task<StoresController> CreateStoreAsync(string cryptoCode = null)
+        public T GetController<T>() where T : Controller
         {
-            cryptoCode = cryptoCode ?? CryptoCode;
-            SupportedNetwork = parent.NetworkProvider.GetNetwork(cryptoCode);
-            ExtKey = new ExtKey().GetWif(SupportedNetwork.NBitcoinNetwork);
-            var store = parent.PayTester.GetController<StoresController>(UserId);
+            return parent.PayTester.GetController<T>(UserId);
+        }
+
+        public async Task<StoresController> CreateStoreAsync()
+        {
+            var store = parent.PayTester.GetController<UserStoresController>(UserId);
             await store.CreateStore(new CreateStoreViewModel() { Name = "Test Store" });
             StoreId = store.CreatedStoreId;
-            DerivationScheme = new DerivationStrategyFactory(SupportedNetwork.NBitcoinNetwork).Parse(ExtKey.Neuter().ToString() + "-[legacy]");
-            var vm = (StoreViewModel)((ViewResult)await store.UpdateStore(StoreId)).Model;
-            vm.SpeedPolicy = SpeedPolicy.MediumSpeed;
-            await store.UpdateStore(StoreId, vm);
-
-            await store.AddDerivationScheme(StoreId, new DerivationSchemeViewModel()
-            {
-                CryptoCurrency = cryptoCode,
-                DerivationSchemeFormat = "BTCPay",
-                DerivationScheme = DerivationScheme.ToString(),
-            }, "Save");
-            return store;
+            var store2 = parent.PayTester.GetController<StoresController>(UserId);
+            store2.CreatedStoreId = store.CreatedStoreId;
+            return store2;
         }
 
         public BTCPayNetwork SupportedNetwork { get; set; }
@@ -80,17 +75,21 @@ namespace BTCPayServer.Tests
         {
             RegisterDerivationSchemeAsync(crytoCode).GetAwaiter().GetResult();
         }
-        public async Task RegisterDerivationSchemeAsync(string crytoCode)
+        public async Task RegisterDerivationSchemeAsync(string cryptoCode)
         {
+            SupportedNetwork = parent.NetworkProvider.GetNetwork(cryptoCode);
             var store = parent.PayTester.GetController<StoresController>(UserId);
-            var networkProvider = parent.PayTester.GetService<BTCPayNetworkProvider>();
-            var derivation = new DerivationStrategyFactory(networkProvider.GetNetwork(crytoCode).NBitcoinNetwork).Parse(ExtKey.Neuter().ToString() + "-[legacy]");
+            ExtKey = new ExtKey().GetWif(SupportedNetwork.NBitcoinNetwork);
+            DerivationScheme = new DerivationStrategyFactory(SupportedNetwork.NBitcoinNetwork).Parse(ExtKey.Neuter().ToString() + "-[legacy]");
+            var vm = (StoreViewModel)((ViewResult)await store.UpdateStore(StoreId)).Model;
+            vm.SpeedPolicy = SpeedPolicy.MediumSpeed;
+            await store.UpdateStore(StoreId, vm);
+
             await store.AddDerivationScheme(StoreId, new DerivationSchemeViewModel()
             {
-                CryptoCurrency = crytoCode,
-                DerivationSchemeFormat = crytoCode,
-                DerivationScheme = derivation.ToString(),
-            }, "Save");
+                DerivationScheme = DerivationScheme.ToString(),
+                Confirmation = true
+            }, cryptoCode);
         }
 
         public DerivationStrategyBase DerivationScheme { get; set; }
@@ -120,5 +119,23 @@ 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 = parent.PayTester.GetController<StoresController>(UserId);
+            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())
+            }, "save", "BTC");
+            if (storeController.ModelState.ErrorCount != 0)
+                Assert.False(true, storeController.ModelState.FirstOrDefault().Value.Errors[0].ErrorMessage);
+        }
+}
 }

BTCPayServer.Tests/UnitTest1.cs

@@ -22,10 +22,16 @@ using BTCPayServer.Data;
 using Microsoft.EntityFrameworkCore;
 using BTCPayServer.Services.Rates;
 using Microsoft.Extensions.Caching.Memory;
-using BTCPayServer.Eclair;
 using System.Collections.Generic;
 using BTCPayServer.Models.StoreViewModels;
 using System.Threading.Tasks;
+using System.Globalization;
+using BTCPayServer.Payments;
+using BTCPayServer.Payments.Bitcoin;
+using BTCPayServer.HostedServices;
+using BTCPayServer.Payments.Lightning;
+using BTCPayServer.Models.AppViewModels;
+using BTCPayServer.Services.Apps;
 
 namespace BTCPayServer.Tests
 {
@@ -37,6 +43,63 @@ namespace BTCPayServer.Tests
             Logs.LogProvider = new XUnitLogProvider(helper);
         }
 
+        [Fact]
+        public void CanCalculateCryptoDue2()
+        {
+            var dummy = new Key().PubKey.GetAddress(Network.RegTest).ToString();
+#pragma warning disable CS0618
+            InvoiceEntity invoiceEntity = new InvoiceEntity();
+            invoiceEntity.Payments = new System.Collections.Generic.List<PaymentEntity>();
+            invoiceEntity.ProductInformation = new ProductInformation() { Price = 100 };
+            PaymentMethodDictionary paymentMethods = new PaymentMethodDictionary();
+            paymentMethods.Add(new PaymentMethod()
+            {
+                CryptoCode = "BTC",
+                Rate = 10513.44m,
+            }.SetPaymentMethodDetails(new BTCPayServer.Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod()
+            {
+                TxFee = Money.Coins(0.00000100m),
+                DepositAddress = dummy
+            }));
+            paymentMethods.Add(new PaymentMethod()
+            {
+                CryptoCode = "LTC",
+                Rate = 216.79m
+            }.SetPaymentMethodDetails(new BTCPayServer.Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod()
+            {
+                TxFee = Money.Coins(0.00010000m),
+                DepositAddress = dummy
+            }));
+            invoiceEntity.SetPaymentMethods(paymentMethods);
+
+            var btc = invoiceEntity.GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike), null);
+            var accounting = btc.Calculate();
+
+            invoiceEntity.Payments.Add(new PaymentEntity() { Accounted = true, CryptoCode = "BTC" }.SetCryptoPaymentData(new BitcoinLikePaymentData()
+            {
+                Output = new TxOut() { Value = Money.Coins(0.00151263m) }
+            }));
+            accounting = btc.Calculate();
+            invoiceEntity.Payments.Add(new PaymentEntity() { Accounted = true, CryptoCode = "BTC" }.SetCryptoPaymentData(new BitcoinLikePaymentData()
+            {
+                Output = new TxOut() { Value = accounting.Due }
+            }));
+            accounting = btc.Calculate();
+            Assert.Equal(Money.Zero, accounting.Due);
+            Assert.Equal(Money.Zero, accounting.DueUncapped);
+
+            var ltc = invoiceEntity.GetPaymentMethod(new PaymentMethodId("LTC", PaymentTypes.BTCLike), null);
+            accounting = ltc.Calculate();
+
+            Assert.Equal(Money.Zero, accounting.Due);
+            // LTC might have over paid due to BTC paying above what it should (round 1 satoshi up)
+            Assert.True(accounting.DueUncapped < Money.Zero);
+
+            var paymentMethod = InvoiceWatcher.GetNearestClearedPayment(paymentMethods, out var accounting2, null);
+            Assert.Equal(btc.CryptoCode, paymentMethod.CryptoCode);
+#pragma warning restore CS0618
+        }
+
         [Fact]
         public void CanCalculateCryptoDue()
         {
@@ -49,79 +112,81 @@ namespace BTCPayServer.Tests
             entity.ProductInformation = new ProductInformation() { Price = 5000 };
 
             // Some check that handling legacy stuff does not break things
-            var cryptoData = entity.GetCryptoData("BTC", null, true);
-            cryptoData.Calculate();
-            Assert.NotNull(cryptoData);
-            Assert.Null(entity.GetCryptoData("BTC", null, false));
-            entity.SetCryptoData(new CryptoData() { ParentEntity = entity, Rate = entity.Rate, CryptoCode = "BTC", TxFee = entity.TxFee });
-            Assert.NotNull(entity.GetCryptoData("BTC", null, false));
-            Assert.NotNull(entity.GetCryptoData("BTC", null, true));
+            var paymentMethod = entity.GetPaymentMethods(null, true).TryGet("BTC", PaymentTypes.BTCLike);
+            paymentMethod.Calculate();
+            Assert.NotNull(paymentMethod);
+            Assert.Null(entity.GetPaymentMethods(null, false).TryGet("BTC", PaymentTypes.BTCLike));
+            entity.SetPaymentMethod(new PaymentMethod() { ParentEntity = entity, Rate = entity.Rate, CryptoCode = "BTC", TxFee = entity.TxFee });
+            Assert.NotNull(entity.GetPaymentMethods(null, false).TryGet("BTC", PaymentTypes.BTCLike));
+            Assert.NotNull(entity.GetPaymentMethods(null, true).TryGet("BTC", PaymentTypes.BTCLike));
             ////////////////////
 
-            var accounting = cryptoData.Calculate();
+            var accounting = paymentMethod.Calculate();
             Assert.Equal(Money.Coins(1.1m), accounting.Due);
             Assert.Equal(Money.Coins(1.1m), accounting.TotalDue);
 
             entity.Payments.Add(new PaymentEntity() { Output = new TxOut(Money.Coins(0.5m), new Key()), Accounted = true });
 
-            accounting = cryptoData.Calculate();
+            accounting = paymentMethod.Calculate();
             //Since we need to spend one more txout, it should be 1.1 - 0,5 + 0.1
             Assert.Equal(Money.Coins(0.7m), accounting.Due);
             Assert.Equal(Money.Coins(1.2m), accounting.TotalDue);
 
             entity.Payments.Add(new PaymentEntity() { Output = new TxOut(Money.Coins(0.2m), new Key()), Accounted = true });
 
-            accounting = cryptoData.Calculate();
+            accounting = paymentMethod.Calculate();
             Assert.Equal(Money.Coins(0.6m), accounting.Due);
             Assert.Equal(Money.Coins(1.3m), accounting.TotalDue);
 
             entity.Payments.Add(new PaymentEntity() { Output = new TxOut(Money.Coins(0.6m), new Key()), Accounted = true });
 
-            accounting = cryptoData.Calculate();
+            accounting = paymentMethod.Calculate();
             Assert.Equal(Money.Zero, accounting.Due);
             Assert.Equal(Money.Coins(1.3m), accounting.TotalDue);
 
             entity.Payments.Add(new PaymentEntity() { Output = new TxOut(Money.Coins(0.2m), new Key()), Accounted = true });
 
-            accounting = cryptoData.Calculate();
+            accounting = paymentMethod.Calculate();
             Assert.Equal(Money.Zero, accounting.Due);
             Assert.Equal(Money.Coins(1.3m), accounting.TotalDue);
 
             entity = new InvoiceEntity();
             entity.ProductInformation = new ProductInformation() { Price = 5000 };
-            entity.SetCryptoData(new System.Collections.Generic.Dictionary<string, CryptoData>(new KeyValuePair<string, CryptoData>[] {
-                new KeyValuePair<string,CryptoData>("BTC", new CryptoData()
-                                                           {
-                                                                Rate = 1000,
-                                                                TxFee = Money.Coins(0.1m)
-                                                           }),
-                new KeyValuePair<string,CryptoData>("LTC", new CryptoData()
-                                                           {
-                                                                Rate = 500,
-                                                                TxFee = Money.Coins(0.01m)
-                                                           })
-            }));
+            PaymentMethodDictionary paymentMethods = new PaymentMethodDictionary();
+            paymentMethods.Add(new PaymentMethod()
+            {
+                CryptoCode = "BTC",
+                Rate = 1000,
+                TxFee = Money.Coins(0.1m)
+            });
+            paymentMethods.Add(new PaymentMethod()
+            {
+                CryptoCode = "LTC",
+                Rate = 500,
+                TxFee = Money.Coins(0.01m)
+            });
+            entity.SetPaymentMethods(paymentMethods);
             entity.Payments = new List<PaymentEntity>();
-            cryptoData = entity.GetCryptoData("BTC", null);
-            accounting = cryptoData.Calculate();
+            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike), null);
+            accounting = paymentMethod.Calculate();
             Assert.Equal(Money.Coins(5.1m), accounting.Due);
 
-            cryptoData = entity.GetCryptoData("LTC", null);
-            accounting = cryptoData.Calculate();
+            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("LTC", PaymentTypes.BTCLike), null);
+            accounting = paymentMethod.Calculate();
             Assert.Equal(Money.Coins(10.01m), accounting.TotalDue);
 
             entity.Payments.Add(new PaymentEntity() { CryptoCode = "BTC", Output = new TxOut(Money.Coins(1.0m), new Key()), Accounted = true });
 
-            cryptoData = entity.GetCryptoData("BTC", null);
-            accounting = cryptoData.Calculate();
+            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike), null);
+            accounting = paymentMethod.Calculate();
             Assert.Equal(Money.Coins(4.2m), accounting.Due);
             Assert.Equal(Money.Coins(1.0m), accounting.CryptoPaid);
             Assert.Equal(Money.Coins(1.0m), accounting.Paid);
             Assert.Equal(Money.Coins(5.2m), accounting.TotalDue);
-            Assert.Equal(2, accounting.TxCount);
+            Assert.Equal(2, accounting.TxRequired);
 
-            cryptoData = entity.GetCryptoData("LTC", null);
-            accounting = cryptoData.Calculate();
+            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("LTC", PaymentTypes.BTCLike), null);
+            accounting = paymentMethod.Calculate();
             Assert.Equal(Money.Coins(10.01m + 0.1m * 2 - 2.0m /* 8.21m */), accounting.Due);
             Assert.Equal(Money.Coins(0.0m), accounting.CryptoPaid);
             Assert.Equal(Money.Coins(2.0m), accounting.Paid);
@@ -130,44 +195,43 @@ namespace BTCPayServer.Tests
             entity.Payments.Add(new PaymentEntity() { CryptoCode = "LTC", Output = new TxOut(Money.Coins(1.0m), new Key()), Accounted = true });
 
 
-            cryptoData = entity.GetCryptoData("BTC", null);
-            accounting = cryptoData.Calculate();
+            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike), null);
+            accounting = paymentMethod.Calculate();
             Assert.Equal(Money.Coins(4.2m - 0.5m + 0.01m / 2), accounting.Due);
             Assert.Equal(Money.Coins(1.0m), accounting.CryptoPaid);
             Assert.Equal(Money.Coins(1.5m), accounting.Paid);
             Assert.Equal(Money.Coins(5.2m + 0.01m / 2), accounting.TotalDue); // The fee for LTC added
-            Assert.Equal(2, accounting.TxCount);
+            Assert.Equal(2, accounting.TxRequired);
 
-            cryptoData = entity.GetCryptoData("LTC", null);
-            accounting = cryptoData.Calculate();
+            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("LTC", PaymentTypes.BTCLike), null);
+            accounting = paymentMethod.Calculate();
             Assert.Equal(Money.Coins(8.21m - 1.0m + 0.01m), accounting.Due);
             Assert.Equal(Money.Coins(1.0m), accounting.CryptoPaid);
             Assert.Equal(Money.Coins(3.0m), accounting.Paid);
             Assert.Equal(Money.Coins(10.01m + 0.1m * 2 + 0.01m), accounting.TotalDue);
-            Assert.Equal(2, accounting.TxCount);
+            Assert.Equal(2, accounting.TxRequired);
 
             var remaining = Money.Coins(4.2m - 0.5m + 0.01m / 2);
             entity.Payments.Add(new PaymentEntity() { CryptoCode = "BTC", Output = new TxOut(remaining, new Key()), Accounted = true });
 
-            cryptoData = entity.GetCryptoData("BTC", null);
-            accounting = cryptoData.Calculate();
+            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike), null);
+            accounting = paymentMethod.Calculate();
             Assert.Equal(Money.Zero, accounting.Due);
             Assert.Equal(Money.Coins(1.0m) + remaining, accounting.CryptoPaid);
             Assert.Equal(Money.Coins(1.5m) + remaining, accounting.Paid);
             Assert.Equal(Money.Coins(5.2m + 0.01m / 2), accounting.TotalDue);
             Assert.Equal(accounting.Paid, accounting.TotalDue);
-            Assert.Equal(2, accounting.TxCount);
+            Assert.Equal(2, accounting.TxRequired);
 
-            cryptoData = entity.GetCryptoData("LTC", null);
-            accounting = cryptoData.Calculate();
+            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("LTC", PaymentTypes.BTCLike), null);
+            accounting = paymentMethod.Calculate();
             Assert.Equal(Money.Zero, accounting.Due);
             Assert.Equal(Money.Coins(1.0m), accounting.CryptoPaid);
             Assert.Equal(Money.Coins(3.0m) + remaining * 2, accounting.Paid);
             // Paying 2 BTC fee, LTC fee removed because fully paid
             Assert.Equal(Money.Coins(10.01m + 0.1m * 2 + 0.1m * 2 /* + 0.01m no need to pay this fee anymore */), accounting.TotalDue);
-            Assert.Equal(1, accounting.TxCount);
+            Assert.Equal(1, accounting.TxRequired);
             Assert.Equal(accounting.Paid, accounting.TotalDue);
-
 #pragma warning restore CS0618
         }
 
@@ -179,6 +243,7 @@ namespace BTCPayServer.Tests
                 tester.Start();
                 var user = tester.NewAccount();
                 user.GrantAccess();
+                user.RegisterDerivationScheme("BTC");
                 var invoice = user.BitPay.CreateInvoice(new Invoice()
                 {
                     Buyer = new Buyer() { email = "test@fwf.com" },
@@ -224,18 +289,171 @@ namespace BTCPayServer.Tests
         {
             var light = LightMoney.MilliSatoshis(1);
             Assert.Equal("0.00000000001", light.ToString());
+
+            light = LightMoney.MilliSatoshis(200000);
+            Assert.Equal(200m, light.ToDecimal(LightMoneyUnit.Satoshi));
+            Assert.Equal(0.00000001m * 200m, light.ToDecimal(LightMoneyUnit.BTC));
         }
 
-        //[Fact]
-        //public void CanSendLightningPayment()
-        //{
+        [Fact]
+        public void CanSetLightningServer()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var storeController = tester.PayTester.GetController<StoresController>(user.UserId);
+                Assert.IsType<ViewResult>(storeController.UpdateStore(user.StoreId).GetAwaiter().GetResult());
+                Assert.IsType<ViewResult>(storeController.AddLightningNode(user.StoreId, "BTC").GetAwaiter().GetResult());
 
-        //    using (var tester = ServerTester.Create())
-        //    {
-        //        tester.Start();
-        //        tester.PrepareLightning();
-        //    }
-        //}
+                var testResult = storeController.AddLightningNode(user.StoreId, new LightningNodeViewModel()
+                {
+                    Url = tester.MerchantCharge.Client.Uri.AbsoluteUri
+                }, "test", "BTC").GetAwaiter().GetResult();
+                Assert.DoesNotContain("Error", ((LightningNodeViewModel)Assert.IsType<ViewResult>(testResult).Model).StatusMessage, StringComparison.OrdinalIgnoreCase);
+                Assert.True(storeController.ModelState.IsValid);
+
+                Assert.IsType<RedirectToActionResult>(storeController.AddLightningNode(user.StoreId, new LightningNodeViewModel()
+                {
+                    Url = tester.MerchantCharge.Client.Uri.AbsoluteUri
+                }, "save", "BTC").GetAwaiter().GetResult());
+
+                var storeVm = Assert.IsType<Models.StoreViewModels.StoreViewModel>(Assert.IsType<ViewResult>(storeController.UpdateStore(user.StoreId).GetAwaiter().GetResult()).Model);
+                Assert.Single(storeVm.LightningNodes.Where(l => !string.IsNullOrEmpty(l.Address)));
+            }
+        }
+
+        [Fact]
+        public void CanParseLightningURL()
+        {
+            LightningConnectionString conn = null;
+            Assert.True(LightningConnectionString.TryParse("/test/a", out conn));
+            Assert.Equal("unix://test/a", conn.ToString());
+            Assert.Equal("unix://test/a", conn.ToUri(true).AbsoluteUri);
+            Assert.Equal("unix://test/a", conn.ToUri(false).AbsoluteUri);
+            Assert.Equal(LightningConnectionType.CLightning, conn.ConnectionType);
+
+            Assert.True(LightningConnectionString.TryParse("unix://test/a", out conn));
+            Assert.Equal("unix://test/a", conn.ToString());
+            Assert.Equal("unix://test/a", conn.ToUri(true).AbsoluteUri);
+            Assert.Equal("unix://test/a", conn.ToUri(false).AbsoluteUri);
+            Assert.Equal(LightningConnectionType.CLightning, conn.ConnectionType);
+
+            Assert.True(LightningConnectionString.TryParse("unix://test/a", out conn));
+            Assert.Equal("unix://test/a", conn.ToString());
+            Assert.Equal("unix://test/a", conn.ToUri(true).AbsoluteUri);
+            Assert.Equal("unix://test/a", conn.ToUri(false).AbsoluteUri);
+            Assert.Equal(LightningConnectionType.CLightning, conn.ConnectionType);
+
+            Assert.True(LightningConnectionString.TryParse("tcp://test/a", out conn));
+            Assert.Equal("tcp://test/a", conn.ToString());
+            Assert.Equal("tcp://test/a", conn.ToUri(true).AbsoluteUri);
+            Assert.Equal("tcp://test/a", conn.ToUri(false).AbsoluteUri);
+            Assert.Equal(LightningConnectionType.CLightning, conn.ConnectionType);
+
+            Assert.True(LightningConnectionString.TryParse("http://aaa:bbb@test/a", out conn));
+            Assert.Equal("http://aaa:bbb@test/a", conn.ToString());
+            Assert.Equal("http://aaa:bbb@test/a", conn.ToUri(true).AbsoluteUri);
+            Assert.Equal("http://test/a", conn.ToUri(false).AbsoluteUri);
+            Assert.Equal(LightningConnectionType.Charge, conn.ConnectionType);
+            Assert.Equal("aaa", conn.Username);
+            Assert.Equal("bbb", conn.Password);
+
+            Assert.False(LightningConnectionString.TryParse("lol://aaa:bbb@test/a", out conn));
+            Assert.False(LightningConnectionString.TryParse("https://test/a", out conn));
+            Assert.False(LightningConnectionString.TryParse("unix://dwewoi:dwdwqd@test/a", out conn));
+        }
+
+        [Fact]
+        public void CanSendLightningPayment2()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                tester.PrepareLightning();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                user.RegisterLightningNode("BTC", LightningConnectionType.CLightning);
+                user.RegisterDerivationScheme("BTC");
+
+                var invoice = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Price = 0.01,
+                    Currency = "USD",
+                    PosData = "posData",
+                    OrderId = "orderId",
+                    ItemDesc = "Some description"
+                });
+
+                tester.SendLightningPayment(invoice);
+
+                Eventually(() =>
+                {
+                    var localInvoice = user.BitPay.GetInvoice(invoice.Id);
+                    Assert.Equal("complete", localInvoice.Status);
+                    Assert.Equal("False", localInvoice.ExceptionStatus.ToString());
+                });
+            }
+        }
+
+        [Fact]
+        public void CanSendLightningPayment()
+        {
+
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                tester.PrepareLightning();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                user.RegisterLightningNode("BTC", LightningConnectionType.Charge);
+                user.RegisterDerivationScheme("BTC");
+
+                var invoice = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Price = 0.01,
+                    Currency = "USD",
+                    PosData = "posData",
+                    OrderId = "orderId",
+                    ItemDesc = "Some description"
+                });
+
+                tester.SendLightningPayment(invoice);
+
+                Eventually(() =>
+                {
+                    var localInvoice = user.BitPay.GetInvoice(invoice.Id);
+                    Assert.Equal("complete", localInvoice.Status);
+                    Assert.Equal("False", localInvoice.ExceptionStatus.ToString());
+                });
+
+
+                Task.WaitAll(Enumerable.Range(0, 5)
+                    .Select(_ => CanSendLightningPaymentCore(tester, user))
+                    .ToArray());
+            }
+        }
+
+        async Task CanSendLightningPaymentCore(ServerTester tester, TestAccount user)
+        {
+            await Task.Delay(TimeSpan.FromSeconds(RandomUtils.GetUInt32() % 5));
+            var invoice = await user.BitPay.CreateInvoiceAsync(new Invoice()
+            {
+                Price = 0.01,
+                Currency = "USD",
+                PosData = "posData",
+                OrderId = "orderId",
+                ItemDesc = "Some description"
+            });
+            await tester.SendLightningPaymentAsync(invoice);
+            await EventuallyAsync(async () =>
+            {
+                var localInvoice = await user.BitPay.GetInvoiceAsync(invoice.Id);
+                Assert.Equal("complete", localInvoice.Status);
+                Assert.Equal("False", localInvoice.ExceptionStatus.ToString());
+            });
+        }
 
         [Fact]
         public void CanUseServerInitiatedPairingCode()
@@ -272,6 +490,7 @@ namespace BTCPayServer.Tests
                     tester.Start();
                     var acc = tester.NewAccount();
                     acc.GrantAccess();
+                    acc.RegisterDerivationScheme("BTC");
                     var invoice = acc.BitPay.CreateInvoice(new Invoice()
                     {
                         Price = 5.0,
@@ -312,7 +531,7 @@ namespace BTCPayServer.Tests
                 pairingCode = acc.BitPay.RequestClientAuthorization("test1", Facade.Merchant);
                 var store2 = acc.CreateStore();
                 store2.Pair(pairingCode.ToString(), store2.CreatedStoreId).GetAwaiter().GetResult();
-                Assert.Contains(nameof(PairingResult.ReusedKey), store2.StatusMessage);
+                Assert.Contains(nameof(PairingResult.ReusedKey), store2.StatusMessage, StringComparison.CurrentCultureIgnoreCase);
             }
         }
 
@@ -324,17 +543,17 @@ namespace BTCPayServer.Tests
                 tester.Start();
                 var user = tester.NewAccount();
                 user.GrantAccess();
+                user.RegisterDerivationScheme("BTC");
                 var invoice = user.BitPay.CreateInvoice(new Invoice()
                 {
                     Price = 5000.0,
                     Currency = "USD"
                 }, Facade.Merchant);
-
-                var payment1 = Money.Coins(0.04m);
-                var payment2 = Money.Coins(0.08m);
+                var payment1 = invoice.BtcDue + Money.Coins(0.0001m);
+                var payment2 = invoice.BtcDue;
                 var tx1 = new uint256(tester.ExplorerNode.SendCommand("sendtoaddress", new object[]
                 {
-                    invoice.BitcoinAddress.ToString(),
+                    invoice.BitcoinAddress,
                     payment1.ToString(),
                     null, //comment
                     null, //comment_to
@@ -347,6 +566,8 @@ namespace BTCPayServer.Tests
                 {
                     invoice = user.BitPay.GetInvoice(invoice.Id);
                     Assert.Equal(payment1, invoice.BtcPaid);
+                    Assert.Equal("paid", invoice.Status);
+                    Assert.Equal("paidOver", invoice.ExceptionStatus.ToString());
                     invoiceAddress = BitcoinAddress.Create(invoice.BitcoinAddress, user.SupportedNetwork.NBitcoinNetwork);
                 });
 
@@ -355,11 +576,9 @@ namespace BTCPayServer.Tests
                 {
                     input.ScriptSig = Script.Empty; //Strip signatures
                 }
-                var change = tx.Outputs.First(o => o.Value != payment1);
                 var output = tx.Outputs.First(o => o.Value == payment1);
                 output.Value = payment2;
                 output.ScriptPubKey = invoiceAddress.ScriptPubKey;
-                change.Value -= (payment2 - payment1) * 2; //Add more fees
                 var replaced = tester.ExplorerNode.SignRawTransaction(tx);
                 tester.ExplorerNode.SendRawTransaction(replaced);
                 var test = tester.ExplorerClient.GetUTXOs(user.DerivationScheme, null);
@@ -367,6 +586,7 @@ namespace BTCPayServer.Tests
                 {
                     invoice = user.BitPay.GetInvoice(invoice.Id);
                     Assert.Equal(payment2, invoice.BtcPaid);
+                    Assert.Equal("False", invoice.ExceptionStatus.ToString());
                 });
             }
         }
@@ -391,6 +611,7 @@ namespace BTCPayServer.Tests
                 var user = tester.NewAccount();
                 Assert.False(user.BitPay.TestAccess(Facade.Merchant));
                 user.GrantAccess();
+                user.RegisterDerivationScheme("BTC");
                 Assert.True(user.BitPay.TestAccess(Facade.Merchant));
             }
         }
@@ -404,7 +625,7 @@ namespace BTCPayServer.Tests
                 tester.Start();
                 var user = tester.NewAccount();
                 user.GrantAccess();
-
+                user.RegisterDerivationScheme("BTC");
 
                 // First we try payment with a merchant having only BTC
                 var invoice1 = user.BitPay.CreateInvoice(new Invoice()
@@ -446,8 +667,8 @@ namespace BTCPayServer.Tests
             {
                 tester.Start();
                 var user = tester.NewAccount();
-                user.CryptoCode = "LTC";
                 user.GrantAccess();
+                user.RegisterDerivationScheme("LTC");
 
                 // First we try payment with a merchant having only BTC
                 var invoice = user.BitPay.CreateInvoice(new Invoice()
@@ -506,7 +727,7 @@ namespace BTCPayServer.Tests
                 tester.Start();
                 var user = tester.NewAccount();
                 user.GrantAccess();
-
+                user.RegisterDerivationScheme("BTC");
                 // First we try payment with a merchant having only BTC
                 var invoice = user.BitPay.CreateInvoice(new Invoice()
                 {
@@ -519,6 +740,7 @@ namespace BTCPayServer.Tests
                 }, Facade.Merchant);
 
                 var cashCow = tester.ExplorerNode;
+                cashCow.Generate(2); // get some money in case
                 var invoiceAddress = BitcoinAddress.Create(invoice.BitcoinAddress, cashCow.Network);
                 var firstPayment = Money.Coins(0.04m);
                 cashCow.SendToAddress(invoiceAddress, firstPayment);
@@ -553,6 +775,7 @@ namespace BTCPayServer.Tests
                 invoiceAddress = BitcoinAddress.Create(invoice.BitcoinAddress, cashCow.Network);
                 firstPayment = Money.Coins(0.04m);
                 cashCow.SendToAddress(invoiceAddress, firstPayment);
+                Logs.Tester.LogInformation("First payment sent to " + invoiceAddress);
                 Eventually(() =>
                 {
                     invoice = user.BitPay.GetInvoice(invoice.Id);
@@ -563,10 +786,10 @@ namespace BTCPayServer.Tests
                 var ltcCryptoInfo = invoice.CryptoInfo.FirstOrDefault(c => c.CryptoCode == "LTC");
                 Assert.NotNull(ltcCryptoInfo);
                 invoiceAddress = BitcoinAddress.Create(ltcCryptoInfo.Address, cashCow.Network);
-                var secondPayment = Money.Coins(decimal.Parse(ltcCryptoInfo.Due));
+                var secondPayment = Money.Coins(decimal.Parse(ltcCryptoInfo.Due, CultureInfo.InvariantCulture));
                 cashCow.Generate(2); // LTC is not worth a lot, so just to make sure we have money...
                 cashCow.SendToAddress(invoiceAddress, secondPayment);
-
+                Logs.Tester.LogInformation("Second payment sent to " + invoiceAddress);
                 Eventually(() =>
                 {
                     invoice = user.BitPay.GetInvoice(invoice.Id);
@@ -585,6 +808,185 @@ namespace BTCPayServer.Tests
             }
         }
 
+        [Fact]
+        public void CanParseCurrencyValue()
+        {
+            Assert.True(CurrencyValue.TryParse("1.50USD", out var result));
+            Assert.Equal("1.50 USD", result.ToString());
+            Assert.True(CurrencyValue.TryParse("1.50 USD", out result));
+            Assert.Equal("1.50 USD", result.ToString());
+            Assert.True(CurrencyValue.TryParse("1.50 usd", out result));
+            Assert.Equal("1.50 USD", result.ToString());
+            Assert.True(CurrencyValue.TryParse("1 usd", out result));
+            Assert.Equal("1 USD", result.ToString());
+            Assert.True(CurrencyValue.TryParse("1usd", out result));
+            Assert.Equal("1 USD", result.ToString());
+            Assert.True(CurrencyValue.TryParse("1.501 usd", out result));
+            Assert.Equal("1.50 USD", result.ToString());
+            Assert.False(CurrencyValue.TryParse("1.501 WTFF", out result));
+            Assert.False(CurrencyValue.TryParse("1,501 usd", out result));
+            Assert.False(CurrencyValue.TryParse("1.501", out result));
+        }
+
+        [Fact]
+        public void CanParseDerivationScheme()
+        {
+            var parser = new DerivationSchemeParser(Network.TestNet, NBXplorer.ChainType.Test);
+            NBXplorer.DerivationStrategy.DerivationStrategyBase result;
+            //  Passing electrum stuff
+            // Native
+            result = parser.Parse("zpub6nL6PUGurpU3DfPDSZaRS6WshpbNc9ctCFFzrCn54cssnheM31SZJZUcFHKtjJJNhAueMbh6ptFMfy1aeiMQJr3RJ4DDt1hAPx7sMTKV48t");
+            Assert.Equal("tpubD93CJNkmGjLXnsBqE2zGDqfEh1Q8iJ8wueordy3SeWt1RngbbuxXCsqASuVWFywmfoCwUE1rSfNJbaH4cBNcbp8WcyZgPiiRSTazLGL8U9w", result.ToString());
+            // P2SH
+            result = parser.Parse("ypub6QqdH2c5z79681jUgdxjGJzGW9zpL4ryPCuhtZE4GpvrJoZqM823XQN6iSQeVbbbp2uCRQ9UgpeMcwiyV6qjvxTWVcxDn2XEAnioMUwsrQ5");
+            Assert.Equal("tpubD6NzVbkrYhZ4YWjDJUACG9E8fJx2NqNY1iynTiPKEjJrzzRKAgha3nNnwGXr2BtvCJKJHW4nmG7rRqc2AGGy2AECgt16seMyV2FZivUmaJg-[p2sh]", result.ToString());
+            result = parser.Parse("xpub661MyMwAqRbcGeVGU5e5KBcau1HHEUGf9Wr7k4FyLa8yRPNQrrVa7Ndrgg8Afbe2UYXMSL6tJBFd2JewwWASsePPLjkcJFL1tTVEs3UQ23X");
+            Assert.Equal("tpubD6NzVbkrYhZ4YSg7vGdAX6wxE8NwDrmih9SR6cK7gUtsAg37w5LfFpJgviCxC6bGGT4G3uckqH5fiV9ZLN1gm5qgQLVuymzFUR5ed7U7ksu-[legacy]", result.ToString());
+            ////////////////
+
+            var tpub = "tpubD6NzVbkrYhZ4Wc65tjhmcKdWFauAo7bGLRTxvggygkNyp6SMGutJp7iociwsinU33jyNBp1J9j2hJH5yQsayfiS3LEU2ZqXodAcnaygra8o";
+
+            result = parser.Parse(tpub);
+            Assert.Equal(tpub, result.ToString());
+            parser.HintScriptPubKey = BitcoinAddress.Create("tb1q4s33amqm8l7a07zdxcunqnn3gcsjcfz3xc573l", parser.Network).ScriptPubKey;
+            result = parser.Parse(tpub);
+            Assert.Equal(tpub, result.ToString());
+
+            parser.HintScriptPubKey = BitcoinAddress.Create("2N2humNio3YTApSfY6VztQ9hQwDnhDvaqFQ", parser.Network).ScriptPubKey;
+            result = parser.Parse(tpub);
+            Assert.Equal($"{tpub}-[p2sh]", result.ToString());
+
+            parser.HintScriptPubKey = BitcoinAddress.Create("mwD8bHS65cdgUf6rZUUSoVhi3wNQFu1Nfi", parser.Network).ScriptPubKey;
+            result = parser.Parse(tpub);
+            Assert.Equal($"{tpub}-[legacy]", result.ToString());
+
+            parser.HintScriptPubKey = BitcoinAddress.Create("2N2humNio3YTApSfY6VztQ9hQwDnhDvaqFQ", parser.Network).ScriptPubKey;
+            result = parser.Parse($"{tpub}-[legacy]");
+            Assert.Equal($"{tpub}-[p2sh]", result.ToString());
+
+            result = parser.Parse(tpub);
+            Assert.Equal($"{tpub}-[p2sh]", result.ToString());
+        }
+
+        [Fact]
+        public void CanSetPaymentMethodLimits()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                user.RegisterDerivationScheme("BTC");
+                user.RegisterLightningNode("BTC", LightningConnectionType.Charge);
+                var vm = Assert.IsType<CheckoutExperienceViewModel>(Assert.IsType<ViewResult>(user.GetController<StoresController>().CheckoutExperience(user.StoreId).Result).Model);
+                vm.LightningMaxValue = "2 USD";
+                vm.OnChainMinValue = "5 USD";
+                Assert.IsType<RedirectToActionResult>(user.GetController<StoresController>().CheckoutExperience(user.StoreId, vm).Result);
+
+                var invoice = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Price = 1.5,
+                    Currency = "USD",
+                    PosData = "posData",
+                    OrderId = "orderId",
+                    ItemDesc = "Some description",
+                    FullNotifications = true
+                }, Facade.Merchant);
+
+                Assert.Single(invoice.CryptoInfo);
+                Assert.Equal(PaymentTypes.LightningLike.ToString(), invoice.CryptoInfo[0].PaymentType);
+
+                invoice = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Price = 5.5,
+                    Currency = "USD",
+                    PosData = "posData",
+                    OrderId = "orderId",
+                    ItemDesc = "Some description",
+                    FullNotifications = true
+                }, Facade.Merchant);
+
+                Assert.Single(invoice.CryptoInfo);
+                Assert.Equal(PaymentTypes.BTCLike.ToString(), invoice.CryptoInfo[0].PaymentType);
+            }
+        }
+
+        [Fact]
+        public void CanUsePoSApp()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                user.RegisterDerivationScheme("BTC");
+                var apps = user.GetController<AppsController>();
+                var vm = Assert.IsType<CreateAppViewModel>(Assert.IsType<ViewResult>(apps.CreateApp().Result).Model);
+                vm.Name = "test";
+                vm.SelectedAppType = AppType.PointOfSale.ToString();
+                Assert.IsType<RedirectToActionResult>(apps.CreateApp(vm).Result);
+                var appId = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps().Result).Model).Apps[0].Id;
+                var vmpos = Assert.IsType<UpdatePointOfSaleViewModel>(Assert.IsType<ViewResult>(apps.UpdatePointOfSale(appId).Result).Model);
+                vmpos.Title = "hello";
+                vmpos.Currency = "CAD";
+                vmpos.Template =
+                    "apple:\n" +
+                    "  price: 5.0\n" +
+                    "  title: good apple\n" +
+                    "orange:\n" +
+                    "  price: 10.0\n";
+                Assert.IsType<RedirectToActionResult>(apps.UpdatePointOfSale(appId, vmpos).Result);
+                vmpos = Assert.IsType<UpdatePointOfSaleViewModel>(Assert.IsType<ViewResult>(apps.UpdatePointOfSale(appId).Result).Model);
+                Assert.Equal("hello", vmpos.Title);
+                var vmview = Assert.IsType<ViewPointOfSaleViewModel>(Assert.IsType<ViewResult>(apps.ViewPointOfSale(appId).Result).Model);
+                Assert.Equal("hello", vmview.Title);
+                Assert.Equal(2, vmview.Items.Length);
+                Assert.Equal("good apple", vmview.Items[0].Title);
+                Assert.Equal("orange", vmview.Items[1].Title);
+                Assert.Equal(10.0m, vmview.Items[1].Price.Value);
+                Assert.Equal("$5.00", vmview.Items[0].Price.Formatted);
+                Assert.IsType<RedirectResult>(apps.ViewPointOfSale(appId, "orange").Result);
+                var invoice = user.BitPay.GetInvoices().First();
+                Assert.Equal(10.00, invoice.Price);
+                Assert.Equal("CAD", invoice.Currency);
+                Assert.Equal("orange", invoice.ItemDesc);
+            }
+        }
+
+        [Fact]
+        public void CanCreateAndDeleteApps()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var user2 = tester.NewAccount();
+                user2.GrantAccess();
+                var apps = user.GetController<AppsController>();
+                var apps2 = user2.GetController<AppsController>();
+                var vm = Assert.IsType<CreateAppViewModel>(Assert.IsType<ViewResult>(apps.CreateApp().Result).Model);
+                Assert.NotNull(vm.SelectedAppType);
+                Assert.Null(vm.Name);
+                vm.Name = "test";
+                var redirectToAction = Assert.IsType<RedirectToActionResult>(apps.CreateApp(vm).Result);
+                Assert.Equal(nameof(apps.ListApps), redirectToAction.ActionName);
+                var appList = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps().Result).Model);
+                var appList2 = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps2.ListApps().Result).Model);
+                Assert.Single(appList.Apps);
+                Assert.Empty(appList2.Apps);
+                Assert.Equal("test", appList.Apps[0].AppName);
+                Assert.True(appList.Apps[0].IsOwner);
+                Assert.Equal(user.StoreId, appList.Apps[0].StoreId);
+                Assert.IsType<NotFoundResult>(apps2.DeleteApp(appList.Apps[0].Id).Result);
+                Assert.IsType<ViewResult>(apps.DeleteApp(appList.Apps[0].Id).Result);
+                redirectToAction = Assert.IsType<RedirectToActionResult>(apps.DeleteAppPost(appList.Apps[0].Id).Result);
+                Assert.Equal(nameof(apps.ListApps), redirectToAction.ActionName);
+                appList = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps().Result).Model);
+                Assert.Empty(appList.Apps);
+            }
+        }
+
         [Fact]
         public void InvoiceFlowThroughDifferentStatesCorrectly()
         {
@@ -593,6 +995,7 @@ namespace BTCPayServer.Tests
                 tester.Start();
                 var user = tester.NewAccount();
                 user.GrantAccess();
+                user.RegisterDerivationScheme("BTC");
                 var invoice = user.BitPay.CreateInvoice(new Invoice()
                 {
                     Price = 5000.0,
@@ -604,7 +1007,7 @@ namespace BTCPayServer.Tests
                 }, Facade.Merchant);
                 var repo = tester.PayTester.GetService<InvoiceRepository>();
                 var ctx = tester.PayTester.GetService<ApplicationDbContextFactory>().CreateContext();
-
+                Assert.Equal(0, invoice.CryptoInfo[0].TxCount);
                 Eventually(() =>
                 {
                     var textSearchResult = tester.PayTester.InvoiceRepository.GetInvoices(new InvoiceQuery()
@@ -627,11 +1030,11 @@ namespace BTCPayServer.Tests
                 Assert.Equal("new", invoice.Status);
                 Assert.False((bool)((JValue)invoice.ExceptionStatus).Value);
 
-                Assert.Single(user.BitPay.GetInvoices(invoice.InvoiceTime.DateTime));
-                Assert.Empty(user.BitPay.GetInvoices(invoice.InvoiceTime.DateTime + TimeSpan.FromDays(1)));
-                Assert.Single(user.BitPay.GetInvoices(invoice.InvoiceTime.DateTime - TimeSpan.FromDays(5)));
-                Assert.Single(user.BitPay.GetInvoices(invoice.InvoiceTime.DateTime - TimeSpan.FromDays(5), invoice.InvoiceTime.DateTime));
-                Assert.Empty(user.BitPay.GetInvoices(invoice.InvoiceTime.DateTime - TimeSpan.FromDays(5), invoice.InvoiceTime.DateTime - TimeSpan.FromDays(1)));
+                Assert.Single(user.BitPay.GetInvoices(invoice.InvoiceTime.UtcDateTime));
+                Assert.Empty(user.BitPay.GetInvoices(invoice.InvoiceTime.UtcDateTime + TimeSpan.FromDays(2)));
+                Assert.Single(user.BitPay.GetInvoices(invoice.InvoiceTime.UtcDateTime - TimeSpan.FromDays(5)));
+                Assert.Single(user.BitPay.GetInvoices(invoice.InvoiceTime.UtcDateTime - TimeSpan.FromDays(5), invoice.InvoiceTime.DateTime + TimeSpan.FromDays(1.0)));
+                Assert.Empty(user.BitPay.GetInvoices(invoice.InvoiceTime.UtcDateTime - TimeSpan.FromDays(5), invoice.InvoiceTime.DateTime - TimeSpan.FromDays(1)));
 
 
                 var firstPayment = Money.Coins(0.04m);
@@ -660,14 +1063,15 @@ namespace BTCPayServer.Tests
                     Assert.Equal(firstPayment, localInvoice.BtcPaid);
                     txFee = localInvoice.BtcDue - invoice.BtcDue;
                     Assert.Equal("paidPartial", localInvoice.ExceptionStatus.ToString());
+                    Assert.Equal(1, localInvoice.CryptoInfo[0].TxCount);
                     Assert.NotEqual(localInvoice.BitcoinAddress, invoice.BitcoinAddress); //New address
                     Assert.True(IsMapped(invoice, ctx));
                     Assert.True(IsMapped(localInvoice, ctx));
 
                     invoiceEntity = repo.GetInvoice(null, invoice.Id, true).GetAwaiter().GetResult();
-                    var historical1 = invoiceEntity.HistoricalAddresses.FirstOrDefault(h => h.GetAddress() == invoice.BitcoinAddress.ToString());
+                    var historical1 = invoiceEntity.HistoricalAddresses.FirstOrDefault(h => h.GetAddress() == invoice.BitcoinAddress);
                     Assert.NotNull(historical1.UnAssigned);
-                    var historical2 = invoiceEntity.HistoricalAddresses.FirstOrDefault(h => h.GetAddress() == localInvoice.BitcoinAddress.ToString());
+                    var historical2 = invoiceEntity.HistoricalAddresses.FirstOrDefault(h => h.GetAddress() == localInvoice.BitcoinAddress);
                     Assert.Null(historical2.UnAssigned);
                     invoiceAddress = BitcoinAddress.Create(localInvoice.BitcoinAddress, cashCow.Network);
                     secondPayment = localInvoice.BtcDue;
@@ -679,6 +1083,7 @@ namespace BTCPayServer.Tests
                 {
                     var localInvoice = user.BitPay.GetInvoice(invoice.Id, Facade.Merchant);
                     Assert.Equal("paid", localInvoice.Status);
+                    Assert.Equal(2, localInvoice.CryptoInfo[0].TxCount);
                     Assert.Equal(firstPayment + secondPayment, localInvoice.BtcPaid);
                     Assert.Equal(Money.Zero, localInvoice.BtcDue);
                     Assert.Equal(localInvoice.BitcoinAddress, invoiceAddress.ToString()); //no new address generated
@@ -759,13 +1164,13 @@ namespace BTCPayServer.Tests
 
         private static bool IsMapped(Invoice invoice, ApplicationDbContext ctx)
         {
-            var h = BitcoinAddress.Create(invoice.BitcoinAddress).ScriptPubKey.Hash;
-            return ctx.AddressInvoices.FirstOrDefault(i => i.InvoiceDataId == invoice.Id && i.GetHash() == h) != null;
+            var h = BitcoinAddress.Create(invoice.BitcoinAddress).ScriptPubKey.Hash.ToString();
+            return ctx.AddressInvoices.FirstOrDefault(i => i.InvoiceDataId == invoice.Id && i.GetAddress() == h) != null;
         }
 
         private void Eventually(Action act)
         {
-            CancellationTokenSource cts = new CancellationTokenSource(10000);
+            CancellationTokenSource cts = new CancellationTokenSource(20000);
             while (true)
             {
                 try
@@ -779,5 +1184,22 @@ namespace BTCPayServer.Tests
                 }
             }
         }
+
+        private async Task EventuallyAsync(Func<Task> act)
+        {
+            CancellationTokenSource cts = new CancellationTokenSource(20000);
+            while (true)
+            {
+                try
+                {
+                    await act();
+                    break;
+                }
+                catch (XunitException) when (!cts.Token.IsCancellationRequested)
+                {
+                    await Task.Delay(500);
+                }
+            }
+        }
     }
 }

BTCPayServer.Tests/UnitTestPeusa.cs

@@ -13,25 +13,27 @@ namespace BTCPayServer.Tests
     {
         // 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);
+        // Testnet of Bitpay down
+        //[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()
+        //    {
 
-            // go to invoice.Url
-            Console.WriteLine(invoice.Url);
-        }
+        //        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]

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"    
 
 # 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:
 
@@ -17,17 +17,23 @@ services:
       TESTS_POSTGRES: User ID=postgres;Host=postgres;Port=5432;Database=btcpayserver
       TESTS_PORT: 80
       TESTS_HOSTNAME: tests
+      TEST_MERCHANTLIGHTNINGD: "/etc/merchant_lightningd_datadir/lightning-rpc"
+      TEST_CUSTOMERLIGHTNINGD: "/etc/customer_lightningd_datadir/lightning-rpc"
+      TEST_MERCHANTCHARGE: http://api-token:foiewnccewuify@lightning-charged:9112/
+      TESTS_INCONTAINER: "true"
     expose:
       - "80"
     links:
-      - nbxplorer
-      - postgres
+      - 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
@@ -35,9 +41,12 @@ services:
     links:
       - nbxplorer
       - postgres
+      - customer_lightningd
+      - merchant_lightningd
+      - lightning-charged
 
   nbxplorer:
-    image: nicolasdorier/nbxplorer:1.0.1.3
+    image: nicolasdorier/nbxplorer:1.0.1.25
     ports:
       - "32838:32838"
     expose: 
@@ -61,8 +70,7 @@ services:
       - 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
@@ -77,10 +85,72 @@ services:
     expose:
       - "43782" # RPC
       - "39388" # P2P
+    volumes:
+      - "bitcoin_datadir:/data"
+
+  customer_lightningd:
+    image: nicolasdorier/clightning:0.0.0.2
+    environment: 
+      EXPOSE_TCP: "true"
+      LIGHTNINGD_OPT: |
+        bitcoin-datadir=/etc/bitcoin
+        bitcoin-rpcconnect=bitcoind
+        network=regtest
+        ipaddr=customer_lightningd
+        log-level=debug
+    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.7
+    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.2
+    environment: 
+      EXPOSE_TCP: "true"
+      LIGHTNINGD_OPT: |
+        bitcoin-datadir=/etc/bitcoin
+        bitcoin-rpcconnect=bitcoind
+        ipaddr=merchant_lightningd
+        network=regtest
+        log-level=debug
+    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:
-    container_name: btcpayserver_dev_litecoind
-    image: nicolasdorier/docker-litecoin:0.14.2
+    image: nicolasdorier/docker-litecoin:0.15.1
     environment:
       BITCOIN_EXTRA_ARGS: |
         rpcuser=ceiwHEbqWI83
@@ -102,3 +172,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

@@ -1 +1 @@
-docker exec -ti btcpayserver_dev_litecoind litecoin-cli -regtest -conf="/data/litecoin.conf" -datadir="/data" $args
+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/BTCPayNetwork.cs

@@ -3,6 +3,7 @@ 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;
@@ -61,13 +62,16 @@ namespace BTCPayServer
         }
 
         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 override string ToString()
         {
             return CryptoCode;
-        }
+        }        
     }
 }

BTCPayServer/BTCPayNetworkProvider.Bitcoin.cs

@@ -20,13 +20,15 @@ namespace BTCPayServer
             Add(new BTCPayNetwork()
             {
                 CryptoCode = nbxplorerNetwork.CryptoCode,
-                BlockExplorerLink = NBXplorerNetworkProvider.ChainType == ChainType.Main? "https://www.smartbit.com.au/tx/{0}" : "https://testnet.smartbit.com.au/tx/{0}",
+                BlockExplorerLink = NBXplorerNetworkProvider.ChainType == ChainType.Main ? "https://www.smartbit.com.au/tx/{0}" : "https://testnet.smartbit.com.au/tx/{0}",
                 NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
                 NBXplorerNetwork = nbxplorerNetwork,
                 UriScheme = "bitcoin",
                 DefaultRateProvider = btcRate,
                 CryptoImagePath = "imlegacy/bitcoin-symbol.svg",
-                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NBXplorerNetworkProvider.ChainType)
+                LightningImagePath = "imlegacy/btc-lightning.svg",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NBXplorerNetworkProvider.ChainType),
+                CoinType = NBXplorerNetworkProvider.ChainType == ChainType.Main ? new KeyPath("0'") : new KeyPath("1'")
             });
         }
     }

BTCPayServer/BTCPayNetworkProvider.Litecoin.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using BTCPayServer.Services.Rates;
+using NBitcoin;
 using NBXplorer;
 
 namespace BTCPayServer
@@ -11,7 +12,7 @@ namespace BTCPayServer
     {
         public void InitLitecoin()
         {
-            NBXplorer.Altcoins.Litecoin.Networks.EnsureRegistered();
+            NBitcoin.Altcoins.Litecoin.EnsureRegistered();
             var ltcRate = new CoinAverageRateProvider("LTC");
 
             var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("LTC");
@@ -24,7 +25,9 @@ namespace BTCPayServer
                 UriScheme = "litecoin",
                 DefaultRateProvider = ltcRate,
                 CryptoImagePath = "imlegacy/litecoin-symbol.svg",
-                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NBXplorerNetworkProvider.ChainType)
+                LightningImagePath = "imlegacy/ltc-lightning.svg",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NBXplorerNetworkProvider.ChainType),
+                CoinType = NBXplorerNetworkProvider.ChainType == ChainType.Main ? new KeyPath("2'") : new KeyPath("3'")
             });
         }
     }

BTCPayServer/BTCPayNetworkProvider.cs

@@ -25,13 +25,40 @@ namespace BTCPayServer
             }
         }
 
+        BTCPayNetworkProvider(BTCPayNetworkProvider filtered, string[] cryptoCodes)
+        {
+            ChainType = filtered.ChainType;
+            _NBXplorerNetworkProvider = new NBXplorerNetworkProvider(filtered.ChainType);
+            _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 ChainType ChainType { get; set; }
         public BTCPayNetworkProvider(ChainType chainType)
         {
             _NBXplorerNetworkProvider = new NBXplorerNetworkProvider(chainType);
+            ChainType = chainType;
             InitBitcoin();
             InitLitecoin();
         }
 
+        /// <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
         {
@@ -43,7 +70,7 @@ namespace BTCPayServer
 
         public void Add(BTCPayNetwork network)
         {
-            _Networks.Add(network.CryptoCode, network);
+            _Networks.Add(network.CryptoCode.ToUpperInvariant(), network);
         }
 
         public IEnumerable<BTCPayNetwork> GetAll()
@@ -51,6 +78,11 @@ namespace BTCPayServer
             return _Networks.Values.ToArray();
         }
 
+        public bool Support(string cryptoCode)
+        {
+            return _Networks.ContainsKey(cryptoCode.ToUpperInvariant());
+        }
+
         public BTCPayNetwork GetNetwork(string cryptoCode)
         {
             _Networks.TryGetValue(cryptoCode.ToUpperInvariant(), out BTCPayNetwork network);

BTCPayServer/BTCPayServer.csproj

@@ -2,13 +2,22 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp2.0</TargetFramework>
-		<Version>1.0.1.13</Version>
+		<Version>1.0.1.76</Version>
+    <NoWarn>NU1701,CA1816,CA1308,CA1810,CA2208</NoWarn>
   </PropertyGroup>
   <ItemGroup>
     <Compile Remove="Build\dockerfiles\**" />
+    <Compile Remove="wwwroot\bundles\jqueryvalidate\**" />
+    <Compile Remove="wwwroot\vendor\jquery-nice-select\**" />
     <Content Remove="Build\dockerfiles\**" />
+    <Content Remove="wwwroot\bundles\jqueryvalidate\**" />
+    <Content Remove="wwwroot\vendor\jquery-nice-select\**" />
     <EmbeddedResource Remove="Build\dockerfiles\**" />
+    <EmbeddedResource Remove="wwwroot\bundles\jqueryvalidate\**" />
+    <EmbeddedResource Remove="wwwroot\vendor\jquery-nice-select\**" />
     <None Remove="Build\dockerfiles\**" />
+    <None Remove="wwwroot\bundles\jqueryvalidate\**" />
+    <None Remove="wwwroot\vendor\jquery-nice-select\**" />
   </ItemGroup>
   <ItemGroup>
     <None Remove="Currencies.txt" />
@@ -17,26 +26,32 @@
     <EmbeddedResource Include="Currencies.txt" />
   </ItemGroup>
   <ItemGroup>
+    <PackageReference Include="BuildBundlerMinifier" Version="2.6.362" />
     <PackageReference Include="Hangfire" Version="1.6.17" />
     <PackageReference Include="Hangfire.MemoryStorage" Version="1.5.2" />
     <PackageReference Include="Hangfire.PostgreSql" Version="1.4.8.1" />
+    <PackageReference Include="LedgerWallet" Version="1.0.1.32" />
+    <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.52" />
-    <PackageReference Include="NBitpayClient" Version="1.0.0.16" />	  
+    <PackageReference Include="Microsoft.NetCore.Analyzers" Version="2.6.0" />
+    <PackageReference Include="NBitcoin" Version="4.1.0.3" />
+    <PackageReference Include="NBitpayClient" Version="1.0.0.18" />	  
     <PackageReference Include="DBreeze" Version="1.87.0" />
-    <PackageReference Include="NBXplorer.Client" Version="1.0.1.2" />
+    <PackageReference Include="NBXplorer.Client" Version="1.0.1.17" />
     <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.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.5" />
-		<PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="2.0.1" PrivateAssets="All" />
-		<PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="2.0.2" 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,7 +61,7 @@
 	</ItemGroup>
 
 	<ItemGroup>
-	  <None Include="wwwroot\js\core.js" />
+	  <None Include="wwwroot\js\checkout\core.js" />
 	  <None Include="wwwroot\js\creative.js" />
 	  <None Include="wwwroot\js\creative.min.js" />
 	  <None Include="wwwroot\js\site.js" />
@@ -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/Configuration/BTCPayServerOptions.cs

@@ -10,6 +10,7 @@ using System.Text;
 using StandardConfiguration;
 using Microsoft.Extensions.Configuration;
 using NBXplorer;
+using BTCPayServer.Payments.Lightning;
 
 namespace BTCPayServer.Configuration
 {
@@ -58,28 +59,50 @@ namespace BTCPayServer.Configuration
             var supportedChains = conf.GetOrDefault<string>("chains", "btc")
                                       .Split(',', StringSplitOptions.RemoveEmptyEntries)
                                       .Select(t => t.ToUpperInvariant());
-            var validChains = new List<string>();
-            foreach (var net in new BTCPayNetworkProvider(ChainType).GetAll())
+            NetworkProvider = new BTCPayNetworkProvider(ChainType).Filter(supportedChains.ToArray());
+            foreach (var chain in supportedChains)
             {
-                if (supportedChains.Contains(net.CryptoCode))
+                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)
                 {
-                    validChains.Add(net.CryptoCode);
-                    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);
+                    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);
                 }
             }
-            var invalidChains = String.Join(',', supportedChains.Where(s => !validChains.Contains(s)).ToArray());
-            if(!string.IsNullOrEmpty(invalidChains))
-                throw new ConfigException($"Invalid chains {invalidChains}");
 
             Logs.Configuration.LogInformation("Supported chains: " + String.Join(',', supportedChains.ToArray()));
-            PostgresConnectionString = conf.GetOrDefault<string>("postgres", null);
-            ExternalUrl = conf.GetOrDefault<Uri>("externalurl", null);
-        }
 
+            PostgresConnectionString = conf.GetOrDefault<string>("postgres", null);
+            BundleJsCss = conf.GetOrDefault<bool>("bundlejscss", true);
+            ExternalUrl = conf.GetOrDefault<Uri>("externalurl", null);
+
+            RootPath = conf.GetOrDefault<string>("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;
@@ -90,5 +113,10 @@ namespace BTCPayServer.Configuration
             get;
             set;
         }
+        public bool BundleJsCss
+        {
+            get;
+            set;
+        }
     }
 }

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

@@ -31,13 +31,16 @@ namespace BTCPayServer.Configuration
             app.Option("--regtest | -regtest", $"Use regtest (Deprecated, use --network instead)", CommandOptionType.BoolValue);
             app.Option("--chains | -c", $"Chains to support comma separated (default: btc, available: {chains})", CommandOptionType.SingleValue);
             app.Option("--postgres", $"Connection string to postgres database (default: sqlite is used)", CommandOptionType.SingleValue);
+            app.Option("--externalurl", $"The expected external url of this service, to use if BTCPay is behind a reverse proxy (default: empty, use the incoming HTTP request to figure out)", CommandOptionType.SingleValue);
+            app.Option("--bundlejscss", $"Bundle javascript and css files for better performance (default: true)", CommandOptionType.SingleValue);
+            app.Option("--rootpath", "The root path in the URL to access BTCPay (default: /)", CommandOptionType.SingleValue);
             foreach (var network in provider.GetAll())
             {
                 var crypto = network.CryptoCode.ToLowerInvariant();
                 app.Option($"--{crypto}explorerurl", $"Url of the NBxplorer for {network.CryptoCode} (default: {network.NBXplorerNetwork.DefaultSettings.DefaultUrl})", CommandOptionType.SingleValue);
                 app.Option($"--{crypto}explorercookiefile", $"Path to the cookie file (default: {network.NBXplorerNetwork.DefaultSettings.DefaultCookieFile})", CommandOptionType.SingleValue);
+                app.Option($"--{crypto}lightning", $"Easy configuration of lightning for the server adnistrator: Must be a unix socket of CLightning (lightning-rpc) or URL to a charge server (default: empty)", CommandOptionType.SingleValue);
             }
-            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);
             return app;
         }
 
@@ -103,6 +106,8 @@ namespace BTCPayServer.Configuration
             {
                 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();
         }

BTCPayServer/Controllers/AccountController.cs

@@ -150,7 +150,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 +204,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);
 

BTCPayServer/Controllers/AppsController.PointOfSale.cs

@@ -0,0 +1,198 @@
+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";
+            }
+            public string Title { get; set; }
+            public string Currency { get; set; }
+            public string Template { 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, 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,
+                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>();
+            return View(new ViewPointOfSaleViewModel()
+            {
+                Title = settings.Title,
+                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, string choiceKey)
+        {
+            var app = await GetApp(appId, AppType.PointOfSale);
+            if (app == null)
+                return NotFound();
+            var settings = app.GetSettings<PointOfSaleSettings>();
+            var choices = Parse(settings.Template, settings.Currency);
+            var choice = choices.FirstOrDefault(c => c.Id == choiceKey);
+            if (choice == null)
+                return NotFound();
+
+            var store = await GetStore(app);
+            var invoice = await _InvoiceController.CreateInvoiceCore(new NBitpayClient.Invoice()
+            {
+                ItemDesc = choice.Title,
+                Currency = settings.Currency,
+                Price = (double)choice.Price.Value,
+            }, 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,203 @@
+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 (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/InvoiceController.PaymentProtocol.cs

@@ -9,13 +9,15 @@ 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, string cryptoCode = null)
         {
@@ -23,11 +25,12 @@ namespace BTCPayServer.Controllers
                 cryptoCode = "BTC";
             var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId);
             var network = _NetworkProvider.GetNetwork(cryptoCode);
-            if (invoice == null || invoice.IsExpired() || network == null || !invoice.Support(network))
+            var paymentMethodId = new PaymentMethodId(cryptoCode, Payments.PaymentTypes.BTCLike);
+            if (invoice == null || invoice.IsExpired() || network == null || !invoice.Support(paymentMethodId))
                 return NotFound();
 
             var dto = invoice.EntityToDTO(_NetworkProvider);
-            var cryptoData = dto.CryptoInfo.First(c => c.CryptoCode.Equals(cryptoCode, StringComparison.OrdinalIgnoreCase));
+            var paymentMethod = dto.CryptoInfo.First(c => c.GetpaymentMethodId() == paymentMethodId);
             PaymentRequest request = new PaymentRequest
             {
                 DetailsVersion = 1
@@ -35,7 +38,7 @@ namespace BTCPayServer.Controllers
             request.Details.Expires = invoice.ExpirationTime;
             request.Details.Memo = invoice.ProductInformation.ItemDesc;
             request.Details.Network = network.NBitcoinNetwork;
-            request.Details.Outputs.Add(new PaymentOutput() { Amount = cryptoData.Due, Script = BitcoinAddress.Create(cryptoData.Address, network.NBitcoinNetwork).ScriptPubKey });
+            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);
@@ -69,7 +72,7 @@ namespace BTCPayServer.Controllers
             if (cryptoCode == null)
                 cryptoCode = "BTC";
             var network = _NetworkProvider.GetNetwork(cryptoCode);
-            if (network == null || invoice == null || invoice.IsExpired() || !invoice.Support(network))
+            if (network == null || invoice == null || invoice.IsExpired() || !invoice.Support(new PaymentMethodId(cryptoCode, Payments.PaymentTypes.BTCLike)))
                 return NotFound();
 
             var wallet = _WalletProvider.GetWallet(network);

BTCPayServer/Controllers/InvoiceController.UI.cs

@@ -20,6 +20,8 @@ using System.Net.WebSockets;
 using System.Threading;
 using BTCPayServer.Events;
 using NBXplorer;
+using BTCPayServer.Payments;
+using BTCPayServer.Payments.Lightning;
 
 namespace BTCPayServer.Controllers
 {
@@ -63,127 +65,193 @@ namespace BTCPayServer.Controllers
                 Events = invoice.Events
             };
 
-            foreach (var data in invoice.GetCryptoData(null))
+            foreach (var data in invoice.GetPaymentMethods(null))
             {
-                var cryptoInfo = dto.CryptoInfo.First(o => o.CryptoCode.Equals(data.Key, StringComparison.OrdinalIgnoreCase));
-                var accounting = data.Value.Calculate();
-                var paymentNetwork = _NetworkProvider.GetNetwork(data.Key);
+                var cryptoInfo = dto.CryptoInfo.First(o => o.GetpaymentMethodId() == data.GetId());
+                var accounting = data.Calculate();
+                var paymentMethodId = data.GetId();
                 var cryptoPayment = new InvoiceDetailsModel.CryptoPayment();
-                cryptoPayment.CryptoCode = paymentNetwork.CryptoCode;
-                cryptoPayment.Due = accounting.Due.ToString() + $" {paymentNetwork.CryptoCode}";
-                cryptoPayment.Paid = accounting.CryptoPaid.ToString() + $" {paymentNetwork.CryptoCode}";
-                cryptoPayment.Address = data.Value.DepositAddress.ToString();
-                cryptoPayment.Rate = FormatCurrency(data.Value);
+                cryptoPayment.PaymentMethod = ToString(paymentMethodId);
+                cryptoPayment.Due = accounting.Due.ToString() + $" {paymentMethodId.CryptoCode}";
+                cryptoPayment.Paid = accounting.CryptoPaid.ToString() + $" {paymentMethodId.CryptoCode}";
+
+                var onchainMethod = data.GetPaymentMethodDetails() as Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod;
+                if (onchainMethod != null)
+                {
+                    cryptoPayment.Address = onchainMethod.DepositAddress;
+                }
+                cryptoPayment.Rate = FormatCurrency(data);
                 cryptoPayment.PaymentUrl = cryptoInfo.PaymentUrls.BIP21;
                 model.CryptoPayments.Add(cryptoPayment);
             }
 
             var payments = invoice
                 .GetPayments()
+                .Where(p => p.GetPaymentMethodId().PaymentType == PaymentTypes.BTCLike)
                 .Select(async payment =>
                 {
+                    var paymentData = (Payments.Bitcoin.BitcoinLikePaymentData)payment.GetCryptoPaymentData();
                     var m = new InvoiceDetailsModel.Payment();
                     var paymentNetwork = _NetworkProvider.GetNetwork(payment.GetCryptoCode());
-                    m.CryptoCode = payment.GetCryptoCode();
-                    m.DepositAddress = payment.GetScriptPubKey().GetDestinationAddress(paymentNetwork.NBitcoinNetwork);
-                    m.Confirmations = (await _ExplorerClients.GetExplorerClient(payment.GetCryptoCode())?.GetTransactionAsync(payment.Outpoint.Hash))?.Confirmations ?? 0;
-                    m.TransactionId = payment.Outpoint.Hash.ToString();
+                    m.PaymentMethod = ToString(payment.GetPaymentMethodId());
+                    m.DepositAddress = paymentData.Output.ScriptPubKey.GetDestinationAddress(paymentNetwork.NBitcoinNetwork);
+
+                    int confirmationCount = 0;
+                    if (    (paymentData.ConfirmationCount < paymentNetwork.MaxTrackedConfirmation && payment.Accounted)
+                         && (paymentData.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(paymentData.Outpoint.Hash))?.Confirmations ?? 0;
+                        paymentData.ConfirmationCount = confirmationCount;
+                        payment.SetCryptoPaymentData(paymentData);
+                        await _InvoiceRepository.UpdatePayments(new List<PaymentEntity> { payment });
+                    }
+                    else
+                    {
+                        confirmationCount = paymentData.ConfirmationCount;
+                    }
+                    if (confirmationCount >= paymentNetwork.MaxTrackedConfirmation)
+                    {
+                        m.Confirmations = "At least " + (paymentNetwork.MaxTrackedConfirmation);
+                    }
+                    else
+                    {
+                        m.Confirmations = confirmationCount.ToString(CultureInfo.InvariantCulture);
+                    }
+
+                    m.TransactionId = paymentData.Outpoint.Hash.ToString();
                     m.ReceivedTime = payment.ReceivedTime;
-                    m.TransactionLink = string.Format(paymentNetwork.BlockExplorerLink, m.TransactionId);
+                    m.TransactionLink = string.Format(CultureInfo.InvariantCulture, paymentNetwork.BlockExplorerLink, m.TransactionId);
                     m.Replaced = !payment.Accounted;
                     return m;
                 })
                 .ToArray();
             await Task.WhenAll(payments);
-            model.Addresses = invoice.HistoricalAddresses;
+            model.Addresses = invoice.HistoricalAddresses.Select(h => new InvoiceDetailsModel.AddressModel
+            {
+                Destination = h.GetAddress(),
+                PaymentMethod = ToString(h.GetPaymentMethodId()),
+                Current = !h.UnAssigned.HasValue
+            }).ToArray();
             model.Payments = payments.Select(p => p.GetAwaiter().GetResult()).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}/{cryptoCode}")]
+        [Route("i/{invoiceId}/{paymentMethodId}")]
         [Route("invoice")]
         [AcceptMediaTypeConstraint("application/bitcoin-paymentrequest", false)]
         [XFrameOptionsAttribute(null)]
-        public async Task<IActionResult> Checkout(string invoiceId, string id = null, string cryptoCode = 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, cryptoCode);
+            var model = await GetInvoiceModel(invoiceId, paymentMethodId);
             if (model == null)
                 return NotFound();
 
             return View(nameof(Checkout), model);
         }
 
-        private async Task<PaymentModel> GetInvoiceModel(string invoiceId, string cryptoCode)
+        private async Task<PaymentModel> GetInvoiceModel(string invoiceId, string paymentMethodIdStr)
         {
             var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId);
             if (invoice == null)
                 return null;
             var store = await _StoreRepository.FindStore(invoice.StoreId);
             bool isDefaultCrypto = false;
-            if (cryptoCode == null)
-            { 
-                cryptoCode = store.GetDefaultCrypto();
+            if (paymentMethodIdStr == null)
+            {
+                paymentMethodIdStr = store.GetDefaultCrypto();
                 isDefaultCrypto = true;
             }
-            var network = _NetworkProvider.GetNetwork(cryptoCode);
+
+            var paymentMethodId = PaymentMethodId.Parse(paymentMethodIdStr);
+            var network = _NetworkProvider.GetNetwork(paymentMethodId.CryptoCode);
             if (invoice == null || network == null)
                 return null;
-
-            if(!invoice.Support(network))
+            if (!invoice.Support(paymentMethodId))
             {
-                if(!isDefaultCrypto)
+                if (!isDefaultCrypto)
                     return null;
-                network = invoice.GetCryptoData(_NetworkProvider).First().Value.Network;
+                var paymentMethodTemp = invoice.GetPaymentMethods(_NetworkProvider).First();
+                network = paymentMethodTemp.Network;
+                paymentMethodId = paymentMethodTemp.GetId();
             }
-            var cryptoData = invoice.GetCryptoData(network, _NetworkProvider);
 
+            var paymentMethod = invoice.GetPaymentMethod(paymentMethodId, _NetworkProvider);
+            var paymentMethodDetails = paymentMethod.GetPaymentMethodDetails();
             var dto = invoice.EntityToDTO(_NetworkProvider);
-            var cryptoInfo = dto.CryptoInfo.First(o => o.CryptoCode == network.CryptoCode);
-
+            var cryptoInfo = dto.CryptoInfo.First(o => o.GetpaymentMethodId() == paymentMethodId);
+            var storeBlob = store.GetStoreBlob();
             var currency = invoice.ProductInformation.Currency;
-            var accounting = cryptoData.Calculate();
+            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 = cryptoData.DepositAddress,
+                DefaultLang = storeBlob.DefaultLang ?? "en-US",
+                CustomCSSLink = storeBlob.CustomCSS?.AbsoluteUri,
+                CustomLogoLink = storeBlob.CustomLogo?.AbsoluteUri,
+                BtcAddress = paymentMethodDetails.GetPaymentDestination(),
                 OrderAmount = (accounting.TotalDue - accounting.NetworkFee).ToString(),
                 BtcDue = accounting.Due.ToString(),
                 CustomerEmail = invoice.RefundMail,
                 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 = FormatCurrency(cryptoData),
+                Rate = FormatCurrency(paymentMethod),
                 MerchantRefLink = invoice.RedirectURL ?? "/",
                 StoreName = store.StoreName,
-                InvoiceBitcoinUrl = cryptoInfo.PaymentUrls.BIP21,
-                TxCount = accounting.TxCount,
+                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 = "/" + Url.Content(network.CryptoImagePath),
-                NetworkFeeDescription = $"{accounting.TxCount} transaction{(accounting.TxCount > 1 ? "s" : "")} x {cryptoData.TxFee} {network.CryptoCode}",
-                AvailableCryptos = invoice.GetCryptoData(_NetworkProvider)
-                                          .Where(i => i.Value.Network != null)
-                                          .Select(kv=> new PaymentModel.AvailableCrypto()
-                                            {
-                                                CryptoCode = kv.Key,
-                                                CryptoImage = "/" + kv.Value.Network.CryptoImagePath,
-                                                Link = Url.Action(nameof(Checkout), new { invoiceId = invoiceId, cryptoCode = kv.Key })
-                                            }).Where(c => c.CryptoImage != "/")
+                CryptoImage = "/" + GetImage(paymentMethodId, network),
+                NetworkFeeDescription = $"{accounting.TxRequired} transaction{(accounting.TxRequired > 1 ? "s" : "")} x {paymentMethodDetails.GetTxFee()} {network.CryptoCode}",
+                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 isMultiCurrency = invoice.GetPayments().Select(p=>p.GetCryptoCode()).Concat(new[] { network.CryptoCode }).Distinct().Count() > 1;
+            var isMultiCurrency = invoice.GetPayments().Select(p => p.GetPaymentMethodId()).Concat(new[] { paymentMethod.GetId() }).Distinct().Count() > 1;
             if (isMultiCurrency)
                 model.NetworkFeeDescription = $"{accounting.NetworkFee} {network.CryptoCode}";
 
@@ -192,10 +260,15 @@ namespace BTCPayServer.Controllers
             return model;
         }
 
-        private string FormatCurrency(CryptoData cryptoData)
+        private string GetImage(PaymentMethodId paymentMethodId, BTCPayNetwork network)
         {
-            string currency = cryptoData.ParentEntity.ProductInformation.Currency;
-            return FormatCurrency(cryptoData.Rate, currency);
+            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)
         {
@@ -206,19 +279,19 @@ namespace BTCPayServer.Controllers
         {
             StringBuilder builder = new StringBuilder();
             if (expiration.Days >= 1)
-                builder.Append(expiration.Days.ToString());
+                builder.Append(expiration.Days.ToString(CultureInfo.InvariantCulture));
             if (expiration.Hours >= 1)
-                builder.Append(expiration.Hours.ToString("00"));
-            builder.Append($"{expiration.Minutes.ToString("00")}:{expiration.Seconds.ToString("00")}");
+                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();
         }
 
         [HttpGet]
         [Route("i/{invoiceId}/status")]
-        [Route("i/{invoiceId}/{cryptoCode}/status")]
-        public async Task<IActionResult> GetStatus(string invoiceId, string cryptoCode)
+        [Route("i/{invoiceId}/{paymentMethodId}/status")]
+        public async Task<IActionResult> GetStatus(string invoiceId, string paymentMethodId = null)
         {
-            var model = await GetInvoiceModel(invoiceId, cryptoCode);
+            var model = await GetInvoiceModel(invoiceId, paymentMethodId);
             if (model == null)
                 return NotFound();
             return Json(model);
@@ -238,6 +311,7 @@ namespace BTCPayServer.Controllers
             try
             {
                 leases.Add(_EventAggregator.Subscribe<Events.InvoiceDataChangedEvent>(async o => await NotifySocket(webSocket, o.InvoiceId, invoiceId)));
+                leases.Add(_EventAggregator.Subscribe<Events.InvoiceNewAddressEvent>(async o => await NotifySocket(webSocket, o.InvoiceId, invoiceId)));
                 leases.Add(_EventAggregator.Subscribe<Events.InvoiceEvent>(async o => await NotifySocket(webSocket, o.InvoiceId, invoiceId)));
                 while (true)
                 {
@@ -249,7 +323,7 @@ namespace BTCPayServer.Controllers
             finally
             {
                 leases.Dispose();
-                await CloseSocket(webSocket);
+                await webSocket.CloseSocket();
             }
             return new EmptyResult();
         }
@@ -268,21 +342,6 @@ namespace BTCPayServer.Controllers
             catch { try { webSocket.Dispose(); } catch { } }
         }
 
-        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);
-                }
-            }
-            catch { }
-            finally { try { webSocket.Dispose(); } catch { } }
-        }
-
         [HttpPost]
         [Route("i/{invoiceId}/UpdateCustomer")]
         public async Task<IActionResult> UpdateCustomer(string invoiceId, [FromBody]UpdateCustomerModel data)
@@ -317,8 +376,10 @@ namespace BTCPayServer.Controllers
                 model.Invoices.Add(new InvoiceModel()
                 {
                     Status = invoice.Status,
-                    Date = invoice.InvoiceTime,
+                    Date = Prettify(invoice.InvoiceTime),
                     InvoiceId = invoice.Id,
+                    OrderId = invoice.OrderId ?? string.Empty,
+                    RedirectUrl = invoice.RedirectURL ?? string.Empty,
                     AmountCurrency = $"{invoice.ProductInformation.Price.ToString(CultureInfo.InvariantCulture)} {invoice.ProductInformation.Currency}"
                 });
             }
@@ -328,6 +389,30 @@ namespace BTCPayServer.Controllers
             return View(model);
         }
 
+        private string Prettify(DateTimeOffset invoiceTime)
+        {
+            var ago = DateTime.UtcNow - invoiceTime;
+
+            if (ago.TotalMinutes < 1)
+            {
+                return $"{(int)ago.TotalSeconds} second{Plural((int)ago.TotalSeconds)} ago";
+            }
+            if (ago.TotalHours < 1)
+            {
+                return $"{(int)ago.TotalMinutes} minute{Plural((int)ago.TotalMinutes)} ago";
+            }
+            if (ago.Days < 1)
+            {
+                return $"{(int)ago.TotalHours} hour{Plural((int)ago.TotalHours)} ago";
+            }
+            return $"{(int)ago.TotalDays} day{Plural((int)ago.TotalDays)} ago";
+        }
+
+        private string Plural(int totalDays)
+        {
+            return totalDays > 1 ? "s" : string.Empty;
+        }
+
         [HttpGet]
         [Route("invoices/create")]
         [Authorize(AuthenticationSchemes = "Identity.Application")]
@@ -338,7 +423,7 @@ namespace BTCPayServer.Controllers
             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 });
         }
@@ -355,9 +440,21 @@ namespace BTCPayServer.Controllers
                 return View(model);
             }
             var store = await _StoreRepository.FindStore(model.StoreId, GetUserId());
-            if (store.GetDerivationStrategies(_NetworkProvider).Count() == 0)
+            StatusMessage = null;
+            if (store.Role != StoreRoles.Owner)
+            {
+                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

BTCPayServer/Controllers/InvoiceController.cs

@@ -39,55 +39,50 @@ using Microsoft.AspNetCore.Mvc.Routing;
 using NBXplorer.DerivationStrategy;
 using NBXplorer;
 using BTCPayServer.HostedServices;
+using BTCPayServer.Payments;
 
 namespace BTCPayServer.Controllers
 {
     public partial class InvoiceController : Controller
     {
         InvoiceRepository _InvoiceRepository;
-        BTCPayWalletProvider _WalletProvider;
         IRateProviderFactory _RateProviders;
         StoreRepository _StoreRepository;
         UserManager<ApplicationUser> _UserManager;
-        IFeeProviderFactory _FeeProviderFactory;
         private CurrencyNameTable _CurrencyNameTable;
         EventAggregator _EventAggregator;
         BTCPayNetworkProvider _NetworkProvider;
-        ExplorerClientProvider _ExplorerClients;
-        public InvoiceController(InvoiceRepository invoiceRepository,
+        private readonly BTCPayWalletProvider _WalletProvider;
+        IServiceProvider _ServiceProvider;
+        public InvoiceController(
+            IServiceProvider serviceProvider,
+            InvoiceRepository invoiceRepository,
             CurrencyNameTable currencyNameTable,
             UserManager<ApplicationUser> userManager,
-            BTCPayWalletProvider walletProvider,
             IRateProviderFactory rateProviders,
             StoreRepository storeRepository,
             EventAggregator eventAggregator,
-            BTCPayNetworkProvider networkProvider,
-            ExplorerClientProvider explorerClientProviders,
-            IFeeProviderFactory feeProviderFactory)
+            BTCPayWalletProvider walletProvider,
+            BTCPayNetworkProvider networkProvider)
         {
-            _ExplorerClients = explorerClientProviders;
+            _ServiceProvider = serviceProvider;
             _CurrencyNameTable = currencyNameTable ?? throw new ArgumentNullException(nameof(currencyNameTable));
             _StoreRepository = storeRepository ?? throw new ArgumentNullException(nameof(storeRepository));
             _InvoiceRepository = invoiceRepository ?? throw new ArgumentNullException(nameof(invoiceRepository));
-            _WalletProvider = walletProvider ?? throw new ArgumentNullException(nameof(walletProvider));
             _RateProviders = rateProviders ?? throw new ArgumentNullException(nameof(rateProviders));
             _UserManager = userManager;
-            _FeeProviderFactory = feeProviderFactory ?? throw new ArgumentNullException(nameof(feeProviderFactory));
             _EventAggregator = eventAggregator;
             _NetworkProvider = networkProvider;
+            _WalletProvider = walletProvider;
         }
 
 
         internal async Task<DataWrapper<InvoiceResponse>> CreateInvoiceCore(Invoice invoice, StoreData store, string serverUrl)
         {
-            var derivationStrategies = store.GetDerivationStrategies(_NetworkProvider).ToList();
-            if (derivationStrategies.Count == 0)
-                throw new BitpayHttpException(400, "This store has not configured the derivation strategy");
             var entity = new InvoiceEntity
             {
                 InvoiceTime = DateTimeOffset.UtcNow
             };
-            entity.SetDerivationStrategies(derivationStrategies);
 
             var storeBlob = store.GetStoreBlob();
             Uri notificationUri = Uri.IsWellFormedUriString(invoice.NotificationURL, UriKind.Absolute) ? new Uri(invoice.NotificationURL, UriKind.Absolute) : null;
@@ -115,56 +110,62 @@ namespace BTCPayServer.Controllers
             entity.Status = "new";
             entity.SpeedPolicy = ParseSpeedPolicy(invoice.TransactionSpeed, store.SpeedPolicy);
 
-            var queries = derivationStrategies
-                    .Select(derivationStrategy => (Wallet: _WalletProvider.GetWallet(derivationStrategy.Network),
-                                                    DerivationStrategy: derivationStrategy.DerivationStrategyBase,
-                                                    Network: derivationStrategy.Network,
-                                                    RateProvider: _RateProviders.GetRateProvider(derivationStrategy.Network),
-                                                    FeeRateProvider: _FeeProviderFactory.CreateFeeProvider(derivationStrategy.Network)))
-                    .Where(_ => _.Wallet != null &&
-                                _.FeeRateProvider != null &&
-                                _.RateProvider != null)
-                    .Select(_ =>
-                    {
-                        return new
-                        {
-                            network = _.Network,
-                            getFeeRate = _.FeeRateProvider.GetFeeRateAsync(),
-                            getRate = storeBlob.ApplyRateRules(_.Network, _.RateProvider).GetRateAsync(invoice.Currency),
-                            getAddress = _.Wallet.ReserveAddressAsync(_.DerivationStrategy)
-                        };
-                    });
 
-            bool legacyBTCisSet = false;
-            var cryptoDatas = new Dictionary<string, CryptoData>();
-            foreach (var q in queries)
+            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(o.Handler, o.SupportedPaymentMethod, o.Network, entity, storeBlob)))
+                                                .ToList();
+
+            List<string> paymentMethodErrors = new List<string>();
+            List<ISupportedPaymentMethod> supported = new List<ISupportedPaymentMethod>();
+            var paymentMethods = new PaymentMethodDictionary();
+            foreach (var o in supportedPaymentMethods)
             {
-                CryptoData cryptoData = new CryptoData();
-                cryptoData.CryptoCode = q.network.CryptoCode;
-                cryptoData.FeeRate = (await q.getFeeRate);
-                cryptoData.TxFee = GetTxFee(storeBlob, cryptoData.FeeRate); // assume price for 100 bytes
-                cryptoData.Rate = await q.getRate;
-                cryptoData.DepositAddress = (await q.getAddress).ToString();
-
-#pragma warning disable CS0618
-                if (q.network.IsBTC)
+                try
                 {
-                    legacyBTCisSet = true;
-                    entity.TxFee = cryptoData.TxFee;
-                    entity.Rate = cryptoData.Rate;
-                    entity.DepositAddress = cryptoData.DepositAddress;
+                    var paymentMethod = await o.PaymentMethod;
+                    if (paymentMethod == null)
+                        throw new PaymentMethodUnavailableException("Payment method unavailable (The handler returned null)");
+                    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()})");
                 }
-#pragma warning restore CS0618
-                cryptoDatas.Add(cryptoData.CryptoCode, cryptoData);
             }
 
-            if (!legacyBTCisSet)
+            if (supported.Count == 0)
             {
-                // Legacy Bitpay clients expect information for BTC information, even if the store do not support it
+                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);
 #pragma warning disable CS0618
+            // Legacy Bitpay clients expect information for BTC information, even if the store do not support it
+            var legacyBTCisSet = paymentMethods.Any(p => p.GetId().IsBTCOnChain);
+            if (!legacyBTCisSet && _NetworkProvider.BTC != null)
+            {
                 var btc = _NetworkProvider.BTC;
-                var feeProvider = _FeeProviderFactory.CreateFeeProvider(btc);
-                var rateProvider = storeBlob.ApplyRateRules(btc, _RateProviders.GetRateProvider(btc));
+                var feeProvider = ((IFeeProviderFactory)_ServiceProvider.GetService(typeof(IFeeProviderFactory))).CreateFeeProvider(btc);
+                var rateProvider = storeBlob.ApplyRateRules(btc, _RateProviders.GetRateProvider(btc, false));
                 if (feeProvider != null && rateProvider != null)
                 {
                     var gettingFee = feeProvider.GetFeeRateAsync();
@@ -174,19 +175,79 @@ namespace BTCPayServer.Controllers
                 }
 #pragma warning restore CS0618
             }
-
-            entity.SetCryptoData(cryptoDatas);
             entity.PosData = invoice.PosData;
-            entity = await _InvoiceRepository.CreateInvoiceAsync(store.Id, entity, _NetworkProvider);
+            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(IPaymentMethodHandler handler, ISupportedPaymentMethod supportedPaymentMethod, BTCPayNetwork network, InvoiceEntity entity, StoreBlob storeBlob)
+        {
+            var rate = await storeBlob.ApplyRateRules(network, _RateProviders.GetRateProvider(network, false)).GetRateAsync(entity.ProductInformation.Currency);
+            PaymentMethod paymentMethod = new PaymentMethod();
+            paymentMethod.ParentEntity = entity;
+            paymentMethod.Network = network;
+            paymentMethod.SetId(supportedPaymentMethod.PaymentId);
+            paymentMethod.Rate = rate;
+            var paymentDetails = await handler.CreatePaymentMethodDetails(supportedPaymentMethod, paymentMethod, 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 = 0.0m;
+                if (limitValue.Currency == entity.ProductInformation.Currency)
+                    limitValueRate = paymentMethod.Rate;
+                else
+                    limitValueRate = await storeBlob.ApplyRateRules(network, _RateProviders.GetRateProvider(network, false)).GetRateAsync(limitValue.Currency);
+
+                var limitValueCrypto = Money.Coins(limitValue.Value / limitValueRate);
+                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;
+        }
+
+#pragma warning disable CS0618
         private static Money GetTxFee(StoreBlob storeBlob, FeeRate feeRate)
         {
             return storeBlob.NetworkFeeDisabled ? Money.Zero : feeRate.GetFee(100);
         }
+#pragma warning restore CS0618
 
         private SpeedPolicy ParseSpeedPolicy(string transactionSpeed, SpeedPolicy defaultPolicy)
         {

BTCPayServer/Controllers/ManageController.cs

@@ -20,6 +20,7 @@ using NBitcoin;
 using BTCPayServer.Services.Stores;
 using BTCPayServer.Services.Wallets;
 using BTCPayServer.Services.Mails;
+using System.Globalization;
 
 namespace BTCPayServer.Controllers
 {
@@ -367,7 +368,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));
@@ -386,7 +387,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);
@@ -434,7 +435,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);
@@ -524,7 +525,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,68 @@ using System.Linq;
 using System.Threading.Tasks;
 using BTCPayServer.Filters;
 using BTCPayServer.Services.Rates;
+using BTCPayServer.Services.Stores;
 
 namespace BTCPayServer.Controllers
 {
     public class RateController : Controller
     {
-        IRateProvider _RateProvider;
+        IRateProviderFactory _RateProviderFactory;
+        BTCPayNetworkProvider _NetworkProvider;
         CurrencyNameTable _CurrencyNameTable;
-        public RateController(IRateProvider rateProvider, CurrencyNameTable currencyNameTable)
+        StoreRepository _StoreRepo;
+        public RateController(
+            IRateProviderFactory 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 cryptoCode = null, string storeId = null)
         {
-            var allRates = (await _RateProvider.GetRatesAsync());
-            return new DataWrapper<NBitpayClient.Rate[]>
-                    (allRates.Select(r =>
+            var result = await GetRates2(cryptoCode, 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 cryptoCode = null, string storeId = null)
+        {
+            cryptoCode = cryptoCode ?? "BTC";
+            var network = _NetworkProvider.GetNetwork(cryptoCode);
+            if (network == null)
+                return NotFound();
+            var rateProvider = _RateProviderFactory.GetRateProvider(network, true);
+            if (rateProvider == null)
+                return NotFound();
+
+            if (storeId != null)
+            {
+                var store = await _StoreRepo.FindStore(storeId);
+                if (store == null)
+                    return NotFound();
+                rateProvider = store.GetStoreBlob().ApplyRateRules(network, rateProvider);
+            }
+
+            var allRates = (await rateProvider.GetRatesAsync());
+            return Json(allRates.Select(r =>
                             new NBitpayClient.Rate()
                             {
                                 Code = r.Currency,
                                 Name = _CurrencyNameTable.GetCurrencyData(r.Currency)?.Name,
                                 Value = r.Value
                             }).Where(n => n.Name != null).ToArray());
-
         }
     }
 }

BTCPayServer/Controllers/ServerController.cs

@@ -43,6 +43,50 @@ 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.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)

BTCPayServer/Controllers/StoresController.BTCLike.cs

@@ -0,0 +1,353 @@
+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 async Task<IActionResult> AddDerivationScheme(string storeId, string cryptoCode)
+        {
+            var store = await _Repo.FindStore(storeId, GetUserId());
+            if (store == null)
+                return NotFound();
+
+            DerivationSchemeViewModel vm = new DerivationSchemeViewModel();
+            vm.ServerUrl = GetStoreUrl(storeId);
+            vm.CryptoCode = cryptoCode;
+            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 = await _Repo.FindStore(storeId, GetUserId());
+            if (store == null)
+                return NotFound();
+
+            var network = cryptoCode == null ? null : _ExplorerProvider.GetNetwork(cryptoCode);
+            if (network == null)
+            {
+                return NotFound();
+            }
+            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 = await _Repo.FindStore(storeId, GetUserId());
+            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);
+                    }
+                    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);
+                    ;
+                    getxpubResult.CoinType = (int)(getxpubResult.KeyPath.Indexes[1] - 0x80000000);
+                    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,146 @@
+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;
+
+namespace BTCPayServer.Controllers
+{
+    public partial class StoresController
+    {
+
+        [HttpGet]
+        [Route("{storeId}/lightning/{cryptoCode}")]
+        public async Task<IActionResult> AddLightningNode(string storeId, string cryptoCode)
+        {
+            var store = await _Repo.FindStore(storeId, GetUserId());
+            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 = await _Repo.FindStore(storeId, GetUserId());
+            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);
+                    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,34 +1,43 @@
 using BTCPayServer.Authentication;
+using BTCPayServer.Configuration;
 using BTCPayServer.Data;
+using BTCPayServer.HostedServices;
 using BTCPayServer.Models;
 using BTCPayServer.Models.StoreViewModels;
+using BTCPayServer.Services;
 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.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(Policy = StorePolicies.OwnStore)]
     [AutoValidateAntiforgeryToken]
-    public class StoresController : Controller
+    public partial class StoresController : Controller
     {
+        public string CreatedStoreId { get; set; }
         public StoresController(
+            NBXplorerDashboard dashboard,
+            IServiceProvider serviceProvider,
+            BTCPayServerOptions btcpayServerOptions,
+            BTCPayServerEnvironment btcpayEnv,
+            IOptions<MvcJsonOptions> mvcJsonOptions,
             StoreRepository repo,
             TokenRepository tokenRepo,
             UserManager<ApplicationUser> userManager,
@@ -36,24 +45,40 @@ namespace BTCPayServer.Controllers
             BTCPayWalletProvider walletProvider,
             BTCPayNetworkProvider networkProvider,
             ExplorerClientProvider explorerProvider,
+            IFeeProviderFactory feeRateProvider,
+            LanguageService langService,
             IHostingEnvironment env)
         {
+            _Dashboard = dashboard;
             _Repo = repo;
             _TokenRepository = tokenRepo;
             _UserManager = userManager;
+            _LangService = langService;
             _TokenController = tokenController;
             _WalletProvider = walletProvider;
             _Env = env;
             _NetworkProvider = networkProvider;
             _ExplorerProvider = explorerProvider;
+            _MvcJsonOptions = mvcJsonOptions.Value;
+            _FeeRateProvider = feeRateProvider;
+            _ServiceProvider = serviceProvider;
+            _BtcpayServerOptions = btcpayServerOptions;
+            _BTCPayEnv = btcpayEnv;
         }
+        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]
@@ -63,86 +88,179 @@ namespace BTCPayServer.Controllers
         }
 
         [HttpGet]
-        [Route("create")]
-        public IActionResult CreateStore()
-        {
-            return View();
-        }
-
-        [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));
-        }
-
-        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(s => s.GetDerivationStrategies(_NetworkProvider)
-                                              .Select(d => (Wallet: _WalletProvider.GetWallet(d.Network),
-                                                            DerivationStrategy: d.DerivationStrategyBase))
-                                              .Where(_ => _.Wallet != null)
-                                              .Select(async _ => (await _.Wallet.GetBalance(_.DerivationStrategy)).ToString() + " " + _.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,
-                    Balances = balances[i].Select(t => t.Result).ToArray()
-                });
-            }
-            return View(result);
-        }
-
-        [HttpGet]
-        [Route("{storeId}/delete")]
-        public async Task<IActionResult> DeleteStore(string storeId)
+        [Route("{storeId}/wallet/{cryptoCode}")]
+        public async Task<IActionResult> Wallet(string storeId, string cryptoCode)
         {
             var store = await _Repo.FindStore(storeId, GetUserId());
             if (store == null)
                 return NotFound();
+            WalletModel model = new WalletModel();
+            model.ServerUrl = GetStoreUrl(storeId);
+            model.CryptoCurrency = cryptoCode;
+            return View(model);
+        }
+
+        private string GetStoreUrl(string storeId)
+        {
+            return HttpContext.Request.GetAbsoluteRoot() + "/stores/" + storeId + "/";
+        }
+
+        [HttpGet]
+        [Route("{storeId}/users")]
+        public async Task<IActionResult> StoreUsers(string storeId)
+        {
+            StoreUsersViewModel vm = new StoreUsersViewModel();
+            await FillUsers(storeId, vm);
+            return View(vm);
+        }
+
+        private async Task FillUsers(string storeId, StoreUsersViewModel vm)
+        {
+            var users = await _Repo.GetStoreUsers(storeId);
+            vm.StoreId = storeId;
+            vm.Users = users.Select(u => new StoreUsersViewModel.StoreUserViewModel()
+            {
+                Email = u.Email,
+                Id = u.Id,
+                Role = u.Role
+            }).ToList();
+        }
+
+        [HttpPost]
+        [Route("{storeId}/users")]
+        public async Task<IActionResult> StoreUsers(string storeId, StoreUsersViewModel vm)
+        {
+            await FillUsers(storeId, vm);
+            if (!ModelState.IsValid)
+            {
+                return View(vm);
+            }
+            var user = await _UserManager.FindByEmailAsync(vm.Email);
+            if (user == null)
+            {
+                ModelState.AddModelError(nameof(vm.Email), "User not found");
+                return View(vm);
+            }
+            if (!StoreRoles.AllRoles.Contains(vm.Role))
+            {
+                ModelState.AddModelError(nameof(vm.Role), "Invalid role");
+                return View(vm);
+            }
+            if (!await _Repo.AddStoreUser(storeId, 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}/users/{userId}/delete")]
+        public async Task<IActionResult> DeleteStoreUser(string storeId, string userId)
+        {
+            StoreUsersViewModel vm = new StoreUsersViewModel();
+            var store = await _Repo.FindStore(storeId, userId);
+            if (store == null)
+                return NotFound();
+            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 {store.Role} 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)
+        {
+            await _Repo.RemoveStoreUser(storeId, userId);
+            StatusMessage = "User removed successfully";
+            return RedirectToAction(nameof(StoreUsers), new { storeId = storeId, userId = userId });
+        }
+
+        [HttpGet]
+        [Route("{storeId}/checkout")]
+        public async Task<IActionResult> CheckoutExperience(string storeId)
         {
-            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));
+            var storeBlob = store.GetStoreBlob();
+            var vm = new CheckoutExperienceViewModel();
+            vm.SetCryptoCurrencies(_ExplorerProvider, store.GetDefaultCrypto());
+            vm.SetLanguages(_LangService, storeBlob.DefaultLang);
+            vm.LightningMaxValue = storeBlob.LightningMaxValue?.ToString() ?? "";
+            vm.OnChainMinValue = storeBlob.OnChainMinValue?.ToString() ?? "";
+            vm.AllowCoinConversion = storeBlob.AllowCoinConversion;
+            vm.CustomCSS = storeBlob.CustomCSS?.AbsoluteUri;
+            vm.CustomLogo = storeBlob.CustomLogo?.AbsoluteUri;
+            return View(vm);
+        }
+
+        [HttpPost]
+        [Route("{storeId}/checkout")]
+        public async Task<IActionResult> CheckoutExperience(string storeId, 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");
+                }
+            }
+
+            var store = await _Repo.FindStore(storeId, GetUserId());
+            if (store == null)
+                return NotFound();
+            bool needUpdate = false;
+            var blob = store.GetStoreBlob();
+            if (store.GetDefaultCrypto() != model.DefaultCryptoCurrency)
+            {
+                needUpdate = true;
+                store.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.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);
+            if (store.SetStoreBlob(blob))
+            {
+                needUpdate = true;
+            }
+            if (needUpdate)
+            {
+                await _Repo.UpdateStore(store);
+                StatusMessage = "Store successfully updated";
+            }
+
+            return RedirectToAction(nameof(CheckoutExperience), new
+            {
+                storeId = storeId
+            });
         }
 
         [HttpGet]
@@ -157,116 +275,48 @@ namespace BTCPayServer.Controllers
             var vm = new StoreViewModel();
             vm.Id = store.Id;
             vm.StoreName = store.StoreName;
-            vm.SetCryptoCurrencies(_ExplorerProvider, store.GetDefaultCrypto());
             vm.StoreWebsite = store.StoreWebsite;
             vm.NetworkFee = !storeBlob.NetworkFeeDisabled;
             vm.SpeedPolicy = store.SpeedPolicy;
-            AddDerivationSchemes(store, vm);
-            vm.StatusMessage = StatusMessage;
+            AddPaymentMethods(store, vm);
             vm.MonitoringExpiration = storeBlob.MonitoringExpiration;
             vm.InvoiceExpiration = storeBlob.InvoiceExpiration;
             vm.RateMultiplier = (double)storeBlob.GetRateMultiplier();
-            vm.PreferredExchange = storeBlob.PreferredExchange;
+            vm.PreferredExchange = storeBlob.PreferredExchange.IsCoinAverage() ? "coinaverage" : storeBlob.PreferredExchange;
             return View(vm);
         }
 
-        private void AddDerivationSchemes(StoreData store, StoreViewModel vm)
+
+        private void AddPaymentMethods(StoreData store, StoreViewModel vm)
         {
-            var strategies = store
-                            .GetDerivationStrategies(_NetworkProvider)
-                            .ToDictionary(s => s.Network.CryptoCode);
-            foreach (var explorerProvider in _ExplorerProvider.GetAll())
+            var derivationByCryptoCode =
+                store
+                .GetSupportedPaymentMethods(_NetworkProvider)
+                .OfType<DerivationStrategy>()
+                .ToDictionary(c => c.Network.CryptoCode);
+            foreach (var network in _NetworkProvider.GetAll())
             {
-                if (strategies.TryGetValue(explorerProvider.Item1.CryptoCode, out DerivationStrategy strat))
+                var strategy = derivationByCryptoCode.TryGet(network.CryptoCode);
+                vm.DerivationSchemes.Add(new StoreViewModel.DerivationScheme()
                 {
-                    vm.DerivationSchemes.Add(new StoreViewModel.DerivationScheme()
-                    {
-                        Crypto = explorerProvider.Item1.CryptoCode,
-                        Value = strat.DerivationStrategyBase.ToString()
-                    });
-                }
-            }
-        }
-
-        [HttpGet]
-        [Route("{storeId}/derivations")]
-        public async Task<IActionResult> AddDerivationScheme(string storeId, string selectedScheme = null)
-        {
-            selectedScheme = selectedScheme ?? "BTC";
-            var store = await _Repo.FindStore(storeId, GetUserId());
-            if (store == null)
-                return NotFound();
-            DerivationSchemeViewModel vm = new DerivationSchemeViewModel();
-            vm.SetCryptoCurrencies(_ExplorerProvider, selectedScheme);
-            return View(vm);
-        }
-
-        [HttpPost]
-        [Route("{storeId}/derivations")]
-        public async Task<IActionResult> AddDerivationScheme(string storeId, DerivationSchemeViewModel vm, string command, string selectedScheme = null)
-        {
-            selectedScheme = selectedScheme ?? "BTC";
-            var store = await _Repo.FindStore(storeId, GetUserId());
-            if (store == null)
-                return NotFound();
-
-            var network = vm.CryptoCurrency == null ? null : _ExplorerProvider.GetNetwork(vm.CryptoCurrency);
-            vm.SetCryptoCurrencies(_ExplorerProvider, selectedScheme);
-            if (network == null)
-            {
-                ModelState.AddModelError(nameof(vm.CryptoCurrency), "Invalid network");
-                return View(vm);
-            }
-            var wallet = _WalletProvider.GetWallet(network);
-            if (wallet == null)
-            {
-                ModelState.AddModelError(nameof(vm.CryptoCurrency), "Invalid network");
-                return View(vm);
+                    Crypto = network.CryptoCode,
+                    Value = strategy?.DerivationStrategyBase?.ToString() ?? string.Empty
+                });
             }
 
-            if (command == "Save")
-            {
-                try
-                {
-                    if (!string.IsNullOrEmpty(vm.DerivationScheme))
-                    {
-                        var strategy = ParseDerivationStrategy(vm.DerivationScheme, vm.DerivationSchemeFormat, network);
-                        await wallet.TrackAsync(strategy);
-                        vm.DerivationScheme = strategy.ToString();
-                    }
-                    store.SetDerivationStrategy(network, vm.DerivationScheme);
-                }
-                catch
-                {
-                    ModelState.AddModelError(nameof(vm.DerivationScheme), "Invalid Derivation Scheme");
-                    return View(vm);
-                }
+            var lightningByCryptoCode = store
+                                        .GetSupportedPaymentMethods(_NetworkProvider)
+                                        .OfType<Payments.Lightning.LightningSupportedPaymentMethod>()
+                                        .ToDictionary(c => c.CryptoCode);
 
-                await _Repo.UpdateStore(store);
-                StatusMessage = $"Derivation scheme for {vm.CryptoCurrency} has been modified.";
-                return RedirectToAction(nameof(UpdateStore), new { storeId = storeId });
-            }
-            else
+            foreach (var network in _NetworkProvider.GetAll())
             {
-                if (!string.IsNullOrEmpty(vm.DerivationScheme))
+                var lightning = lightningByCryptoCode.TryGet(network.CryptoCode);
+                vm.LightningNodes.Add(new StoreViewModel.LightningNode()
                 {
-                    try
-                    {
-                        var scheme = ParseDerivationStrategy(vm.DerivationScheme, vm.DerivationSchemeFormat, network);
-                        var line = scheme.GetLineFor(DerivationFeature.Deposit);
-
-                        for (int i = 0; i < 10; i++)
-                        {
-                            var address = line.Derive((uint)i);
-                            vm.AddressSamples.Add((line.Path.Derive((uint)i).ToString(), address.ScriptPubKey.GetDestinationAddress(network.NBitcoinNetwork).ToString()));
-                        }
-                    }
-                    catch
-                    {
-                        ModelState.AddModelError(nameof(vm.DerivationScheme), "Invalid Derivation Scheme");
-                    }
-                }
-                return View(vm);
+                    CryptoCode = network.CryptoCode,
+                    Address = lightning?.GetLightningUrl()?.BaseUri.AbsoluteUri ?? string.Empty
+                });
             }
         }
 
@@ -278,10 +328,12 @@ namespace BTCPayServer.Controllers
             {
                 return View(model);
             }
+            if (model.PreferredExchange != null)
+                model.PreferredExchange = model.PreferredExchange.Trim().ToLowerInvariant();
             var store = await _Repo.FindStore(storeId, GetUserId());
             if (store == null)
                 return NotFound();
-            AddDerivationSchemes(store, model);
+            AddPaymentMethods(store, model);
 
             bool needUpdate = false;
             if (store.SpeedPolicy != model.SpeedPolicy)
@@ -300,17 +352,12 @@ namespace BTCPayServer.Controllers
                 store.StoreWebsite = model.StoreWebsite;
             }
 
-            if (store.GetDefaultCrypto() != model.DefaultCryptoCurrency)
-            {
-                needUpdate = true;
-                store.SetDefaultCrypto(model.DefaultCryptoCurrency);
-            }
-            model.SetCryptoCurrencies(_ExplorerProvider, model.DefaultCryptoCurrency);
-
             var blob = store.GetStoreBlob();
             blob.NetworkFeeDisabled = !model.NetworkFee;
             blob.MonitoringExpiration = model.MonitoringExpiration;
             blob.InvoiceExpiration = model.InvoiceExpiration;
+
+            bool newExchange = blob.PreferredExchange != model.PreferredExchange;
             blob.PreferredExchange = model.PreferredExchange;
 
             blob.SetRateMultiplier(model.RateMultiplier);
@@ -320,14 +367,14 @@ namespace BTCPayServer.Controllers
                 needUpdate = true;
             }
 
-            if (!string.IsNullOrEmpty(blob.PreferredExchange))
+            if (!blob.PreferredExchange.IsCoinAverage() && newExchange)
             {
                 using (HttpClient client = new HttpClient())
                 {
                     var rate = await client.GetAsync(model.RateSource);
                     if (rate.StatusCode == System.Net.HttpStatusCode.NotFound)
                     {
-                        ModelState.AddModelError(nameof(model.PreferredExchange), $"Invalid exchange ({model.RateSource})");
+                        ModelState.AddModelError(nameof(model.PreferredExchange), $"Unsupported exchange ({model.RateSource})");
                         return View(model);
                     }
                 }
@@ -345,41 +392,11 @@ namespace BTCPayServer.Controllers
             });
         }
 
-        private DerivationStrategyBase ParseDerivationStrategy(string derivationScheme, string format, BTCPayNetwork network)
+        private DerivationStrategy ParseDerivationStrategy(string derivationScheme, Script hint, BTCPayNetwork network)
         {
-            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[] { });
-
-                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.NBXplorerNetwork.DefaultSettings.ChainType == NBXplorer.ChainType.Main ? 0x0488b21eU : 0x043587cf, false);
-
-                for (int i = 0; i < 4; i++)
-                    data[i] = standardPrefix[i];
-
-                derivationScheme = new BitcoinExtPubKey(Encoders.Base58Check.EncodeData(data), network.NBitcoinNetwork).ToString();
-                foreach (var label in labels)
-                {
-                    derivationScheme = derivationScheme + $"-[{label}]";
-                }
-            }
-
-            return new DerivationStrategyFactory(network.NBitcoinNetwork).Parse(derivationScheme);
+            var parser = new DerivationSchemeParser(network.NBitcoinNetwork, network.DefaultSettings.ChainType);
+            parser.HintScriptPubKey = hint;
+            return new DerivationStrategy(parser.Parse(derivationScheme), network);
         }
 
         [HttpGet]
@@ -409,15 +426,17 @@ namespace BTCPayServer.Controllers
                 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
+            storeId = model.StoreId ?? storeId;
+            var userId = GetUserId();
+            if (userId == null)
+                return Unauthorized();
+            var store = await _Repo.FindStore(storeId, userId);
+            if (store == null)
+                return Unauthorized();
+            if (store.Role != StoreRoles.Owner)
             {
-                storeId = model.StoreId;
-                var userId = GetUserId();
-                if (userId == null)
-                    return Unauthorized();
-                var store = await _Repo.FindStore(storeId, userId);
-                if (store == null)
-                    return Unauthorized();
+                StatusMessage = "Error: You need to be owner of this store to request pairing codes";
+                return RedirectToAction(nameof(UserStoresController.ListStores), "UserStores");
             }
 
             var tokenRequest = new TokenRequest()
@@ -497,11 +516,13 @@ namespace BTCPayServer.Controllers
         [Route("/api-access-request")]
         public async Task<IActionResult> RequestPairing(string pairingCode, string selectedStore = null)
         {
+            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
             {
@@ -523,7 +544,7 @@ namespace BTCPayServer.Controllers
         }
 
         [HttpPost]
-        [Route("api-access-request")]
+        [Route("/api-access-request")]
         public async Task<IActionResult> Pair(string pairingCode, string selectedStore)
         {
             if (pairingCode == null)
@@ -533,10 +554,16 @@ namespace BTCPayServer.Controllers
             if (store == null || pairing == null)
                 return NotFound();
 
+            if (store.Role != StoreRoles.Owner)
+            {
+                StatusMessage = "Error: You can't approve a pairing without being owner of the store";
+                return RedirectToAction(nameof(UserStoresController.ListStores), "UserStores");
+            }
+
             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

BTCPayServer/Controllers/UserStoresController.cs

@@ -0,0 +1,147 @@
+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.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 = "Identity.Application")]
+    [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 async Task<IActionResult> DeleteStore(string storeId)
+        {
+            var store = await _Repo.FindStore(storeId, GetUserId());
+            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 = await _Repo.FindStore(storeId, GetUserId());
+            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.Role == StoreRoles.Owner,
+                    Balances = store.Role == StoreRoles.Owner ? 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/AddressInvoiceData.cs

@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using BTCPayServer.Payments;
+using BTCPayServer.Services.Invoices;
 using NBitcoin;
 
 namespace BTCPayServer.Data
@@ -20,28 +22,30 @@ namespace BTCPayServer.Data
 
 
 #pragma warning disable CS0618
-        public ScriptId GetHash()
+        public string GetAddress()
         {
             if (Address == null)
                 return null;
-            var index = Address.IndexOf("#");
+            var index = Address.LastIndexOf("#", StringComparison.InvariantCulture);
             if (index == -1)
-                return new ScriptId(Address);
-            return new ScriptId(Address.Substring(0, index));
+                return Address;
+            return Address.Substring(0, index);
         }
-        public AddressInvoiceData SetHash(ScriptId scriptId, string cryptoCode)
+        public AddressInvoiceData Set(string address, PaymentMethodId paymentMethodId)
         {
-            Address = scriptId + "#" + cryptoCode;
+            Address = address + "#" + paymentMethodId.ToString();
             return this;
         }
-        public string GetCryptoCode()
+        public PaymentMethodId GetpaymentMethodId()
         {
             if (Address == null)
                 return null;
-            var index = Address.IndexOf("#");
+            var index = Address.LastIndexOf("#", StringComparison.InvariantCulture);
+            // Legacy AddressInvoiceData does not have the paymentMethodId attached to the Address
             if (index == -1)
-                return "BTC";
-            return Address.Substring(index + 1);
+                return PaymentMethodId.Parse("BTC");
+            /////////////////////////
+            return PaymentMethodId.Parse(Address.Substring(index + 1));
         }
 #pragma warning restore CS0618
 

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,11 @@ namespace BTCPayServer.Data
             get; set;
         }
 
+        public DbSet<AppData> Apps
+        {
+            get; set;
+        }
+
         public DbSet<InvoiceEventData> InvoiceEvents
         {
             get; set;
@@ -107,6 +112,10 @@ namespace BTCPayServer.Data
                        t.StoreDataId
                    });
 
+
+            builder.Entity<AppData>()
+                    .HasOne(a => a.StoreData);
+
             builder.Entity<UserStore>()
                  .HasOne(pt => pt.ApplicationUser)
                  .WithMany(p => p.UserStores)

BTCPayServer/Data/HistoricalAddressInvoiceData.cs

@@ -27,15 +27,16 @@ namespace BTCPayServer.Data
         public string CryptoCode { get; set; }
 
 #pragma warning disable CS0618
-        public string GetCryptoCode()
+        public Payments.PaymentMethodId GetPaymentMethodId()
         {
-            return string.IsNullOrEmpty(CryptoCode) ? "BTC" : CryptoCode;
+            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("#");
+            var index = Address.IndexOf("#", StringComparison.InvariantCulture);
             if (index == -1)
                 return Address;
             return Address.Substring(0, index);

BTCPayServer/Data/StoreData.cs

@@ -12,6 +12,8 @@ using System.ComponentModel;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using BTCPayServer.Services.Rates;
+using BTCPayServer.Payments;
+using BTCPayServer.JsonConverters;
 
 namespace BTCPayServer.Data
 {
@@ -28,6 +30,11 @@ namespace BTCPayServer.Data
             get; set;
         }
 
+        public List<AppData> Apps
+        {
+            get; set;
+        }
+
         [Obsolete("Use GetDerivationStrategies instead")]
         public string DerivationStrategy
         {
@@ -41,10 +48,12 @@ namespace BTCPayServer.Data
             set;
         }
 
-        public IEnumerable<DerivationStrategy> GetDerivationStrategies(BTCPayNetworkProvider networks)
+        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)
@@ -60,54 +69,63 @@ namespace BTCPayServer.Data
                 JObject strategies = JObject.Parse(DerivationStrategies);
                 foreach (var strat in strategies.Properties())
                 {
-                    var network = networks.GetNetwork(strat.Name);
+                    var paymentMethodId = PaymentMethodId.Parse(strat.Name);
+                    var network = networks.GetNetwork(paymentMethodId.CryptoCode);
                     if (network != null)
                     {
-                        if (network == networks.BTC && btcReturned)
+                        if (network == networks.BTC && paymentMethodId.PaymentType == PaymentTypes.BTCLike && btcReturned)
                             continue;
                         if (strat.Value.Type == JTokenType.Null)
                             continue;
-                        yield return BTCPayServer.DerivationStrategy.Parse(strat.Value.Value<string>(), network);
+                        yield return PaymentMethodExtensions.Deserialize(paymentMethodId, strat.Value, network);
                     }
                 }
             }
 #pragma warning restore CS0618
         }
 
-        public void SetDerivationStrategy(BTCPayNetwork network, string derivationScheme)
+        /// <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())
             {
-                if (strat.Name == network.CryptoCode)
+                var stratId = PaymentMethodId.Parse(strat.Name);
+                if (stratId.IsBTCOnChain)
                 {
-                    if (network.IsBTC)
-                        DerivationStrategy = null;
-                    if (string.IsNullOrEmpty(derivationScheme))
+                    // Legacy stuff which should go away
+                    DerivationStrategy = null;
+                }
+                if (stratId == paymentMethodId)
+                {
+                    if (supportedPaymentMethod == null)
                     {
                         strat.Remove();
                     }
                     else
                     {
-                        strat.Value = new JValue(derivationScheme);
+                        strat.Value = PaymentMethodExtensions.Serialize(supportedPaymentMethod);
                     }
                     existing = true;
                     break;
                 }
             }
 
-            if (!existing && string.IsNullOrEmpty(derivationScheme))
+            if(!existing && supportedPaymentMethod == null && paymentMethodId.IsBTCOnChain)
             {
-                if (network.IsBTC)
-                    DerivationStrategy = null;
+                DerivationStrategy = null;
             }
-            else if (!existing)
-                strategies.Add(new JProperty(network.CryptoCode, new JValue(derivationScheme)));
-            // This is deprecated so we don't have to set anymore
-            //if (network.IsBTC)
-            //    DerivationStrategy = derivationScheme;
+            else if (!existing && supportedPaymentMethod != null)
+                strategies.Add(new JProperty(supportedPaymentMethod.PaymentId.ToString(), PaymentMethodExtensions.Serialize(supportedPaymentMethod)));
             DerivationStrategies = strategies.ToString();
 #pragma warning restore CS0618
         }
@@ -201,6 +219,11 @@ namespace BTCPayServer.Data
         {
             get; set;
         }
+        public bool AllowCoinConversion
+        {
+            get; set;
+        }
+        public string DefaultLang { get; set; }
         [DefaultValue(60)]
         [JsonProperty(DefaultValueHandling = DefaultValueHandling.Populate)]
         public int MonitoringExpiration
@@ -237,9 +260,19 @@ namespace BTCPayServer.Data
         public List<RateRule> RateRules { get; set; } = new List<RateRule>();
         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 IRateProvider ApplyRateRules(BTCPayNetwork network, IRateProvider rateProvider)
         {
-            if (!string.IsNullOrEmpty(PreferredExchange))
+            if (!PreferredExchange.IsCoinAverage())
             {
                 // If the original rateProvider is a cache, use the same inner provider as fallback, and same memory cache to wrap it all
                 if (rateProvider is CachedRateProvider cachedRateProvider)
@@ -248,7 +281,7 @@ namespace BTCPayServer.Data
                         new CoinAverageRateProvider(network.CryptoCode) { Exchange = PreferredExchange },
                         cachedRateProvider.Inner
                     });
-                    rateProvider = new CachedRateProvider(network.CryptoCode, rateProvider, cachedRateProvider.MemoryCache);
+                    rateProvider = new CachedRateProvider(network.CryptoCode, rateProvider, cachedRateProvider.MemoryCache) { AdditionalScope = PreferredExchange };
                 }
                 else
                 {

BTCPayServer/DerivationSchemeParser.cs

@@ -0,0 +1,180 @@
+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 ChainType ChainType { get; set; }
+        public Script HintScriptPubKey { get; set; }
+
+        public DerivationSchemeParser(Network expectedNetwork, ChainType chainType)
+        {
+            Network = expectedNetwork;
+            ChainType = chainType;
+        }
+
+        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");
+                }
+            }
+
+            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(ChainType == NBXplorer.ChainType.Main ? 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

@@ -2,17 +2,19 @@
 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
+    public class DerivationStrategy : ISupportedPaymentMethod
     {
         private DerivationStrategyBase _DerivationStrategy;
         private BTCPayNetwork _Network;
 
-        DerivationStrategy(DerivationStrategyBase result, BTCPayNetwork network)
+        public DerivationStrategy(DerivationStrategyBase result, BTCPayNetwork network)
         {
             this._DerivationStrategy = result;
             this._Network = network;
@@ -32,6 +34,8 @@ namespace BTCPayServer
 
         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

@@ -88,7 +88,9 @@ namespace BTCPayServer
                 }
             }
 
-            Logs.Events.LogInformation(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,11 +2,18 @@
 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; }

BTCPayServer/Events/InvoiceNeedUpdateEvent.cs

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

BTCPayServer/Events/InvoiceNewAddressEvent.cs

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

BTCPayServer/Events/InvoiceStopWatchedEvent.cs

@@ -7,6 +7,10 @@ namespace BTCPayServer.Events
 {
     public class InvoiceStopWatchedEvent
     {
+        public InvoiceStopWatchedEvent(string invoiceId)
+        {
+            this.InvoiceId = invoiceId;
+        }
         public string InvoiceId { get; set; }
         public override string ToString()
         {

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 BTCPayNetwork Network { get; set; }
-        public Script ScriptPubKey { get; set; }
-
-        public override string ToString()
-        {
-            String address = ScriptPubKey.GetDestinationAddress(Network.NBitcoinNetwork)?.ToString() ?? ScriptPubKey.ToString();
-            return $"{address} received a transaction ({Network.CryptoCode})";
-        }
-    }
-}

BTCPayServer/ExplorerClientProvider.cs

@@ -6,6 +6,7 @@ using System.Threading.Tasks;
 using BTCPayServer.Configuration;
 using BTCPayServer.Logging;
 using NBXplorer;
+using BTCPayServer.HostedServices;
 
 namespace BTCPayServer
 {
@@ -15,9 +16,10 @@ namespace BTCPayServer
         BTCPayServerOptions _Options;
 
         public BTCPayNetworkProvider NetworkProviders => _NetworkProviders;
-
-        public ExplorerClientProvider(BTCPayNetworkProvider networkProviders, BTCPayServerOptions options)
+        NBXplorerDashboard _Dashboard;
+        public ExplorerClientProvider(BTCPayNetworkProvider networkProviders, BTCPayServerOptions options, NBXplorerDashboard dashboard)
         {
+            _Dashboard = dashboard;
             _NetworkProviders = networkProviders;
             _Options = options;
 
@@ -68,6 +70,16 @@ namespace BTCPayServer
             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);

BTCPayServer/Extensions.cs

@@ -21,16 +21,60 @@ 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;
 
 namespace BTCPayServer
 {
     public static class Extensions
     {
+        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 bool IsCoinAverage(this string exchangeName)
+        {
+            string[] coinAverages = new[] { "coinaverage", "bitcoinaverage" };
+            return String.IsNullOrWhiteSpace(exchangeName) ? true : coinAverages.Contains(exchangeName, StringComparer.OrdinalIgnoreCase) ? true : false;
+        }
+
         public static async Task<Dictionary<uint256, TransactionResult>> GetTransactions(this BTCPayWallet client, uint256[] hashes, CancellationToken cts = default(CancellationToken))
         {
             hashes = hashes.Distinct().ToArray();
@@ -42,7 +86,7 @@ namespace BTCPayServer
         }
         public static string WithTrailingSlash(this string str)
         {
-            if (str.EndsWith("/"))
+            if (str.EndsWith("/", StringComparison.InvariantCulture))
                 return str;
             return str + "/";
         }

BTCPayServer/HostedServices/InvoiceNotificationManager.cs

@@ -19,6 +19,7 @@ using Microsoft.Extensions.Hosting;
 using BTCPayServer.Events;
 using NBXplorer;
 using BTCPayServer.Services.Invoices;
+using BTCPayServer.Payments;
 
 namespace BTCPayServer.HostedServices
 {
@@ -74,7 +75,8 @@ namespace BTCPayServer.HostedServices
                 if (string.IsNullOrEmpty(invoice.NotificationURL))
                     return;
                 _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(invoice.Id, eventCode, name));
-                await SendNotification(invoice, eventCode, name, cts.Token);
+                var response = await SendNotification(invoice, eventCode, name, cts.Token);
+                response.EnsureSuccessStatusCode();
                 return;
             }
             catch (OperationCanceledException) when (cts.IsCancellationRequested)
@@ -111,7 +113,7 @@ namespace BTCPayServer.HostedServices
             try
             {
                 HttpResponseMessage response = await SendNotification(job.Invoice, job.EventCode, job.Message, cts.Token);
-                reschedule = response.StatusCode != System.Net.HttpStatusCode.OK;
+                reschedule = !response.IsSuccessStatusCode;
                 Logger.LogInformation("Job " + jobId + " returned " + response.StatusCode);
 
                 _EventAggregator.Publish<InvoiceIPNEvent>(new InvoiceIPNEvent(job.Invoice.Id, job.EventCode, job.Message)
@@ -137,7 +139,7 @@ namespace BTCPayServer.HostedServices
                 reschedule = true;
 
                 List<string> messages = new List<string>();
-                while(ex != null)
+                while (ex != null)
                 {
                     messages.Add(ex.Message);
                     ex = ex.InnerException;
@@ -201,7 +203,7 @@ namespace BTCPayServer.HostedServices
 
             // 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.CryptoCode == "BTC");
+            var btcCryptoInfo = dto.CryptoInfo.FirstOrDefault(c => c.GetpaymentMethodId() == new PaymentMethodId("BTC", Payments.PaymentTypes.BTCLike));
             if (btcCryptoInfo != null)
             {
 #pragma warning disable CS0618
@@ -228,10 +230,68 @@ namespace BTCPayServer.HostedServices
 
             request.RequestUri = new Uri(invoice.NotificationURL, UriKind.Absolute);
             request.Content = new StringContent(notificationString, UTF8, "application/json");
-            var response = await _Client.SendAsync(request, cancellation);
+            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)

BTCPayServer/HostedServices/InvoiceWatcher.cs

@@ -25,13 +25,10 @@ namespace BTCPayServer.HostedServices
     {
         class UpdateInvoiceContext
         {
-            public UpdateInvoiceContext()
+            public UpdateInvoiceContext(InvoiceEntity invoice)
             {
-
+                Invoice = invoice;
             }
-
-            public Dictionary<BTCPayNetwork, KnownState> KnownStates { get; set; }
-            public Dictionary<BTCPayNetwork, KnownState> ModifiedKnownStates { get; set; } = new Dictionary<BTCPayNetwork, KnownState>();
             public InvoiceEntity Invoice { get; set; }
             public List<object> Events { get; set; } = new List<object>();
 
@@ -46,97 +43,20 @@ namespace BTCPayServer.HostedServices
 
         InvoiceRepository _InvoiceRepository;
         EventAggregator _EventAggregator;
-        BTCPayWalletProvider _WalletProvider;
         BTCPayNetworkProvider _NetworkProvider;
 
         public InvoiceWatcher(
-            IHostingEnvironment env,
             BTCPayNetworkProvider networkProvider,
             InvoiceRepository invoiceRepository,
-            EventAggregator eventAggregator,
-            BTCPayWalletProvider walletProvider)
+            EventAggregator eventAggregator)
         {
             PollInterval = TimeSpan.FromMinutes(1.0);
-            _WalletProvider = walletProvider ?? throw new ArgumentNullException(nameof(walletProvider));
             _InvoiceRepository = invoiceRepository ?? throw new ArgumentNullException(nameof(invoiceRepository));
             _EventAggregator = eventAggregator ?? throw new ArgumentNullException(nameof(eventAggregator));
             _NetworkProvider = networkProvider;
         }
         CompositeDisposable leases = new CompositeDisposable();
 
-        async Task NotifyReceived(Script scriptPubKey, BTCPayNetwork network)
-        {
-            var invoice = await _InvoiceRepository.GetInvoiceIdFromScriptPubKey(scriptPubKey, network.CryptoCode);
-            if (invoice != null)
-                _WatchRequests.Add(invoice);
-        }
-
-        async Task NotifyBlock()
-        {
-            foreach (var invoice in await _InvoiceRepository.GetPendingInvoices())
-            {
-                _WatchRequests.Add(invoice);
-            }
-        }
-
-        private async Task UpdateInvoice(string invoiceId, CancellationToken cancellation)
-        {
-            Dictionary<BTCPayNetwork, KnownState> changes = new Dictionary<BTCPayNetwork, KnownState>();
-            while (!cancellation.IsCancellationRequested)
-            {
-                try
-                {
-                    var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId, true).ConfigureAwait(false);
-                    if (invoice == null)
-                        break;
-                    var stateBefore = invoice.Status;
-                    var updateContext = new UpdateInvoiceContext()
-                    {
-                        Invoice = invoice,
-                        KnownStates = changes
-                    };
-                    await UpdateInvoice(updateContext).ConfigureAwait(false);
-                    if (updateContext.Dirty)
-                    {
-                        await _InvoiceRepository.UpdateInvoiceStatus(invoice.Id, invoice.Status, invoice.ExceptionStatus).ConfigureAwait(false);
-                        updateContext.Events.Add(new InvoiceDataChangedEvent() { Status = invoice.Status, ExceptionStatus = invoice.ExceptionStatus, InvoiceId = invoice.Id });
-                    }
-
-                    var changed = stateBefore != invoice.Status;
-
-                    foreach (var evt in updateContext.Events)
-                    {
-                        _EventAggregator.Publish(evt, evt.GetType());
-                    }
-
-                    foreach (var modifiedKnownState in updateContext.ModifiedKnownStates)
-                    {
-                        changes.AddOrReplace(modifiedKnownState.Key, modifiedKnownState.Value);
-                    }
-
-                    if (invoice.Status == "complete" ||
-                       ((invoice.Status == "invalid" || invoice.Status == "expired") && invoice.MonitoringExpiration < DateTimeOffset.UtcNow))
-                    {
-                        if (await _InvoiceRepository.RemovePendingInvoice(invoice.Id).ConfigureAwait(false))
-                            _EventAggregator.Publish<InvoiceStopWatchedEvent>(new InvoiceStopWatchedEvent() { InvoiceId = invoice.Id });
-                        break;
-                    }
-
-                    if (!changed || cancellation.IsCancellationRequested)
-                        break;
-                }
-                catch (OperationCanceledException) when (cancellation.IsCancellationRequested)
-                {
-                    break;
-                }
-                catch (Exception ex)
-                {
-                    Logs.PayServer.LogError(ex, "Unhandled error on watching invoice " + invoiceId);
-                    await Task.Delay(10000, cancellation).ConfigureAwait(false);
-                }
-            }
-        }
-
 
         private async Task UpdateInvoice(UpdateInvoiceContext context)
         {
@@ -150,250 +70,118 @@ namespace BTCPayServer.HostedServices
                 invoice.Status = "expired";
             }
 
-            var derivationStrategies = invoice.GetDerivationStrategies(_NetworkProvider).ToArray();
-            var payments = await GetPaymentsWithTransaction(derivationStrategies, invoice);
-            foreach (Task<NetworkCoins> coinsAsync in GetCoinsPerNetwork(context, invoice, derivationStrategies))
+            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")
             {
-                var coins = await coinsAsync;
-                if (coins.TimestampedCoins.Length == 0)
+                if (accounting.Paid >= accounting.TotalDue)
+                {
+                    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.TotalDue && 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.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.TotalDue)
+                {
+                    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.TotalDue))
+                {
+                    await _InvoiceRepository.UnaffectAddress(invoice.Id);
+                    context.Events.Add(new InvoiceEvent(invoice, 1013, "invoice_failedToConfirm"));
+                    invoice.Status = "invalid";
+                    context.MarkDirty();
+                }
+                else if (confirmedAccounting.Paid >= accounting.TotalDue)
+                {
+                    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.TotalDue)
+                {
+                    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;
-                bool dirtyAddress = false;
-                if (coins.State != null)
-                    context.ModifiedKnownStates.AddOrReplace(coins.Wallet.Network, coins.State);
-                var alreadyAccounted = new HashSet<OutPoint>(invoice.GetPayments(coins.Wallet.Network).Select(p => p.Outpoint));
-
-                foreach (var coin in coins.TimestampedCoins.Where(c => !alreadyAccounted.Contains(c.Coin.Outpoint)))
+                var currentAccounting = paymentMethod.Calculate();
+                var distanceFromZero = Math.Abs(currentAccounting.DueUncapped.ToDecimal(MoneyUnit.BTC));
+                if (result == null || distanceFromZero < nearestToZero)
                 {
-                    var payment = await _InvoiceRepository.AddPayment(invoice.Id, coin.DateTime, coin.Coin, coins.Wallet.Network.CryptoCode).ConfigureAwait(false);
-#pragma warning disable CS0618
-                    invoice.Payments.Add(payment);
-#pragma warning restore CS0618
-                    alreadyAccounted.Add(coin.Coin.Outpoint);
-                    context.Events.Add(new InvoiceEvent(invoice, 1002, "invoice_receivedPayment"));
-                    dirtyAddress = true;
-                }
-                if (dirtyAddress)
-                {
-                    payments = await GetPaymentsWithTransaction(derivationStrategies, invoice);
-                }
-                var network = coins.Wallet.Network;
-                var cryptoData = invoice.GetCryptoData(network, _NetworkProvider);
-                var cryptoDataAll = invoice.GetCryptoData(_NetworkProvider);
-                var accounting = cryptoData.Calculate();
-
-                if (invoice.Status == "new" || invoice.Status == "expired")
-                {
-                    var totalPaid = payments.Select(p => p.Payment.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
-                    if (totalPaid >= accounting.TotalDue)
-                    {
-                        if (invoice.Status == "new")
-                        {
-                            context.Events.Add(new InvoiceEvent(invoice, 1003, "invoice_paidInFull"));
-                            invoice.Status = "paid";
-                            invoice.ExceptionStatus = 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 (totalPaid > accounting.TotalDue && invoice.ExceptionStatus != "paidOver")
-                    {
-                        invoice.ExceptionStatus = "paidOver";
-                        await _InvoiceRepository.UnaffectAddress(invoice.Id);
-                        context.MarkDirty();
-                    }
-
-                    if (totalPaid < accounting.TotalDue && invoice.GetPayments().Count != 0 && invoice.ExceptionStatus != "paidPartial")
-                    {
-                        invoice.ExceptionStatus = "paidPartial";
-                        context.MarkDirty();
-                        if (dirtyAddress)
-                        {
-                            var address = await coins.Wallet.ReserveAddressAsync(coins.Strategy);
-                            Logs.PayServer.LogInformation("Generate new " + address);
-                            await _InvoiceRepository.NewAddress(invoice.Id, address, network);
-                        }
-                    }
-                }
-
-                if (invoice.Status == "paid")
-                {
-                    IEnumerable<AccountedPaymentEntity> transactions = payments;
-                    if (invoice.SpeedPolicy == SpeedPolicy.HighSpeed)
-                    {
-                        transactions = transactions.Where(t => t.Confirmations >= 1 || !t.Transaction.RBF);
-                    }
-                    else if (invoice.SpeedPolicy == SpeedPolicy.MediumSpeed)
-                    {
-                        transactions = transactions.Where(t => t.Confirmations >= 1);
-                    }
-                    else if (invoice.SpeedPolicy == SpeedPolicy.LowSpeed)
-                    {
-                        transactions = transactions.Where(t => t.Confirmations >= 6);
-                    }
-
-                    var totalConfirmed = transactions.Select(t => t.Payment.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
-
-                    if (// Is after the monitoring deadline
-                       (invoice.MonitoringExpiration < DateTimeOffset.UtcNow)
-                       &&
-                       // And not enough amount confirmed
-                       (totalConfirmed < accounting.TotalDue))
-                    {
-                        await _InvoiceRepository.UnaffectAddress(invoice.Id);
-                        context.Events.Add(new InvoiceEvent(invoice, 1013, "invoice_failedToConfirm"));
-                        invoice.Status = "invalid";
-                        context.MarkDirty();
-                    }
-                    else if (totalConfirmed >= accounting.TotalDue)
-                    {
-                        await _InvoiceRepository.UnaffectAddress(invoice.Id);
-                        context.Events.Add(new InvoiceEvent(invoice, 1005, "invoice_confirmed"));
-                        invoice.Status = "confirmed";
-                        context.MarkDirty();
-                    }
-                }
-
-                if (invoice.Status == "confirmed")
-                {
-                    IEnumerable<AccountedPaymentEntity> transactions = payments;
-                    transactions = transactions.Where(t => t.Confirmations >= 6);
-                    var totalConfirmed = transactions.Select(t => t.Payment.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
-                    if (totalConfirmed >= accounting.TotalDue)
-                    {
-                        context.Events.Add(new InvoiceEvent(invoice, 1006, "invoice_completed"));
-                        invoice.Status = "complete";
-                        context.MarkDirty();
-                    }
+                    result = paymentMethod;
+                    nearestToZero = distanceFromZero;
+                    accounting = currentAccounting;
                 }
             }
-        }
-
-        private IEnumerable<Task<NetworkCoins>> GetCoinsPerNetwork(UpdateInvoiceContext context, InvoiceEntity invoice, DerivationStrategy[] strategies)
-        {
-            return strategies
-                                .Select(d => (Wallet: _WalletProvider.GetWallet(d.Network),
-                                              Network: d.Network,
-                                              Strategy: d.DerivationStrategyBase))
-                                .Where(d => d.Wallet != null)
-                                .Select(d => (Network: d.Network,
-                                              Coins: d.Wallet.GetCoins(d.Strategy, context.KnownStates.TryGet(d.Network))))
-                                .Select(async d =>
-                                {
-                                    var coins = await d.Coins;
-                                    // Keep only coins from the invoice
-                                    coins.TimestampedCoins = coins.TimestampedCoins.Where(c => invoice.AvailableAddressHashes.Contains(c.Coin.ScriptPubKey.Hash.ToString() + d.Network.CryptoCode)).ToArray();
-                                    return coins;
-                                })
-                                .ToArray();
-        }
-
-
-        private async Task<IEnumerable<AccountedPaymentEntity>> GetPaymentsWithTransaction(DerivationStrategy[] derivations, InvoiceEntity invoice)
-        {
-            List<PaymentEntity> updatedPaymentEntities = new List<PaymentEntity>();
-            List<AccountedPaymentEntity> accountedPayments = new List<AccountedPaymentEntity>();
-            foreach (var network in derivations.Select(d => d.Network))
-            {
-                var wallet = _WalletProvider.GetWallet(network);
-                if (wallet == null)
-                    continue;
-
-                var transactions = await wallet.GetTransactions(invoice.GetPayments(wallet.Network)
-                    .Select(t => t.Outpoint.Hash)
-                    .ToArray());
-                var conflicts = GetConflicts(transactions.Select(t => t.Value));
-                foreach (var payment in invoice.GetPayments(network))
-                {
-                    if (!transactions.TryGetValue(payment.Outpoint.Hash, out TransactionResult tx))
-                        continue;
-
-                    AccountedPaymentEntity accountedPayment = new AccountedPaymentEntity()
-                    {
-                        Confirmations = tx.Confirmations,
-                        Transaction = tx.Transaction,
-                        Payment = payment
-                    };
-                    var txId = accountedPayment.Transaction.GetHash();
-                    var txConflict = conflicts.GetConflict(txId);
-                    var accounted = txConflict == null || txConflict.IsWinner(txId);
-                    if (accounted != payment.Accounted)
-                    {
-                        updatedPaymentEntities.Add(payment);
-                        payment.Accounted = accounted;
-                    }
-
-                    if (accounted)
-                        accountedPayments.Add(accountedPayment);
-                }
-            }
-            await _InvoiceRepository.UpdatePayments(updatedPaymentEntities);
-            return accountedPayments;
-        }
-
-        class TransactionConflict
-        {
-            public Dictionary<uint256, TransactionResult> Transactions { get; set; } = new Dictionary<uint256, TransactionResult>();
-
-
-            uint256 _Winner;
-            public bool IsWinner(uint256 txId)
-            {
-                if (_Winner == null)
-                {
-                    var confirmed = Transactions.FirstOrDefault(t => t.Value.Confirmations >= 1);
-                    if (!confirmed.Equals(default(KeyValuePair<uint256, TransactionResult>)))
-                    {
-                        _Winner = confirmed.Key;
-                    }
-                    else
-                    {
-                        // Take the most recent (bitcoin node would not forward a conflict without a successfull RBF)
-                        _Winner = Transactions
-                                .OrderByDescending(t => t.Value.Timestamp)
-                                .First()
-                                .Key;
-                    }
-                }
-                return _Winner == txId;
-            }
-        }
-        class TransactionConflicts : List<TransactionConflict>
-        {
-            public TransactionConflicts(IEnumerable<TransactionConflict> collection) : base(collection)
-            {
-
-            }
-
-            public TransactionConflict GetConflict(uint256 txId)
-            {
-                return this.FirstOrDefault(c => c.Transactions.ContainsKey(txId));
-            }
-        }
-        private TransactionConflicts GetConflicts(IEnumerable<TransactionResult> transactions)
-        {
-            Dictionary<OutPoint, TransactionConflict> conflictsByOutpoint = new Dictionary<OutPoint, TransactionConflict>();
-            foreach (var tx in transactions)
-            {
-                var hash = tx.Transaction.GetHash();
-                foreach (var input in tx.Transaction.Inputs)
-                {
-                    TransactionConflict conflict = new TransactionConflict();
-                    if (!conflictsByOutpoint.TryAdd(input.PrevOut, conflict))
-                    {
-                        conflict = conflictsByOutpoint[input.PrevOut];
-                    }
-                    if (!conflict.Transactions.ContainsKey(hash))
-                        conflict.Transactions.Add(hash, tx);
-                }
-            }
-            return new TransactionConflicts(conflictsByOutpoint.Where(c => c.Value.Transactions.Count > 1).Select(c => c.Value));
+            return result;
         }
 
         TimeSpan _PollInterval;
@@ -409,113 +197,136 @@ namespace BTCPayServer.HostedServices
             }
         }
 
-        private async Task Watch(string invoiceId)
+        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 now = DateTimeOffset.UtcNow;
-                if (invoice.ExpirationTime > now)
+                var delay = invoice.ExpirationTime - DateTimeOffset.UtcNow;
+                if (delay > TimeSpan.Zero)
                 {
-                    await Task.Delay(invoice.ExpirationTime - now, _Cts.Token);
-                    _WatchRequests.Add(invoiceId);
+                    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 _Poller;
         Task _Loop;
+        Task _WaitingInvoices;
         CancellationTokenSource _Cts;
 
         public Task StartAsync(CancellationToken cancellationToken)
         {
             _Cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
-
-            _Poller = StartPoller(_Cts.Token);
             _Loop = StartLoop(_Cts.Token);
+            _WaitingInvoices = WaitPendingInvoices();
 
-            leases.Add(_EventAggregator.Subscribe<Events.NewBlockEvent>(async b => { await NotifyBlock(); }));
-            leases.Add(_EventAggregator.Subscribe<Events.TxOutReceivedEvent>(async b => { await NotifyReceived(b.ScriptPubKey, b.Network); }));
+            leases.Add(_EventAggregator.Subscribe<Events.InvoiceNeedUpdateEvent>(b =>
+            {
+                Watch(b.InvoiceId);
+            }));
             leases.Add(_EventAggregator.Subscribe<Events.InvoiceEvent>(async b =>
             {
-                if(b.Name == "invoice_created")
-                { 
-                    await Watch(b.InvoiceId);
+                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 StartPoller(CancellationToken cancellation)
+        private async Task WaitPendingInvoices()
         {
-            try
-            {
-                while (!cancellation.IsCancellationRequested)
-                {
-                    try
-                    {
-                        foreach (var pending in await _InvoiceRepository.GetPendingInvoices())
-                        {
-                            _WatchRequests.Add(pending);
-                        }
-                        await Task.Delay(PollInterval, cancellation);
-                    }
-                    catch (Exception ex) when (!cancellation.IsCancellationRequested)
-                    {
-                        Logs.PayServer.LogError(ex, $"Unhandled exception in InvoiceWatcher poller");
-                        await Task.Delay(PollInterval, cancellation);
-                    }
-                }
-            }
-            catch when (cancellation.IsCancellationRequested) { }
+            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
-            ConcurrentDictionary<string, Task> executing = new ConcurrentDictionary<string, Task>();
             try
             {
-                foreach (var item in _WatchRequests.GetConsumingEnumerable(cancellation))
+                foreach (var invoiceId in _WatchRequests.GetConsumingEnumerable(cancellation))
                 {
-                    bool added = false;
-                    var task = executing.GetOrAdd(item, async i =>
+                    int maxLoop = 5;
+                    int loopCount = -1;
+                    while (!cancellation.IsCancellationRequested && loopCount < maxLoop)
                     {
+                        loopCount++;
                         try
                         {
-                            added = true;
-                            await UpdateInvoice(i, cancellation);
-                        }
-                        catch (Exception ex) when (!cancellation.IsCancellationRequested)
-                        {
-                            Logs.PayServer.LogCritical(ex, $"Error in the InvoiceWatcher loop (Invoice {i})");
-                        }
-                    });
+                            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));
+                            }
 
-                    if (!added && task.Status == TaskStatus.RanToCompletion)
-                    {
-                        executing.TryRemove(item, out Task t);
-                        _WatchRequests.Add(item);
+                            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)
             {
             }
-            finally
-            {
-                await Task.WhenAll(executing.Values);
-            }
             Logs.PayServer.LogInformation("Stop watching invoices");
         }
 
@@ -523,7 +334,8 @@ namespace BTCPayServer.HostedServices
         {
             leases.Dispose();
             _Cts.Cancel();
-            return Task.WhenAll(_Poller, _Loop);
+            var waitingPendingInvoices = _WaitingInvoices ?? Task.CompletedTask;
+            return Task.WhenAll(waitingPendingInvoices, _Loop);
         }
     }
 }

BTCPayServer/HostedServices/NBXplorerListener.cs

@@ -1,213 +0,0 @@
-using System;
-using Microsoft.Extensions.Logging;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using BTCPayServer.Logging;
-using BTCPayServer.Services.Invoices;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.Hosting;
-using NBXplorer;
-using System.Collections.Concurrent;
-using NBXplorer.DerivationStrategy;
-using BTCPayServer.Events;
-using BTCPayServer.Services;
-
-namespace BTCPayServer.HostedServices
-{
-    public class NBXplorerListener : IHostedService
-    {
-        EventAggregator _Aggregator;
-        ExplorerClientProvider _ExplorerClients;
-        IApplicationLifetime _Lifetime;
-        InvoiceRepository _InvoiceRepository;
-        private TaskCompletionSource<bool> _RunningTask;
-        private CancellationTokenSource _Cts;
-        NBXplorerDashboard _Dashboards;
-        TransactionCacheProvider _TxCache;
-
-        public NBXplorerListener(ExplorerClientProvider explorerClients,
-                                NBXplorerDashboard dashboard,
-                                TransactionCacheProvider cacheProvider,
-                                InvoiceRepository invoiceRepository,
-                                EventAggregator aggregator, IApplicationLifetime lifetime)
-        {
-            PollInterval = TimeSpan.FromMinutes(1.0);
-            _Dashboards = dashboard;
-            _InvoiceRepository = invoiceRepository;
-            _ExplorerClients = explorerClients;
-            _Aggregator = aggregator;
-            _Lifetime = lifetime;
-            _TxCache = cacheProvider;
-        }
-
-        CompositeDisposable leases = new CompositeDisposable();
-        ConcurrentDictionary<string, NotificationSession> _Sessions = new ConcurrentDictionary<string, NotificationSession>();
-        private Timer _ListenPoller;
-
-        TimeSpan _PollInterval;
-        public TimeSpan PollInterval
-        {
-            get
-            {
-                return _PollInterval;
-            }
-            set
-            {
-                _PollInterval = value;
-                if (_ListenPoller != null)
-                {
-                    _ListenPoller.Change(0, (int)value.TotalMilliseconds);
-                }
-            }
-        }
-
-        public Task StartAsync(CancellationToken cancellationToken)
-        {
-            _RunningTask = new TaskCompletionSource<bool>();
-            _Cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
-            leases.Add(_Aggregator.Subscribe<Events.NBXplorerStateChangedEvent>(async nbxplorerEvent =>
-            {
-                if (nbxplorerEvent.NewState == NBXplorerState.Ready)
-                {
-                    await Listen(nbxplorerEvent.Network);
-                }
-            }));
-
-            _ListenPoller = new Timer(async s =>
-            {
-                foreach (var nbxplorerState in _Dashboards.GetAll())
-                {
-                    if (nbxplorerState.Status != null && nbxplorerState.Status.IsFullySynched)
-                    {
-                        await Listen(nbxplorerState.Network);
-                    }
-                }
-            }, null, 0, (int)PollInterval.TotalMilliseconds);
-            leases.Add(_ListenPoller);
-
-            leases.Add(_Aggregator.Subscribe<Events.InvoiceEvent>(async inv =>
-            {
-                if (inv.Name == "invoice_created")
-                {
-                    var invoice = await _InvoiceRepository.GetInvoice(null, inv.InvoiceId);
-                    List<Task> listeningDerivations = new List<Task>();
-                    foreach (var notificationSessions in _Sessions)
-                    {
-                        var derivationStrategy = GetStrategy(notificationSessions.Key, invoice);
-                        if (derivationStrategy != null)
-                        {
-                            listeningDerivations.Add(notificationSessions.Value.ListenDerivationSchemesAsync(new[] { derivationStrategy }, _Cts.Token));
-                        }
-                    }
-                    await Task.WhenAll(listeningDerivations.ToArray()).ConfigureAwait(false);
-                }
-            }));
-            return Task.CompletedTask;
-        }
-
-        private async Task Listen(BTCPayNetwork network)
-        {
-            bool cleanup = false;
-            try
-            {
-                if (_Sessions.ContainsKey(network.CryptoCode))
-                    return;
-                var client = _ExplorerClients.GetExplorerClient(network);
-                if (client == null)
-                    return;
-                if (_Cts.IsCancellationRequested)
-                    return;
-                var session = await client.CreateNotificationSessionAsync(_Cts.Token).ConfigureAwait(false);
-                if (!_Sessions.TryAdd(network.CryptoCode, session))
-                {
-                    await session.DisposeAsync();
-                    return;
-                }
-                cleanup = true;
-                using (session)
-                {
-                    await session.ListenNewBlockAsync(_Cts.Token).ConfigureAwait(false);
-                    await session.ListenDerivationSchemesAsync((await GetStrategies(network)).ToArray(), _Cts.Token).ConfigureAwait(false);
-                    Logs.PayServer.LogInformation($"Connected to WebSocket of NBXplorer ({network.CryptoCode})");
-                    while (!_Cts.IsCancellationRequested)
-                    {
-                        var newEvent = await session.NextEventAsync(_Cts.Token).ConfigureAwait(false);
-                        switch (newEvent)
-                        {
-                            case NBXplorer.Models.NewBlockEvent evt:
-                                _TxCache.GetTransactionCache(network).NewBlock(evt.Hash, evt.PreviousBlockHash);
-                                _Aggregator.Publish(new Events.NewBlockEvent() { CryptoCode = evt.CryptoCode });
-                                break;
-                            case NBXplorer.Models.NewTransactionEvent evt:
-                                foreach (var txout in evt.Outputs)
-                                {
-                                    _TxCache.GetTransactionCache(network).AddToCache(evt.TransactionData);
-                                    _Aggregator.Publish(new Events.TxOutReceivedEvent()
-                                    {
-                                        Network = network,
-                                        ScriptPubKey = txout.ScriptPubKey
-                                    });
-                                }
-                                break;
-                            default:
-                                Logs.PayServer.LogWarning("Received unknown message from NBXplorer");
-                                break;
-                        }
-                    }
-                }
-            }
-            catch when (_Cts.IsCancellationRequested) { }
-            catch (Exception ex)
-            {
-                Logs.PayServer.LogError(ex, $"Error while connecting to WebSocket of NBXplorer ({network.CryptoCode})");
-            }
-            finally
-            {
-                if (cleanup)
-                {
-                    Logs.PayServer.LogInformation($"Disconnected from WebSocket of NBXplorer ({network.CryptoCode})");
-                    _Sessions.TryRemove(network.CryptoCode, out NotificationSession unused);
-                    if (_Sessions.Count == 0 && _Cts.IsCancellationRequested)
-                    {
-                        _RunningTask.TrySetResult(true);
-                    }
-                }
-            }
-        }
-
-        private async Task<List<DerivationStrategyBase>> GetStrategies(BTCPayNetwork network)
-        {
-            List<DerivationStrategyBase> strategies = new List<DerivationStrategyBase>();
-            foreach (var invoiceId in await _InvoiceRepository.GetPendingInvoices())
-            {
-                var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId);
-                var strategy = GetStrategy(network.CryptoCode, invoice);
-                if (strategy != null)
-                    strategies.Add(strategy);
-            }
-
-            return strategies;
-        }
-
-        private DerivationStrategyBase GetStrategy(string cryptoCode, InvoiceEntity invoice)
-        {
-            foreach (var derivationStrategy in invoice.GetDerivationStrategies(_ExplorerClients.NetworkProviders))
-            {
-                if (derivationStrategy.Network.CryptoCode == cryptoCode)
-                {
-                    return derivationStrategy.DerivationStrategyBase;
-                }
-            }
-            return null;
-        }
-
-        public Task StopAsync(CancellationToken cancellationToken)
-        {
-            leases.Dispose();
-            _Cts.Cancel();
-            return Task.WhenAny(_RunningTask.Task, Task.Delay(-1, cancellationToken));
-        }
-    }
-}

BTCPayServer/HostedServices/NBXplorerWaiter.cs

@@ -41,6 +41,13 @@ namespace BTCPayServer.HostedServices
             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;
@@ -188,6 +195,7 @@ namespace BTCPayServer.HostedServices
                 _Aggregator.Publish(new NBXplorerErrorEvent(_Network, error));
             }
 
+            _Dashboard.Publish(_Network, State, status, error);
             if (oldState != State)
             {
                 if (State == NBXplorerState.Synching)
@@ -200,7 +208,6 @@ namespace BTCPayServer.HostedServices
                 }
                 _Aggregator.Publish(new NBXplorerStateChangedEvent(_Network, oldState, State));
             }
-            _Dashboard.Publish(_Network, State, status, error);
             return oldState != State;
         }
 

BTCPayServer/Hosting/BTCPayServerServices.cs

@@ -37,6 +37,7 @@ using BTCPayServer.Authentication;
 using Microsoft.Extensions.Caching.Memory;
 using BTCPayServer.Logging;
 using BTCPayServer.HostedServices;
+using Meziantou.AspNetCore.BundleTagHelpers;
 
 namespace BTCPayServer.Hosting
 {
@@ -125,13 +126,15 @@ namespace BTCPayServer.Hosting
                 }
                 return dbContext;
             });
+            services.TryAddSingleton<Payments.Lightning.LightningClientFactory>();
 
             services.TryAddSingleton<BTCPayNetworkProvider>(o => 
             {
                 var opts = o.GetRequiredService<BTCPayServerOptions>();
-                return new BTCPayNetworkProvider(opts.ChainType);
+                return opts.NetworkProvider;
             });
 
+            services.TryAddSingleton<LanguageService>();
             services.TryAddSingleton<NBXplorerDashboard>();
             services.TryAddSingleton<StoreRepository>();
             services.TryAddSingleton<BTCPayWalletProvider>();
@@ -142,10 +145,13 @@ namespace BTCPayServer.Hosting
                 BlockTarget = 20
             });
 
-            services.AddSingleton<TransactionCacheProvider>();
+            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, NBXplorerListener>();
             services.AddSingleton<IHostedService, InvoiceNotificationManager>();
             services.AddSingleton<IHostedService, InvoiceWatcher>();
 
@@ -168,17 +174,29 @@ namespace BTCPayServer.Hosting
 
             services.AddAuthorization(o =>
             {
-                o.AddPolicy("CanAccessStore", builder =>
+                o.AddPolicy(StorePolicies.CanAccessStores, builder =>
                 {
                     builder.AddRequirements(new OwnStoreAuthorizationRequirement());
                 });
 
-                o.AddPolicy("OwnStore", builder =>
+                o.AddPolicy(StorePolicies.OwnStore, builder =>
                 {
-                    builder.AddRequirements(new OwnStoreAuthorizationRequirement("Owner"));
+                    builder.AddRequirements(new OwnStoreAuthorizationRequirement(StoreRoles.Owner));
                 });
             });
 
+            // bundling
+
+            services.AddBundles();
+            services.AddTransient<BundleOptions>(provider =>
+            {
+                var opts = provider.GetRequiredService<BTCPayServerOptions>();
+                var bundle = new BundleOptions();
+                bundle.UseMinifiedFiles = opts.BundleJsCss;
+                bundle.AppendVersion = true;
+                return bundle;
+            });
+
             return services;
         }
 
@@ -194,7 +212,7 @@ namespace BTCPayServer.Hosting
             }
 
             app.UseMiddleware<BTCPayMiddleware>();
-            return app;
+            return app; 
         }
 
         static void Retry(Action act)

BTCPayServer/Hosting/BTCpayMiddleware.cs

@@ -22,6 +22,7 @@ using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Routing;
 using Microsoft.AspNetCore.Http.Extensions;
 using BTCPayServer.Controllers;
+using System.Net.WebSockets;
 
 namespace BTCPayServer.Hosting
 {
@@ -69,7 +70,7 @@ namespace BTCPayServer.Hosting
                     if (BitIdExtensions.CheckBitIDSignature(key, sig, url, body))
                     {
                         var bitid = new BitIdentity(key);
-                        httpContext.User = new GenericPrincipal(bitid, new string[0]);
+                        httpContext.User = new GenericPrincipal(bitid, Array.Empty<string>());
                         Logs.PayServer.LogDebug($"BitId signature check success for SIN {bitid.SIN}");
                     }
                 }
@@ -82,6 +83,8 @@ namespace BTCPayServer.Hosting
             {
                 await _Next(httpContext);
             }
+            catch (WebSocketException)
+            { }
             catch (UnauthorizedAccessException ex)
             {
                 await HandleBitpayHttpException(httpContext, new BitpayHttpException(401, ex.Message));

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
 {
@@ -88,6 +92,15 @@ namespace BTCPayServer.Hosting
                 options.Password.RequireNonAlphanumeric = false;
                 options.Password.RequireUppercase = false;
             });
+
+            // Needed to debug U2F for ledger support
+            //services.Configure<KestrelServerOptions>(kestrel =>
+            //{
+            //    kestrel.Listen(IPAddress.Loopback, 5012, l =>
+            //    {
+            //        l.UseHttps("devtest.pfx", "toto");
+            //    });
+            //});
         }
 
         // Big hack, tests fails if only call AddHangfire because Hangfire fail at initializing at the second test run
@@ -134,7 +147,25 @@ namespace BTCPayServer.Hosting
             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);
+            }
+            else
+            {
+                app.Map(options.RootPath, appChild =>
+                {
+                    ConfigureCore(appChild, env, prov, loggerFactory);
+                });
+            }
+        }
+
+        private static void ConfigureCore(IApplicationBuilder app, IHostingEnvironment env, IServiceProvider prov, ILoggerFactory loggerFactory)
         {
             if (env.IsDevelopment())
             {
@@ -142,9 +173,6 @@ namespace BTCPayServer.Hosting
                 app.UseBrowserLink();
             }
 
-
-            Logs.Configure(loggerFactory);
-
             //App insight do not that by itself...
             loggerFactory.AddApplicationInsights(prov, LogLevel.Information);
 

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,6 +6,7 @@ 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
@@ -333,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/Migrations/20180402095640_appdata.Designer.cs

@@ -0,0 +1,537 @@
+// <auto-generated />
+using BTCPayServer.Data;
+using BTCPayServer.Services.Invoices;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage;
+using Microsoft.EntityFrameworkCore.Storage.Internal;
+using System;
+
+namespace BTCPayServer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20180402095640_appdata")]
+    partial class appdata
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "2.0.1-rtm-125");
+
+            modelBuilder.Entity("BTCPayServer.Data.AddressInvoiceData", b =>
+                {
+                    b.Property<string>("Address")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTimeOffset?>("CreatedTime");
+
+                    b.Property<string>("InvoiceDataId");
+
+                    b.HasKey("Address");
+
+                    b.HasIndex("InvoiceDataId");
+
+                    b.ToTable("AddressInvoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.AppData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("AppType");
+
+                    b.Property<DateTimeOffset>("Created");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("Settings");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("Apps");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.HistoricalAddressInvoiceData", b =>
+                {
+                    b.Property<string>("InvoiceDataId");
+
+                    b.Property<string>("Address");
+
+                    b.Property<DateTimeOffset>("Assigned");
+
+                    b.Property<string>("CryptoCode");
+
+                    b.Property<DateTimeOffset?>("UnAssigned");
+
+                    b.HasKey("InvoiceDataId", "Address");
+
+                    b.ToTable("HistoricalAddressInvoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<DateTimeOffset>("Created");
+
+                    b.Property<string>("CustomerEmail");
+
+                    b.Property<string>("ExceptionStatus");
+
+                    b.Property<string>("ItemCode");
+
+                    b.Property<string>("OrderId");
+
+                    b.Property<string>("Status");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("Invoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceEventData", b =>
+                {
+                    b.Property<string>("InvoiceDataId");
+
+                    b.Property<string>("UniqueId");
+
+                    b.Property<string>("Message");
+
+                    b.Property<DateTimeOffset>("Timestamp");
+
+                    b.HasKey("InvoiceDataId", "UniqueId");
+
+                    b.ToTable("InvoiceEvents");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PairedSINData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Facade");
+
+                    b.Property<string>("Label");
+
+                    b.Property<DateTimeOffset>("PairingTime");
+
+                    b.Property<string>("SIN");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SIN");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("PairedSINData");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PairingCodeData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("DateCreated");
+
+                    b.Property<DateTimeOffset>("Expiration");
+
+                    b.Property<string>("Facade");
+
+                    b.Property<string>("Label");
+
+                    b.Property<string>("SIN");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.Property<string>("TokenValue");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PairingCodes");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PaymentData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Accounted");
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<string>("InvoiceDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InvoiceDataId");
+
+                    b.ToTable("Payments");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PendingInvoiceData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PendingInvoices");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.RefundAddressesData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<byte[]>("Blob");
+
+                    b.Property<string>("InvoiceDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InvoiceDataId");
+
+                    b.ToTable("RefundAddresses");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.SettingData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Settings");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.StoreData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("DefaultCrypto");
+
+                    b.Property<string>("DerivationStrategies");
+
+                    b.Property<string>("DerivationStrategy");
+
+                    b.Property<int>("SpeedPolicy");
+
+                    b.Property<byte[]>("StoreBlob");
+
+                    b.Property<byte[]>("StoreCertificate");
+
+                    b.Property<string>("StoreName");
+
+                    b.Property<string>("StoreWebsite");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Stores");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.UserStore", b =>
+                {
+                    b.Property<string>("ApplicationUserId");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.Property<string>("Role");
+
+                    b.HasKey("ApplicationUserId", "StoreDataId");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("UserStore");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Models.ApplicationUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("AccessFailedCount");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken();
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256);
+
+                    b.Property<bool>("EmailConfirmed");
+
+                    b.Property<bool>("LockoutEnabled");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("PasswordHash");
+
+                    b.Property<string>("PhoneNumber");
+
+                    b.Property<bool>("PhoneNumberConfirmed");
+
+                    b.Property<bool>("RequiresEmailConfirmation");
+
+                    b.Property<string>("SecurityStamp");
+
+                    b.Property<bool>("TwoFactorEnabled");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken();
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ClaimType");
+
+                    b.Property<string>("ClaimValue");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ClaimType");
+
+                    b.Property<string>("ClaimValue");
+
+                    b.Property<string>("UserId")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider");
+
+                    b.Property<string>("ProviderKey");
+
+                    b.Property<string>("ProviderDisplayName");
+
+                    b.Property<string>("UserId")
+                        .IsRequired();
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId");
+
+                    b.Property<string>("RoleId");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId");
+
+                    b.Property<string>("LoginProvider");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.AddressInvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("AddressInvoices")
+                        .HasForeignKey("InvoiceDataId");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.AppData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("Apps")
+                        .HasForeignKey("StoreDataId");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.HistoricalAddressInvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData")
+                        .WithMany("HistoricalAddressInvoices")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany()
+                        .HasForeignKey("StoreDataId");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceEventData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData")
+                        .WithMany("Events")
+                        .HasForeignKey("InvoiceDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.PaymentData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("Payments")
+                        .HasForeignKey("InvoiceDataId");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.RefundAddressesData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                        .WithMany("RefundAddresses")
+                        .HasForeignKey("InvoiceDataId");
+                });
+
+            modelBuilder.Entity("BTCPayServer.Data.UserStore", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser", "ApplicationUser")
+                        .WithMany("UserStores")
+                        .HasForeignKey("ApplicationUserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("UserStores")
+                        .HasForeignKey("StoreDataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("BTCPayServer.Models.ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

BTCPayServer/Migrations/20180402095640_appdata.cs

@@ -0,0 +1,45 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+using System;
+using System.Collections.Generic;
+
+namespace BTCPayServer.Migrations
+{
+    public partial class appdata : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Apps",
+                columns: table => new
+                {
+                    Id = table.Column<string>(nullable: false),
+                    AppType = table.Column<string>(nullable: true),
+                    Created = table.Column<DateTimeOffset>(nullable: false),
+                    Name = table.Column<string>(nullable: true),
+                    Settings = table.Column<string>(nullable: true),
+                    StoreDataId = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Apps", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Apps_Stores_StoreDataId",
+                        column: x => x.StoreDataId,
+                        principalTable: "Stores",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Apps_StoreDataId",
+                table: "Apps",
+                column: "StoreDataId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "Apps");
+        }
+    }
+}

BTCPayServer/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -36,6 +36,28 @@ namespace BTCPayServer.Migrations
                     b.ToTable("AddressInvoices");
                 });
 
+            modelBuilder.Entity("BTCPayServer.Data.AppData", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("AppType");
+
+                    b.Property<DateTimeOffset>("Created");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("Settings");
+
+                    b.Property<string>("StoreDataId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StoreDataId");
+
+                    b.ToTable("Apps");
+                });
+
             modelBuilder.Entity("BTCPayServer.Data.HistoricalAddressInvoiceData", b =>
                 {
                     b.Property<string>("InvoiceDataId");
@@ -407,6 +429,13 @@ namespace BTCPayServer.Migrations
                         .HasForeignKey("InvoiceDataId");
                 });
 
+            modelBuilder.Entity("BTCPayServer.Data.AppData", b =>
+                {
+                    b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                        .WithMany("Apps")
+                        .HasForeignKey("StoreDataId");
+                });
+
             modelBuilder.Entity("BTCPayServer.Data.HistoricalAddressInvoiceData", b =>
                 {
                     b.HasOne("BTCPayServer.Data.InvoiceData")

BTCPayServer/Models/AppViewModels/CreateAppViewModel.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Data;
+using BTCPayServer.Services.Apps;
+using Microsoft.AspNetCore.Mvc.Rendering;
+
+namespace BTCPayServer.Models.AppViewModels
+{
+    public class CreateAppViewModel
+    {
+        public CreateAppViewModel()
+        {
+            SetApps();
+        }
+        class Format
+        {
+            public string Name { get; set; }
+            public string Value { get; set; }
+        }
+        [Required]
+        [MaxLength(50)]
+        [MinLength(1)]
+        public string Name { get; set; }
+
+        [Display(Name = "Store")]
+        public string SelectedStore { get; set; }
+
+        public void SetStores(StoreData[] stores)
+        {
+            var defaultStore = stores[0].Id;
+            var choices = stores.Select(o => new Format() { Name = o.StoreName, Value = o.Id }).ToArray();
+            var chosen = choices.FirstOrDefault(f => f.Value == defaultStore) ?? choices.FirstOrDefault();
+            Stores = new SelectList(choices, nameof(chosen.Value), nameof(chosen.Name), chosen);
+            SelectedStore = chosen.Value;
+        }
+
+        public SelectList Stores { get; set; }
+
+        [Display(Name = "App type")]
+        public string SelectedAppType { get; set; }
+
+        public SelectList AppTypes { get; set; }
+
+        void SetApps()
+        {
+            var defaultAppType = AppType.PointOfSale.ToString();
+            var choices = typeof(AppType).GetEnumNames().Select(o => new Format() { Name = o, Value = o }).ToArray();
+            var chosen = choices.FirstOrDefault(f => f.Value == defaultAppType) ?? choices.FirstOrDefault();
+            AppTypes = new SelectList(choices, nameof(chosen.Value), nameof(chosen.Name), chosen);
+            SelectedAppType = chosen.Value;
+        }
+
+    }
+}

BTCPayServer/Models/AppViewModels/ListAppsViewModel.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Models.AppViewModels
+{
+    public class ListAppsViewModel
+    {
+        public class ListAppViewModel
+        {
+            public string Id { get; set; }
+            public string StoreName { get; set; }
+            public string StoreId { get; set; }
+            public string AppName { get; set; }
+            public string AppType { get; set; }
+            public bool IsOwner { get; set; }
+            public string UpdateAction { get { return "Update" + AppType; } }
+            public string ViewAction { get { return "View" + AppType; } }
+        }
+
+        public ListAppViewModel[] Apps { get; set; }
+    }
+}

BTCPayServer/Models/AppViewModels/UpdatePointOfSaleViewModel.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Models.AppViewModels
+{
+    public class UpdatePointOfSaleViewModel
+    {
+        [Required]
+        [MaxLength(30)]
+        public string Title { get; set; }
+        [Required]
+        [MaxLength(5)]
+        public string Currency { get; set; }
+        [Required]
+        [MaxLength(5000)]
+        public string Template { get; set; }
+    }
+}

BTCPayServer/Models/AppViewModels/ViewPointOfSaleViewModel.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Models.AppViewModels
+{
+    public class ViewPointOfSaleViewModel
+    {
+        public class Item
+        {
+            public class ItemPrice
+            {
+                public string Formatted { get; set; }
+                public decimal Value { get; set; }
+            }
+            public string Id { get; set; }
+            public ItemPrice Price { get; set; }
+            public string Title { get; set; }
+        }
+        public string Title { get; set; }
+        public Item[] Items { get; set; }
+    }
+}

BTCPayServer/Models/InvoiceResponse.cs

@@ -42,7 +42,6 @@ namespace BTCPayServer.Models
     {
         //"url":"https://test.bitpay.com/invoice?id=9saCHtp1zyPcNoi3rDdBu8"
         [JsonProperty("url")]
-        [Obsolete("Use CryptoInfo.Url instead")]
         public string Url
         {
             get; set;

BTCPayServer/Models/InvoicingModels/InvoiceDetailsModel.cs

@@ -12,17 +12,23 @@ namespace BTCPayServer.Models.InvoicingModels
     {
         public class CryptoPayment
         {
-            public string CryptoCode { get; set; }
+            public string PaymentMethod { get; set; }
             public string Due { get; set; }
             public string Paid { get; set; }
             public string Address { get; internal set; }
             public string Rate { get; internal set; }
             public string PaymentUrl { get; internal set; }
         }
+        public class AddressModel
+        {
+            public string PaymentMethod { get; set; }
+            public string Destination { get; set; }
+            public bool Current { get; set; }
+        }
         public class Payment
         {
-            public string CryptoCode { get; set; }
-            public int Confirmations
+            public string PaymentMethod { get; set; }
+            public string Confirmations
             {
                 get; set;
             }
@@ -126,7 +132,7 @@ namespace BTCPayServer.Models.InvoicingModels
             get;
             internal set;
         }
-        public HistoricalAddressInvoiceData[] Addresses { get; set; }
+        public AddressModel[] Addresses { get; set; }
         public DateTimeOffset MonitoringDate { get; internal set; }
         public List<Data.InvoiceEventData> Events { get; internal set; }
     }

BTCPayServer/Models/InvoicingModels/InvoicesModel.cs

@@ -33,11 +33,13 @@ namespace BTCPayServer.Models.InvoicingModels
 
     public class InvoiceModel
     {
-        public DateTimeOffset Date
+        public string Date
         {
             get; set;
         }
 
+        public string OrderId { get; set; }
+        public string RedirectUrl { get; set; }
         public string InvoiceId
         {
             get; set;

BTCPayServer/Models/InvoicingModels/PaymentModel.cs

@@ -9,11 +9,15 @@ namespace BTCPayServer.Models.InvoicingModels
     {
         public class AvailableCrypto
         {
-            public string CryptoCode { get; set; }
+            public string PaymentMethodId { get; set; }
             public string CryptoImage { get; set; }
             public string Link { get; set; }
         }
+        public string CustomCSSLink { get; set; }
+        public string CustomLogoLink { get; set; }
+        public string DefaultLang { get; set; }
         public List<AvailableCrypto> AvailableCryptos { get; set; } = new List<AvailableCrypto>();
+        public bool IsLightning { get; set; }
         public string CryptoCode { get; set; }
         public string ServerUrl { get; set; }
         public string InvoiceId { get; set; }
@@ -32,6 +36,7 @@ namespace BTCPayServer.Models.InvoicingModels
         public string Rate { get; set; }
         public string OrderAmount { get; set; }
         public string InvoiceBitcoinUrl { get; set; }
+        public string InvoiceBitcoinUrlQR { get; set; }
         public int TxCount { get; set; }
         public string BtcPaid { get; set; }
         public string StoreEmail { get; set; }
@@ -39,5 +44,11 @@ namespace BTCPayServer.Models.InvoicingModels
         public string OrderId { get; set; }
         public string CryptoImage { get; set; }
         public string NetworkFeeDescription { get; internal set; }
+        public int MaxTimeMinutes { get; internal set; }
+        public string PaymentType { get; internal set; }
+        public string PaymentMethodId { get; internal set; }
+
+        public bool AllowCoinConversion { get; set; }
+        public string PeerInfo { get; set; }
     }
 }

BTCPayServer/Models/ServerViewModels/UserViewModel.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Models.ServerViewModels
+{
+    public class UserViewModel
+    {
+        public string Id { get; set; }
+        public string Email { get; set; }
+        [Display(Name = "Is admin")]
+        public bool IsAdmin { get; set; }
+        public string StatusMessage { get; set; }
+    }
+}

BTCPayServer/Models/StoreViewModels/CheckoutExperienceViewModel.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services;
+using Microsoft.AspNetCore.Mvc.Rendering;
+
+namespace BTCPayServer.Models.StoreViewModels
+{
+    public class CheckoutExperienceViewModel
+    {
+        class Format
+        {
+            public string Name { get; set; }
+            public string Value { get; set; }
+        }
+        public SelectList CryptoCurrencies { get; set; }
+        public SelectList Languages { get; set; }
+
+        [Display(Name = "Default crypto currency on checkout")]
+        public string DefaultCryptoCurrency { get; set; }
+        [Display(Name = "Default language on checkout")]
+        public string DefaultLang { get; set; }
+        [Display(Name = "Allow conversion through third party (Shapeshift, Changelly...)")]
+        public bool AllowCoinConversion
+        {
+            get; set;
+        }
+        [Display(Name = "Do not propose lightning payment if value of the invoice is above...")]
+        [MaxLength(20)]
+        public string LightningMaxValue { get; set; }
+
+        [Display(Name = "Do not propose on chain payment if the value of the invoice is below...")]
+        [MaxLength(20)]
+        public string OnChainMinValue { get; set; }
+
+        [Display(Name = "Link to a custom CSS stylesheet")]
+        [Url]
+        public string CustomCSS { get; set; }
+        [Display(Name = "Link to a custom logo")]
+        [Url]
+        public string CustomLogo { get; set; }
+
+        public void SetCryptoCurrencies(ExplorerClientProvider explorerProvider, string defaultCrypto)
+        {
+            var choices = explorerProvider.GetAll().Select(o => new Format() { Name = o.Item1.CryptoCode, Value = o.Item1.CryptoCode }).ToArray();
+            var chosen = choices.FirstOrDefault(f => f.Value == defaultCrypto) ?? choices.FirstOrDefault();
+            CryptoCurrencies = new SelectList(choices, nameof(chosen.Value), nameof(chosen.Name), chosen);
+            DefaultCryptoCurrency = chosen.Name;
+        }
+
+        public void SetLanguages(LanguageService langService, string defaultLang)
+        {
+            defaultLang = defaultLang ?? "en-US";
+            var choices = langService.GetLanguages().Select(o => new Format() { Name = o.DisplayName, Value = o.Code }).ToArray();
+            var chosen = choices.FirstOrDefault(f => f.Value == defaultLang) ?? choices.FirstOrDefault();
+            Languages = new SelectList(choices, nameof(chosen.Value), nameof(chosen.Name), chosen);
+            DefaultLang = chosen.Value;
+        }
+    }
+}

BTCPayServer/Models/StoreViewModels/DerivationSchemeViewModel.cs

@@ -9,20 +9,8 @@ namespace BTCPayServer.Models.StoreViewModels
 {
     public class DerivationSchemeViewModel
     {
-        class Format
-        {
-            public string Name { get; set; }
-            public string Value { get; set; }
-        }
         public DerivationSchemeViewModel()
         {
-            var btcPay = new Format { Name = "BTCPay", Value = "BTCPay" };
-            DerivationSchemeFormat = btcPay.Value;
-            DerivationSchemeFormats = new SelectList(new Format[]
-            {
-                btcPay,
-                new Format { Name = "Electrum", Value = "Electrum" },
-            }, nameof(btcPay.Value), nameof(btcPay.Name), btcPay);
         }
         public string DerivationScheme
         {
@@ -34,30 +22,12 @@ namespace BTCPayServer.Models.StoreViewModels
             get; set;
         } = new List<(string KeyPath, string Address)>();
 
-        [Display(Name = "Derivation Scheme format")]
-        public string DerivationSchemeFormat
-        {
-            get;
-            set;
-        }
+        public string CryptoCode { get; set; }
+        [Display(Name = "Hint address")]
+        public string HintAddress { get; set; }
+        public bool Confirmation { get; set; }
 
-        [Display(Name = "Crypto currency")]
-        public string CryptoCurrency
-        {
-            get;
-            set;
-        }
-
-        public SelectList CryptoCurrencies { get; set; }
-        public SelectList DerivationSchemeFormats { get; set; }
-
-        
-        public void SetCryptoCurrencies(ExplorerClientProvider explorerProvider, string selectedScheme)
-        {
-            var choices = explorerProvider.GetAll().Select(o => new Format() { Name = o.Item1.CryptoCode, Value = o.Item1.CryptoCode }).ToArray();
-            var chosen = choices.FirstOrDefault(f => f.Name == selectedScheme) ?? choices.FirstOrDefault();
-            CryptoCurrencies = new SelectList(choices, nameof(chosen.Value), nameof(chosen.Name), chosen);
-            CryptoCurrency = chosen.Name;
-        }
+        public string ServerUrl { get; set; }
+        public string StatusMessage { get; internal set; }
     }
 }

BTCPayServer/Models/StoreViewModels/LightningNodeViewModel.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc.Rendering;
+
+namespace BTCPayServer.Models.StoreViewModels
+{
+    public class LightningNodeViewModel
+    {
+        [Display(Name = "Lightning charge url")]
+        public string Url
+        {
+            get;
+            set;
+        }
+
+        public string CryptoCode
+        {
+            get;
+            set;
+        }
+        public string StatusMessage { get; set; }
+        public string InternalLightningNode { get; internal set; }
+    }
+}

BTCPayServer/Models/StoreViewModels/StoreUsersViewModel.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Models.StoreViewModels
+{
+    public class StoreUsersViewModel
+    {
+        public class StoreUserViewModel
+        {
+            public string Email { get; set; }
+            public string Role { get; set; }
+            public string Id { get; set; }
+        }
+        public StoreUsersViewModel()
+        {
+            Role = StoreRoles.Guest;
+        }
+        [Required]
+        [EmailAddress]
+        public string Email { get; set; }
+        public string StoreId { get; set; }
+        public string Role { get; set; }
+        public List<StoreUserViewModel> Users { get; set; }
+    }
+}

BTCPayServer/Models/StoreViewModels/StoreViewModel.cs

@@ -1,4 +1,5 @@
-using BTCPayServer.Services.Invoices;
+using BTCPayServer.Services;
+using BTCPayServer.Services.Invoices;
 using BTCPayServer.Validations;
 using Microsoft.AspNetCore.Mvc.Rendering;
 using System;
@@ -16,11 +17,7 @@ namespace BTCPayServer.Models.StoreViewModels
             public string Crypto { get; set; }
             public string Value { get; set; }
         }
-        class Format
-        {
-            public string Name { get; set; }
-            public string Value { get; set; }
-        }
+
         public StoreViewModel()
         {
 
@@ -47,14 +44,14 @@ namespace BTCPayServer.Models.StoreViewModels
 
         public List<StoreViewModel.DerivationScheme> DerivationSchemes { get; set; } = new List<StoreViewModel.DerivationScheme>();
 
-        [Display(Name = "Preferred exchange rate...")]
+        [Display(Name = "Preferred price source (eg. bitfinex, bitstamp...)")]
         public string PreferredExchange { get; set; }
 
         public string RateSource
         {
             get
             {
-                return string.IsNullOrEmpty(PreferredExchange) ? "https://apiv2.bitcoinaverage.com/indices/global/ticker/short" : $"https://apiv2.bitcoinaverage.com/exchanges/{PreferredExchange}";
+                return PreferredExchange.IsCoinAverage() ? "https://apiv2.bitcoinaverage.com/indices/global/ticker/short" : $"https://apiv2.bitcoinaverage.com/exchanges/{PreferredExchange}";
             }
         }
 
@@ -67,7 +64,7 @@ namespace BTCPayServer.Models.StoreViewModels
         }
 
         [Display(Name = "Invoice expires if the full amount has not been paid after ... minutes")]
-        [Range(1, 60 * 24 * 31)]
+        [Range(1, 60 * 24 * 24)]
         public int InvoiceExpiration
         {
             get;
@@ -75,7 +72,7 @@ namespace BTCPayServer.Models.StoreViewModels
         }
 
         [Display(Name = "Payment invalid if transactions fails to confirm ... minutes after invoice expiration")]
-        [Range(10, 60 * 24 * 31)]
+        [Range(10, 60 * 24 * 24)]
         public int MonitoringExpiration
         {
             get;
@@ -94,21 +91,15 @@ namespace BTCPayServer.Models.StoreViewModels
             get; set;
         }
 
-        public string StatusMessage
+        public class LightningNode
+        {
+            public string CryptoCode { get; set; }
+            public string Address { get; set; }
+        }
+        public List<LightningNode> LightningNodes
         {
             get; set;
-        }
-        public SelectList CryptoCurrencies { get; set; }
+        } = new List<LightningNode>();
 
-        [Display(Name = "Default crypto currency on checkout")]
-        public string DefaultCryptoCurrency { get; set; }
-
-        public void SetCryptoCurrencies(ExplorerClientProvider explorerProvider, string defaultCrypto)
-        {
-            var choices = explorerProvider.GetAll().Select(o => new Format() { Name = o.Item1.CryptoCode, Value = o.Item1.CryptoCode }).ToArray();
-            var chosen = choices.FirstOrDefault(f => f.Name == defaultCrypto) ?? choices.FirstOrDefault();
-            CryptoCurrencies = new SelectList(choices, nameof(chosen.Value), nameof(chosen.Name), chosen);
-            DefaultCryptoCurrency = chosen.Name;
-        }
     }
 }

BTCPayServer/Models/StoreViewModels/StoresViewModel.cs

@@ -8,14 +8,11 @@ namespace BTCPayServer.Models.StoreViewModels
 {
     public class StoresViewModel
     {
-        public string StatusMessage
-        {
-            get; set;
-        }
         public List<StoreViewModel> Stores
         {
             get; set;
         } = new List<StoreViewModel>();
+
         public class StoreViewModel
         {
             public string Name
@@ -32,6 +29,11 @@ namespace BTCPayServer.Models.StoreViewModels
             {
                 get; set;
             }
+            public bool IsOwner
+            {
+                get;
+                set;
+            }
             public string[] Balances
             {
                 get; set;

BTCPayServer/Models/StoreViewModels/WalletModel.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc.Rendering;
+
+namespace BTCPayServer.Models.StoreViewModels
+{
+    public class WalletModel
+    {
+        public string ServerUrl { get; set; }
+        public string CryptoCurrency
+        {
+            get;
+            set;
+        }
+    }
+}

BTCPayServer/Payments/Bitcoin/BitcoinLikeOnChainPaymentMethod.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Invoices;
+using NBitcoin;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Payments.Bitcoin
+{
+    public class BitcoinLikeOnChainPaymentMethod : IPaymentMethodDetails
+    {
+        public PaymentTypes GetPaymentType()
+        {
+            return PaymentTypes.BTCLike;
+        }
+
+        public string GetPaymentDestination()
+        {
+            return DepositAddress;
+        }
+
+        public decimal GetTxFee()
+        {
+            return TxFee.ToDecimal(MoneyUnit.BTC);
+        }
+
+        public void SetNoTxFee()
+        {
+            TxFee = Money.Zero;
+        }
+
+
+        public void SetPaymentDestination(string newPaymentDestination)
+        {
+            DepositAddress = newPaymentDestination;
+        }
+
+        // Those properties are JsonIgnore because their data is inside CryptoData class for legacy reason
+        [JsonIgnore]
+        public FeeRate FeeRate { get; set; }
+        [JsonIgnore]
+        public Money TxFee { get; set; }
+        [JsonIgnore]
+        public String DepositAddress { get; set; }
+        public BitcoinAddress GetDepositAddress(Network network)
+        {
+            return string.IsNullOrEmpty(DepositAddress) ? null : BitcoinAddress.Create(DepositAddress, network);
+        }
+        ///////////////////////////////////////////////////////////////////////////////////////
+    }
+}

BTCPayServer/Payments/Bitcoin/BitcoinLikePaymentData.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Invoices;
+using NBitcoin;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Payments.Bitcoin
+{
+
+    public class BitcoinLikePaymentData : CryptoPaymentData
+    {
+        public PaymentTypes GetPaymentType()
+        {
+            return PaymentTypes.BTCLike;
+        }
+        public BitcoinLikePaymentData()
+        {
+
+        }
+        public BitcoinLikePaymentData(Coin coin, bool rbf)
+        {
+            Outpoint = coin.Outpoint;
+            Output = coin.TxOut;
+            ConfirmationCount = 0;
+            RBF = rbf;
+        }
+        [JsonIgnore]
+        public OutPoint Outpoint { get; set; }
+        [JsonIgnore]
+        public TxOut Output { get; set; }
+        public int ConfirmationCount { get; set; }
+        public bool RBF { get; set; }
+
+        /// <summary>
+        /// This is set to true if the payment was created before CryptoPaymentData existed in BTCPayServer
+        /// </summary>
+        public bool Legacy { get; set; }
+
+        public string GetPaymentId()
+        {
+            return Outpoint.ToString();
+        }
+
+        public string[] GetSearchTerms()
+        {
+            return new[] { Outpoint.Hash.ToString() };
+        }
+
+        public decimal GetValue()
+        {
+            return Output.Value.ToDecimal(MoneyUnit.BTC);
+        }
+
+        public bool PaymentCompleted(PaymentEntity entity, BTCPayNetwork network)
+        {
+            return ConfirmationCount >= network.MaxTrackedConfirmation;
+        }
+
+        public bool PaymentConfirmed(PaymentEntity entity, SpeedPolicy speedPolicy, BTCPayNetwork network)
+        {
+            if (speedPolicy == SpeedPolicy.HighSpeed)
+            {
+                return ConfirmationCount >= 1 || !RBF;
+            }
+            else if (speedPolicy == SpeedPolicy.MediumSpeed)
+            {
+                return ConfirmationCount >= 1;
+            }
+            else if (speedPolicy == SpeedPolicy.LowSpeed)
+            {
+                return ConfirmationCount >= 6;
+            }
+            return false;
+        }
+    }
+}

BTCPayServer/Payments/Bitcoin/BitcoinLikePaymentHandler.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Data;
+using BTCPayServer.Services;
+using BTCPayServer.Services.Invoices;
+using BTCPayServer.Services.Rates;
+using NBitcoin;
+
+namespace BTCPayServer.Payments.Bitcoin
+{
+    public class BitcoinLikePaymentHandler : PaymentMethodHandlerBase<DerivationStrategy>
+    {
+        ExplorerClientProvider _ExplorerProvider;
+        private IFeeProviderFactory _FeeRateProviderFactory;
+        private Services.Wallets.BTCPayWalletProvider _WalletProvider;
+
+        public BitcoinLikePaymentHandler(ExplorerClientProvider provider,
+                                         IFeeProviderFactory feeRateProviderFactory,
+                                         Services.Wallets.BTCPayWalletProvider walletProvider)
+        {
+            if (provider == null)
+                throw new ArgumentNullException(nameof(provider));
+            _ExplorerProvider = provider;
+            this._FeeRateProviderFactory = feeRateProviderFactory;
+            _WalletProvider = walletProvider;
+        }
+
+        public override async Task<IPaymentMethodDetails> CreatePaymentMethodDetails(DerivationStrategy supportedPaymentMethod, PaymentMethod paymentMethod, BTCPayNetwork network)
+        {
+            if (!_ExplorerProvider.IsAvailable(network))
+                throw new PaymentMethodUnavailableException($"Full node not available");
+            var getFeeRate = _FeeRateProviderFactory.CreateFeeProvider(network).GetFeeRateAsync();
+            var getAddress = _WalletProvider.GetWallet(network).ReserveAddressAsync(supportedPaymentMethod.DerivationStrategyBase);
+            Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod onchainMethod = new Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod();
+            onchainMethod.FeeRate = await getFeeRate;
+            onchainMethod.TxFee = onchainMethod.FeeRate.GetFee(100); // assume price for 100 bytes
+            onchainMethod.DepositAddress = (await getAddress).ToString();
+            return onchainMethod;
+        }
+    }
+}

BTCPayServer/Payments/Bitcoin/NBXplorerListener.cs

@@ -0,0 +1,377 @@
+using System;
+using Microsoft.Extensions.Logging;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Logging;
+using BTCPayServer.Services.Invoices;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Hosting;
+using NBXplorer;
+using System.Collections.Concurrent;
+using NBXplorer.DerivationStrategy;
+using BTCPayServer.Events;
+using BTCPayServer.Services;
+using BTCPayServer.Services.Wallets;
+using NBitcoin;
+using NBXplorer.Models;
+using BTCPayServer.Payments;
+using BTCPayServer.HostedServices;
+
+namespace BTCPayServer.Payments.Bitcoin
+{
+    /// <summary>
+    /// This class listener NBXplorer instances to detect incoming on-chain, bitcoin like payment
+    /// </summary>
+    public class NBXplorerListener : IHostedService
+    {
+        EventAggregator _Aggregator;
+        ExplorerClientProvider _ExplorerClients;
+        IApplicationLifetime _Lifetime;
+        InvoiceRepository _InvoiceRepository;
+        private TaskCompletionSource<bool> _RunningTask;
+        private CancellationTokenSource _Cts;
+        BTCPayWalletProvider _Wallets;
+        BTCPayNetworkProvider _NetworkProvider;
+
+        public NBXplorerListener(ExplorerClientProvider explorerClients,
+                                BTCPayWalletProvider wallets,
+                                InvoiceRepository invoiceRepository,
+                                BTCPayNetworkProvider networkProvider,
+                                EventAggregator aggregator, IApplicationLifetime lifetime)
+        {
+            PollInterval = TimeSpan.FromMinutes(1.0);
+            _Wallets = wallets;
+            _InvoiceRepository = invoiceRepository;
+            _ExplorerClients = explorerClients;
+            _Aggregator = aggregator;
+            _Lifetime = lifetime;
+            _NetworkProvider = networkProvider;
+        }
+
+        CompositeDisposable leases = new CompositeDisposable();
+        ConcurrentDictionary<string, NotificationSession> _SessionsByCryptoCode = new ConcurrentDictionary<string, NotificationSession>();
+        private Timer _ListenPoller;
+
+        TimeSpan _PollInterval;
+        public TimeSpan PollInterval
+        {
+            get
+            {
+                return _PollInterval;
+            }
+            set
+            {
+                _PollInterval = value;
+                if (_ListenPoller != null)
+                {
+                    _ListenPoller.Change(0, (int)value.TotalMilliseconds);
+                }
+            }
+        }
+
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            _RunningTask = new TaskCompletionSource<bool>();
+            _Cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+            leases.Add(_Aggregator.Subscribe<Events.NBXplorerStateChangedEvent>(async nbxplorerEvent =>
+            {
+                if (nbxplorerEvent.NewState == NBXplorerState.Ready)
+                {
+                    var wallet = _Wallets.GetWallet(nbxplorerEvent.Network);
+                    if (_Wallets.IsAvailable(wallet.Network))
+                    {
+                        await Listen(wallet);
+                    }
+                }
+            }));
+
+            _ListenPoller = new Timer(async s =>
+            {
+                foreach (var wallet in _Wallets.GetWallets())
+                {
+                    if (_Wallets.IsAvailable(wallet.Network))
+                    {
+                        await Listen(wallet);
+                    }
+                }
+            }, null, 0, (int)PollInterval.TotalMilliseconds);
+            leases.Add(_ListenPoller);
+            return Task.CompletedTask;
+        }
+
+        private async Task Listen(BTCPayWallet wallet)
+        {
+            var network = wallet.Network;
+            bool cleanup = false;
+            try
+            {
+                if (_SessionsByCryptoCode.ContainsKey(network.CryptoCode))
+                    return;
+                var client = _ExplorerClients.GetExplorerClient(network);
+                if (client == null)
+                    return;
+                if (_Cts.IsCancellationRequested)
+                    return;
+                var session = await client.CreateNotificationSessionAsync(_Cts.Token).ConfigureAwait(false);
+                if (!_SessionsByCryptoCode.TryAdd(network.CryptoCode, session))
+                {
+                    await session.DisposeAsync();
+                    return;
+                }
+                cleanup = true;
+
+                using (session)
+                {
+                    await session.ListenNewBlockAsync(_Cts.Token).ConfigureAwait(false);
+                    await session.ListenAllDerivationSchemesAsync(cancellation: _Cts.Token).ConfigureAwait(false);
+
+                    Logs.PayServer.LogInformation($"{network.CryptoCode}: Checking if any pending invoice got paid while offline...");
+                    int paymentCount = await FindPaymentViaPolling(wallet, network);
+                    Logs.PayServer.LogInformation($"{network.CryptoCode}: {paymentCount} payments happened while offline");
+
+                    Logs.PayServer.LogInformation($"Connected to WebSocket of NBXplorer ({network.CryptoCode})");
+                    while (!_Cts.IsCancellationRequested)
+                    {
+                        var newEvent = await session.NextEventAsync(_Cts.Token).ConfigureAwait(false);
+                        switch (newEvent)
+                        {
+                            case NBXplorer.Models.NewBlockEvent evt:
+
+                                await Task.WhenAll((await _InvoiceRepository.GetPendingInvoices())
+                                    .Select(invoiceId => UpdatePaymentStates(wallet, invoiceId))
+                                    .ToArray());
+                                _Aggregator.Publish(new Events.NewBlockEvent() { CryptoCode = evt.CryptoCode });
+                                break;
+                            case NBXplorer.Models.NewTransactionEvent evt:
+                                wallet.InvalidateCache(evt.DerivationStrategy);
+                                foreach (var output in evt.Outputs)
+                                {
+                                    foreach (var txCoin in evt.TransactionData.Transaction.Outputs.AsCoins()
+                                                                                .Where(o => o.ScriptPubKey == output.ScriptPubKey)
+                                                                                .Select(o => output.Redeem == null ? o : o.ToScriptCoin(output.Redeem)))
+                                    {
+                                        var invoice = await _InvoiceRepository.GetInvoiceFromScriptPubKey(output.ScriptPubKey, network.CryptoCode);
+                                        if (invoice != null)
+                                        {
+                                            var paymentData = new BitcoinLikePaymentData(txCoin, evt.TransactionData.Transaction.RBF);
+                                            var alreadyExist = GetAllBitcoinPaymentData(invoice).Where(c => c.GetPaymentId() == paymentData.GetPaymentId()).Any();
+                                            if (!alreadyExist)
+                                            {
+                                                var payment = await _InvoiceRepository.AddPayment(invoice.Id, DateTimeOffset.UtcNow, paymentData, network.CryptoCode);
+                                                if(payment != null)
+                                                    await ReceivedPayment(wallet, invoice.Id, payment, evt.DerivationStrategy);
+                                            }
+                                            else
+                                            {
+                                                await UpdatePaymentStates(wallet, invoice.Id);
+                                            }
+                                        }
+                                    }
+                                }
+                                break;
+                            default:
+                                Logs.PayServer.LogWarning("Received unknown message from NBXplorer");
+                                break;
+                        }
+                    }
+                }
+            }
+            catch when (_Cts.IsCancellationRequested) { }
+            catch (Exception ex)
+            {
+                Logs.PayServer.LogError(ex, $"Error while connecting to WebSocket of NBXplorer ({network.CryptoCode})");
+            }
+            finally
+            {
+                if (cleanup)
+                {
+                    Logs.PayServer.LogInformation($"Disconnected from WebSocket of NBXplorer ({network.CryptoCode})");
+                    _SessionsByCryptoCode.TryRemove(network.CryptoCode, out NotificationSession unused);
+                    if (_SessionsByCryptoCode.Count == 0 && _Cts.IsCancellationRequested)
+                    {
+                        _RunningTask.TrySetResult(true);
+                    }
+                }
+            }
+        }
+
+        IEnumerable<BitcoinLikePaymentData> GetAllBitcoinPaymentData(InvoiceEntity invoice)
+        {
+            return invoice.GetPayments()
+                    .Where(p => p.GetPaymentMethodId().PaymentType == PaymentTypes.BTCLike)
+                    .Select(p => (BitcoinLikePaymentData)p.GetCryptoPaymentData());
+        }
+
+        async Task<InvoiceEntity> UpdatePaymentStates(BTCPayWallet wallet, string invoiceId)
+        {
+            var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId, false);
+            List<PaymentEntity> updatedPaymentEntities = new List<PaymentEntity>();
+            var transactions = await wallet.GetTransactions(GetAllBitcoinPaymentData(invoice)
+                    .Select(p => p.Outpoint.Hash)
+                    .ToArray());
+            var conflicts = GetConflicts(transactions.Select(t => t.Value));
+            foreach (var payment in invoice.GetPayments(wallet.Network))
+            {
+                if (payment.GetPaymentMethodId().PaymentType != PaymentTypes.BTCLike)
+                    continue;
+                var paymentData = (BitcoinLikePaymentData)payment.GetCryptoPaymentData();
+                if (!transactions.TryGetValue(paymentData.Outpoint.Hash, out TransactionResult tx))
+                    continue;
+                var txId = tx.Transaction.GetHash();
+                var txConflict = conflicts.GetConflict(txId);
+                var accounted = txConflict == null || txConflict.IsWinner(txId);
+
+                bool updated = false;
+                if (accounted != payment.Accounted)
+                {
+                    updated = true;
+                    payment.Accounted = accounted;
+                }
+
+                if (paymentData.ConfirmationCount != tx.Confirmations)
+                {
+                    if (wallet.Network.MaxTrackedConfirmation >= paymentData.ConfirmationCount)
+                    {
+                        paymentData.ConfirmationCount = tx.Confirmations;
+                        payment.SetCryptoPaymentData(paymentData);
+                        updated = true;
+                    }
+                }
+
+                if (updated)
+                    updatedPaymentEntities.Add(payment);
+            }
+            await _InvoiceRepository.UpdatePayments(updatedPaymentEntities);
+            if (updatedPaymentEntities.Count != 0)
+                _Aggregator.Publish(new Events.InvoiceNeedUpdateEvent(invoice.Id));
+            return invoice;
+        }
+
+        class TransactionConflict
+        {
+            public Dictionary<uint256, TransactionResult> Transactions { get; set; } = new Dictionary<uint256, TransactionResult>();
+
+
+            uint256 _Winner;
+            public bool IsWinner(uint256 txId)
+            {
+                if (_Winner == null)
+                {
+                    var confirmed = Transactions.FirstOrDefault(t => t.Value.Confirmations >= 1);
+                    if (!confirmed.Equals(default(KeyValuePair<uint256, TransactionResult>)))
+                    {
+                        _Winner = confirmed.Key;
+                    }
+                    else
+                    {
+                        // Take the most recent (bitcoin node would not forward a conflict without a successful RBF)
+                        _Winner = Transactions
+                                .OrderByDescending(t => t.Value.Timestamp)
+                                .First()
+                                .Key;
+                    }
+                }
+                return _Winner == txId;
+            }
+        }
+        class TransactionConflicts : List<TransactionConflict>
+        {
+            public TransactionConflicts(IEnumerable<TransactionConflict> collection) : base(collection)
+            {
+
+            }
+
+            public TransactionConflict GetConflict(uint256 txId)
+            {
+                return this.FirstOrDefault(c => c.Transactions.ContainsKey(txId));
+            }
+        }
+        private TransactionConflicts GetConflicts(IEnumerable<TransactionResult> transactions)
+        {
+            Dictionary<OutPoint, TransactionConflict> conflictsByOutpoint = new Dictionary<OutPoint, TransactionConflict>();
+            foreach (var tx in transactions)
+            {
+                var hash = tx.Transaction.GetHash();
+                foreach (var input in tx.Transaction.Inputs)
+                {
+                    TransactionConflict conflict = new TransactionConflict();
+                    if (!conflictsByOutpoint.TryAdd(input.PrevOut, conflict))
+                    {
+                        conflict = conflictsByOutpoint[input.PrevOut];
+                    }
+                    if (!conflict.Transactions.ContainsKey(hash))
+                        conflict.Transactions.Add(hash, tx);
+                }
+            }
+            return new TransactionConflicts(conflictsByOutpoint.Where(c => c.Value.Transactions.Count > 1).Select(c => c.Value));
+        }
+
+        private async Task<int> FindPaymentViaPolling(BTCPayWallet wallet, BTCPayNetwork network)
+        {
+            int totalPayment = 0;
+            var invoices = await _InvoiceRepository.GetPendingInvoices();
+            foreach (var invoiceId in invoices)
+            {
+                var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId, true);
+                var alreadyAccounted = GetAllBitcoinPaymentData(invoice).Select(p => p.Outpoint).ToHashSet();
+                var strategy = GetDerivationStrategy(invoice, network);
+                if (strategy == null)
+                    continue;
+                var cryptoId = new PaymentMethodId(network.CryptoCode, PaymentTypes.BTCLike);
+                if (!invoice.Support(cryptoId))
+                    continue;
+                var coins = (await wallet.GetUnspentCoins(strategy))
+                             .Where(c => invoice.AvailableAddressHashes.Contains(c.Coin.ScriptPubKey.Hash.ToString() + cryptoId))
+                             .ToArray();
+                foreach (var coin in coins.Where(c => !alreadyAccounted.Contains(c.Coin.Outpoint)))
+                {
+                    var transaction = await wallet.GetTransactionAsync(coin.Coin.Outpoint.Hash);
+                    var paymentData = new BitcoinLikePaymentData(coin.Coin, transaction.Transaction.RBF);
+                    var payment = await _InvoiceRepository.AddPayment(invoice.Id, coin.Timestamp, paymentData, network.CryptoCode).ConfigureAwait(false);
+                    alreadyAccounted.Add(coin.Coin.Outpoint);
+                    if (payment != null)
+                        invoice = await ReceivedPayment(wallet, invoice.Id, payment, strategy);
+                    totalPayment++;
+                }
+            }
+            return totalPayment;
+        }
+
+        private DerivationStrategyBase GetDerivationStrategy(InvoiceEntity invoice, BTCPayNetwork network)
+        {
+            return invoice.GetSupportedPaymentMethod<DerivationStrategy>(new PaymentMethodId(network.CryptoCode, PaymentTypes.BTCLike), _ExplorerClients.NetworkProviders)
+                          .Select(d => d.DerivationStrategyBase)
+                          .FirstOrDefault();
+        }
+
+        private async Task<InvoiceEntity> ReceivedPayment(BTCPayWallet wallet, string invoiceId, PaymentEntity payment, DerivationStrategyBase strategy)
+        {
+            var paymentData = (BitcoinLikePaymentData)payment.GetCryptoPaymentData();
+            var invoice = (await UpdatePaymentStates(wallet, invoiceId));
+            var paymentMethod = invoice.GetPaymentMethod(wallet.Network, PaymentTypes.BTCLike, _ExplorerClients.NetworkProviders);
+            if (paymentMethod != null &&
+                paymentMethod.GetPaymentMethodDetails() is BitcoinLikeOnChainPaymentMethod btc &&
+                btc.GetDepositAddress(wallet.Network.NBitcoinNetwork).ScriptPubKey == paymentData.Output.ScriptPubKey &&
+                paymentMethod.Calculate().Due > Money.Zero)
+            {
+                var address = await wallet.ReserveAddressAsync(strategy);
+                btc.DepositAddress = address.ToString();
+                await _InvoiceRepository.NewAddress(invoiceId, btc, wallet.Network);
+                _Aggregator.Publish(new InvoiceNewAddressEvent(invoiceId, address.ToString(), wallet.Network));
+                paymentMethod.SetPaymentMethodDetails(btc);
+                invoice.SetPaymentMethod(paymentMethod);
+            }
+            wallet.InvalidateCache(strategy);
+            _Aggregator.Publish(new InvoiceEvent(invoiceId, 1002, "invoice_receivedPayment"));
+            return invoice;
+        }
+        public Task StopAsync(CancellationToken cancellationToken)
+        {
+            leases.Dispose();
+            _Cts.Cancel();
+            return Task.WhenAny(_RunningTask.Task, Task.Delay(-1, cancellationToken));
+        }
+    }
+}