plug japanese translation

Fix Japanese

.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,7 @@ __pycache__/
 *.odx.cs
 *.xsd.cs
 /BTCPayServer/Build/dockerfiles
+
+# Bundling JS/CSS
+BTCPayServer/wwwroot/bundles/*
+!BTCPayServer/wwwroot/bundles/.gitignore

BTCPayServer.Tests/BTCPayServer.Tests.csproj

@@ -8,7 +8,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.6.1" />
     <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,8 +95,8 @@ 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 =>
@@ -116,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
@@ -124,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/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,8 +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
 {
@@ -55,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(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,33 +49,19 @@ 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 async Task<StoresController> CreateStoreAsync()
         {
-            cryptoCode = cryptoCode ?? CryptoCode;
-            SupportedNetwork = parent.NetworkProvider.GetNetwork(cryptoCode);
-            ExtKey = new ExtKey().GetWif(SupportedNetwork.NBitcoinNetwork);
-            var store = parent.PayTester.GetController<StoresController>(UserId);
+            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(),
-                Confirmation = true
-            }, "Save");
-            return store;
+            var store2 = parent.PayTester.GetController<StoresController>(UserId);
+            store2.CreatedStoreId = store.CreatedStoreId;
+            return store2;
         }
 
         public BTCPayNetwork SupportedNetwork { get; set; }
@@ -81,18 +70,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(),
+                DerivationScheme = DerivationScheme.ToString(),
                 Confirmation = true
-            }, "Save");
+            }, cryptoCode);
         }
 
         public DerivationStrategyBase DerivationScheme { get; set; }
@@ -122,5 +114,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,11 +22,14 @@ 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;
 
 namespace BTCPayServer.Tests
 {
@@ -38,6 +41,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()
         {
@@ -50,79 +110,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);
@@ -131,44 +193,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
         }
 
@@ -180,6 +241,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" },
@@ -225,18 +287,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()
@@ -273,6 +488,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,
@@ -325,14 +541,14 @@ 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,
@@ -348,6 +564,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);
                 });
 
@@ -356,11 +574,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);
@@ -368,6 +584,7 @@ namespace BTCPayServer.Tests
                 {
                     invoice = user.BitPay.GetInvoice(invoice.Id);
                     Assert.Equal(payment2, invoice.BtcPaid);
+                    Assert.Equal("False", invoice.ExceptionStatus.ToString());
                 });
             }
         }
@@ -392,6 +609,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));
             }
         }
@@ -405,7 +623,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()
@@ -447,8 +665,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()
@@ -507,7 +725,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()
                 {
@@ -588,6 +806,44 @@ namespace BTCPayServer.Tests
             }
         }
 
+        [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());
+            ////////////////
+        
+            result = parser.Parse("tpubD6NzVbkrYhZ4Wc65tjhmcKdWFauAo7bGLRTxvggygkNyp6SMGutJp7iociwsinU33jyNBp1J9j2hJH5yQsayfiS3LEU2ZqXodAcnaygra8o");
+            Assert.Equal("tpubD6NzVbkrYhZ4Wc65tjhmcKdWFauAo7bGLRTxvggygkNyp6SMGutJp7iociwsinU33jyNBp1J9j2hJH5yQsayfiS3LEU2ZqXodAcnaygra8o", result.ToString());
+            parser.HintScriptPubKey = BitcoinAddress.Create("tb1q4s33amqm8l7a07zdxcunqnn3gcsjcfz3xc573l", parser.Network).ScriptPubKey;
+            result = parser.Parse("tpubD6NzVbkrYhZ4Wc65tjhmcKdWFauAo7bGLRTxvggygkNyp6SMGutJp7iociwsinU33jyNBp1J9j2hJH5yQsayfiS3LEU2ZqXodAcnaygra8o");
+            Assert.Equal("tpubD6NzVbkrYhZ4Wc65tjhmcKdWFauAo7bGLRTxvggygkNyp6SMGutJp7iociwsinU33jyNBp1J9j2hJH5yQsayfiS3LEU2ZqXodAcnaygra8o", result.ToString());
+
+            parser.HintScriptPubKey = BitcoinAddress.Create("2N2humNio3YTApSfY6VztQ9hQwDnhDvaqFQ", parser.Network).ScriptPubKey;
+            result = parser.Parse("tpubD6NzVbkrYhZ4Wc65tjhmcKdWFauAo7bGLRTxvggygkNyp6SMGutJp7iociwsinU33jyNBp1J9j2hJH5yQsayfiS3LEU2ZqXodAcnaygra8o");
+            Assert.Equal("tpubD6NzVbkrYhZ4Wc65tjhmcKdWFauAo7bGLRTxvggygkNyp6SMGutJp7iociwsinU33jyNBp1J9j2hJH5yQsayfiS3LEU2ZqXodAcnaygra8o-[p2sh]", result.ToString());
+
+            parser.HintScriptPubKey = BitcoinAddress.Create("mwD8bHS65cdgUf6rZUUSoVhi3wNQFu1Nfi", parser.Network).ScriptPubKey;
+            result = parser.Parse("tpubD6NzVbkrYhZ4Wc65tjhmcKdWFauAo7bGLRTxvggygkNyp6SMGutJp7iociwsinU33jyNBp1J9j2hJH5yQsayfiS3LEU2ZqXodAcnaygra8o");
+            Assert.Equal("tpubD6NzVbkrYhZ4Wc65tjhmcKdWFauAo7bGLRTxvggygkNyp6SMGutJp7iociwsinU33jyNBp1J9j2hJH5yQsayfiS3LEU2ZqXodAcnaygra8o-[legacy]", result.ToString());
+
+            parser.HintScriptPubKey = BitcoinAddress.Create("2N2humNio3YTApSfY6VztQ9hQwDnhDvaqFQ", parser.Network).ScriptPubKey;
+            result = parser.Parse("tpubD6NzVbkrYhZ4Wc65tjhmcKdWFauAo7bGLRTxvggygkNyp6SMGutJp7iociwsinU33jyNBp1J9j2hJH5yQsayfiS3LEU2ZqXodAcnaygra8o-[legacy]");
+            Assert.Equal("tpubD6NzVbkrYhZ4Wc65tjhmcKdWFauAo7bGLRTxvggygkNyp6SMGutJp7iociwsinU33jyNBp1J9j2hJH5yQsayfiS3LEU2ZqXodAcnaygra8o-[p2sh]", result.ToString());
+
+            result = parser.Parse("tpubD6NzVbkrYhZ4Wc65tjhmcKdWFauAo7bGLRTxvggygkNyp6SMGutJp7iociwsinU33jyNBp1J9j2hJH5yQsayfiS3LEU2ZqXodAcnaygra8o");
+            Assert.Equal("tpubD6NzVbkrYhZ4Wc65tjhmcKdWFauAo7bGLRTxvggygkNyp6SMGutJp7iociwsinU33jyNBp1J9j2hJH5yQsayfiS3LEU2ZqXodAcnaygra8o-[p2sh]", result.ToString());
+        }
+
         [Fact]
         public void InvoiceFlowThroughDifferentStatesCorrectly()
         {
@@ -596,6 +852,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,
@@ -607,7 +864,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()
@@ -663,6 +920,7 @@ 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));
@@ -682,6 +940,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
@@ -762,8 +1021,8 @@ 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)
@@ -782,5 +1041,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/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.13
+    image: nicolasdorier/nbxplorer:1.0.1.24
     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,73 @@ services:
     expose:
       - "43782" # RPC
       - "39388" # P2P
+    volumes:
+      - "bitcoin_datadir:/data"
+
+  customer_lightningd:
+    image: nicolasdorier/clightning
+    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.5
+    environment:
+      NETWORK: regtest
+      API_TOKEN: foiewnccewuify
+      SKIP_BITCOIND: 1
+      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
+    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 +173,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

@@ -62,6 +62,7 @@ namespace BTCPayServer
         }
 
         public string CryptoImagePath { get; set; }
+        public string LightningImagePath { get; set; }
         public NBXplorer.NBXplorerNetwork NBXplorerNetwork { get; set; }
 
         public BTCPayDefaultSettings DefaultSettings { get; set; }

BTCPayServer/BTCPayNetworkProvider.Bitcoin.cs

@@ -20,12 +20,13 @@ 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",
+                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

@@ -25,6 +25,7 @@ namespace BTCPayServer
                 UriScheme = "litecoin",
                 DefaultRateProvider = ltcRate,
                 CryptoImagePath = "imlegacy/litecoin-symbol.svg",
+                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,14 +2,22 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp2.0</TargetFramework>
-		<Version>1.0.1.35</Version>
+		<Version>1.0.1.63</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" />
@@ -18,17 +26,19 @@
     <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="Microsoft.NetCore.Analyzers" Version="2.6.0" />
-    <PackageReference Include="NBitcoin" Version="4.0.0.55" />
-    <PackageReference Include="NBitpayClient" Version="1.0.0.16" />	  
+    <PackageReference Include="NBitcoin" Version="4.0.0.65" />
+    <PackageReference Include="NBitpayClient" Version="1.0.0.18" />	  
     <PackageReference Include="DBreeze" Version="1.87.0" />
-    <PackageReference Include="NBXplorer.Client" Version="1.0.1.9" />
+    <PackageReference Include="NBXplorer.Client" Version="1.0.1.16" />
     <PackageReference Include="NicolasDorier.CommandLine" Version="1.0.0.1" />
     <PackageReference Include="NicolasDorier.CommandLine.Configuration" Version="1.0.0.2" />
     <PackageReference Include="NicolasDorier.StandardConfiguration" Version="1.0.0.13" />
@@ -50,7 +60,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" />
@@ -102,6 +112,7 @@
 
 	<ItemGroup>
 	  <Folder Include="Build\" />
+	  <Folder Include="wwwroot\vendor\clipboard.js\" />
 	</ItemGroup>
 
 	<ItemGroup>

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,47 @@ 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);
+            BundleJsCss = conf.GetOrDefault<bool>("bundlejscss", true);
             ExternalUrl = conf.GetOrDefault<Uri>("externalurl", null);
+            var old = conf.GetOrDefault<Uri>("internallightningnode", null);
+            if(old != null)
+                throw new ConfigException($"internallightningnode should not be used anymore, use btclightning instead");
         }
 
+        public Dictionary<string, LightningConnectionString> InternalLightningByCryptoCode { get; set; } = new Dictionary<string, LightningConnectionString>();
+
+        public BTCPayNetworkProvider NetworkProvider { get; set; }
         public string PostgresConnectionString
         {
             get;
@@ -90,5 +110,10 @@ namespace BTCPayServer.Configuration
             get;
             set;
         }
+        public bool BundleJsCss
+        {
+            get;
+            set;
+        }
     }
 }

BTCPayServer/Configuration/ConfigurationExtensions.cs

@@ -27,7 +27,14 @@ 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))

BTCPayServer/Configuration/DefaultConfiguration.cs

@@ -36,8 +36,10 @@ namespace BTCPayServer.Configuration
                 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);
+            app.Option("--bundlejscss", $"Bundle javascript and css files for better performance (default: true)", CommandOptionType.SingleValue);
             return app;
         }
 
@@ -103,6 +105,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/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,7 @@ using System.Net.WebSockets;
 using System.Threading;
 using BTCPayServer.Events;
 using NBXplorer;
+using BTCPayServer.Payments;
 
 namespace BTCPayServer.Controllers
 {
@@ -63,42 +64,51 @@ 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;
-                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.GetCryptoPaymentDataType() == BitcoinLikePaymentData.OnchainBitcoinType)
+                .Where(p => p.GetPaymentMethodId().PaymentType == PaymentTypes.BTCLike)
                 .Select(async payment =>
                 {
-                    var paymentData = (BitcoinLikePaymentData)payment.GetCryptoPaymentData();
+                    var paymentData = (Payments.Bitcoin.BitcoinLikePaymentData)payment.GetCryptoPaymentData();
                     var m = new InvoiceDetailsModel.Payment();
                     var paymentNetwork = _NetworkProvider.GetNetwork(payment.GetCryptoCode());
-                    m.CryptoCode = payment.GetCryptoCode();
+                    m.PaymentMethod = ToString(payment.GetPaymentMethodId());
                     m.DepositAddress = paymentData.Output.ScriptPubKey.GetDestinationAddress(paymentNetwork.NBitcoinNetwork);
 
                     int confirmationCount = 0;
-                    if(paymentData.Legacy) // The confirmation count in the paymentData is not up to date
+                    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 _ExplorerClients.GetExplorerClient(payment.GetCryptoCode())?.GetTransactionAsync(paymentData.Outpoint.Hash))?.Confirmations ?? 0;
+                        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)
+                    if (confirmationCount >= paymentNetwork.MaxTrackedConfirmation)
                     {
                         m.Confirmations = "At least " + (paymentNetwork.MaxTrackedConfirmation);
                     }
@@ -106,7 +116,7 @@ namespace BTCPayServer.Controllers
                     {
                         m.Confirmations = confirmationCount.ToString(CultureInfo.InvariantCulture);
                     }
-                    
+
                     m.TransactionId = paymentData.Outpoint.Hash.ToString();
                     m.ReceivedTime = payment.ReceivedTime;
                     m.TransactionLink = string.Format(CultureInfo.InvariantCulture, paymentNetwork.BlockExplorerLink, m.TransactionId);
@@ -115,68 +125,94 @@ namespace BTCPayServer.Controllers
                 })
                 .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(),
                 ServerUrl = HttpContext.Request.GetAbsoluteRoot(),
                 OrderId = invoice.OrderId,
                 InvoiceId = invoice.Id,
-                BtcAddress = cryptoData.DepositAddress,
+                DefaultLang = storeBlob.DefaultLang ?? "en-US",
+                BtcAddress = paymentMethodDetails.GetPaymentDestination(),
                 OrderAmount = (accounting.TotalDue - accounting.NetworkFee).ToString(),
                 BtcDue = accounting.Due.ToString(),
                 CustomerEmail = invoice.RefundMail,
@@ -184,27 +220,33 @@ namespace BTCPayServer.Controllers
                 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(),
+                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}";
 
@@ -213,10 +255,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)
         {
@@ -236,10 +283,10 @@ namespace BTCPayServer.Controllers
 
         [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);
@@ -324,8 +371,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}"
                 });
             }
@@ -335,6 +384,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")]
@@ -345,7 +418,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 });
         }
@@ -362,9 +435,18 @@ 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)
+            {
+                StatusMessage = "Error: You need to be owner of this store to create an invoice";
+            }
+            if (store.GetSupportedPaymentMethods(_NetworkProvider).Count() == 0)
             {
                 StatusMessage = "Error: You need to configure the derivation scheme in order to create an invoice";
+            }
+
+            if(StatusMessage != null)
+            {
                 return RedirectToAction(nameof(StoresController.UpdateStore), "Stores", new
                 {
                     storeId = store.Id

BTCPayServer/Controllers/InvoiceController.cs

@@ -39,55 +39,72 @@ 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).Where(c => _ExplorerClients.IsAvailable(c.Network.CryptoCode)).ToList();
-            if (derivationStrategies.Count == 0)
+            var supportedPaymentMethods = store.GetSupportedPaymentMethods(_NetworkProvider)
+                                               .Select(c =>
+                                                (Handler: (IPaymentMethodHandler)_ServiceProvider.GetService(typeof(IPaymentMethodHandler<>).MakeGenericType(c.GetType())),
+                                                SupportedPaymentMethod: c,
+                                                Network: _NetworkProvider.GetNetwork(c.PaymentId.CryptoCode),
+                                                IsAvailable: Task.FromResult(false)))
+                                                .Where(c => c.Network != null)
+                                                .Select(c => 
+                                                {
+                                                    c.IsAvailable = c.Handler.IsAvailable(c.SupportedPaymentMethod, c.Network);
+                                                    return c;
+                                                })
+                                                .ToList();
+            foreach(var supportedPaymentMethod in supportedPaymentMethods.ToList())
+            {
+                if(!await supportedPaymentMethod.IsAvailable)
+                {
+                    supportedPaymentMethods.Remove(supportedPaymentMethod);
+                }
+            }
+            if (supportedPaymentMethods.Count == 0)
                 throw new BitpayHttpException(400, "No derivation strategy are available now for this store");
             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,55 +132,41 @@ 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, false),
-                                                    FeeRateProvider: _FeeProviderFactory.CreateFeeProvider(derivationStrategy.Network)))
-                    .Where(_ => _.Wallet != null &&
-                                _.FeeRateProvider != null &&
-                                _.RateProvider != null)
-                    .Select(_ =>
-                    {
-                        return new
+            var methods = supportedPaymentMethods
+                        .Select(async o =>
                         {
-                            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)
-            {
-                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();
-
+                            var rate = await storeBlob.ApplyRateRules(o.Network, _RateProviders.GetRateProvider(o.Network, false)).GetRateAsync(invoice.Currency);
+                            PaymentMethod paymentMethod = new PaymentMethod();
+                            paymentMethod.ParentEntity = entity;
+                            paymentMethod.SetId(o.SupportedPaymentMethod.PaymentId);
+                            paymentMethod.Rate = rate;
+                            var paymentDetails = await o.Handler.CreatePaymentMethodDetails(o.SupportedPaymentMethod, paymentMethod, o.Network);
+                            if (storeBlob.NetworkFeeDisabled)
+                                paymentDetails.SetNoTxFee();
+                            paymentMethod.SetPaymentMethodDetails(paymentDetails);
 #pragma warning disable CS0618
-                if (q.network.IsBTC)
-                {
-                    legacyBTCisSet = true;
-                    entity.TxFee = cryptoData.TxFee;
-                    entity.Rate = cryptoData.Rate;
-                    entity.DepositAddress = cryptoData.DepositAddress;
-                }
+                            if (paymentMethod.GetId().IsBTCOnChain)
+                            {
+                                entity.TxFee = paymentMethod.TxFee;
+                                entity.Rate = paymentMethod.Rate;
+                                entity.DepositAddress = paymentMethod.DepositAddress;
+                            }
 #pragma warning restore CS0618
-                cryptoDatas.Add(cryptoData.CryptoCode, cryptoData);
-            }
-
-            if (!legacyBTCisSet)
+                            return paymentMethod;
+                        });
+            entity.SetSupportedPaymentMethods(supportedPaymentMethods.Select(s => s.SupportedPaymentMethod));
+            var paymentMethods = new PaymentMethodDictionary();
+            foreach (var method in methods)
             {
-                // Legacy Bitpay clients expect information for BTC information, even if the store do not support it
+                paymentMethods.Add(await method);
+            }
 #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 feeProvider = ((IFeeProviderFactory)_ServiceProvider.GetService(typeof(IFeeProviderFactory))).CreateFeeProvider(btc);
                 var rateProvider = storeBlob.ApplyRateRules(btc, _RateProviders.GetRateProvider(btc, false));
                 if (feeProvider != null && rateProvider != null)
                 {
@@ -175,7 +178,7 @@ namespace BTCPayServer.Controllers
 #pragma warning restore CS0618
             }
 
-            entity.SetCryptoData(cryptoDatas);
+            entity.SetPaymentMethods(paymentMethods);
             entity.PosData = invoice.PosData;
             entity = await _InvoiceRepository.CreateInvoiceAsync(store.Id, entity, _NetworkProvider);
             _EventAggregator.Publish(new Events.InvoiceEvent(entity, 1001, "invoice_created"));
@@ -183,10 +186,12 @@ namespace BTCPayServer.Controllers
             return new DataWrapper<InvoiceResponse>(resp) { Facade = "pos/invoice" };
         }
 
+#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

@@ -368,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));
@@ -387,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);

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,13 +1,12 @@
 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.Fees;
 using BTCPayServer.Services.Stores;
 using BTCPayServer.Services.Wallets;
-using LedgerWallet;
-using Microsoft.AspNetCore.Authentication.Cookies;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Identity;
@@ -16,16 +15,11 @@ using Microsoft.AspNetCore.Mvc.Rendering;
 using Microsoft.Extensions.Options;
 using NBitcoin;
 using NBitcoin.DataEncoders;
-using NBitpayClient;
 using NBXplorer.DerivationStrategy;
-using Newtonsoft.Json;
 using System;
 using System.Collections.Generic;
-using System.Globalization;
 using System.Linq;
 using System.Net.Http;
-using System.Net.WebSockets;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -33,11 +27,16 @@ 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,
@@ -47,11 +46,14 @@ namespace BTCPayServer.Controllers
             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;
@@ -59,7 +61,14 @@ namespace BTCPayServer.Controllers
             _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;
@@ -69,6 +78,7 @@ namespace BTCPayServer.Controllers
         StoreRepository _Repo;
         TokenRepository _TokenRepository;
         UserManager<ApplicationUser> _UserManager;
+        private LanguageService _LangService;
         IHostingEnvironment _Env;
 
         [TempData]
@@ -78,41 +88,15 @@ 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]
-        [Route("{storeId}/wallet")]
-        public async Task<IActionResult> Wallet(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.SetCryptoCurrencies(_ExplorerProvider, store.GetDefaultCrypto());
+            model.CryptoCurrency = cryptoCode;
             return View(model);
         }
 
@@ -121,260 +105,82 @@ namespace BTCPayServer.Controllers
             return HttpContext.Request.GetAbsoluteRoot() + "/stores/" + storeId + "/";
         }
 
-        public class GetInfoResult
+        [HttpGet]
+        [Route("{storeId}/users")]
+        public async Task<IActionResult> StoreUsers(string storeId)
         {
-            public int RecommendedSatoshiPerByte { get; set; }
-            public double Balance { get; set; }
+            StoreUsersViewModel vm = new StoreUsersViewModel();
+            await FillUsers(storeId, vm);
+            return View(vm);
         }
 
-        public class SendToAddressResult
+        private async Task FillUsers(string storeId, StoreUsersViewModel vm)
         {
-            public string TransactionId { get; set; }
+            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}/ws/ledger")]
-        public async Task<IActionResult> LedgerConnection(
-            string storeId,
-            string command,
-            // getinfo
-            string cryptoCode = null,
-            // sendtoaddress
-            string destination = null, string amount = null, string feeRate = null, string substractFees = null
-            )
+        [Route("{storeId}/users/{userId}/delete")]
+        public async Task<IActionResult> DeleteStoreUser(string storeId, string userId)
         {
-            if (!HttpContext.WebSockets.IsWebSocketRequest)
-                return NotFound();
-            var store = await _Repo.FindStore(storeId, GetUserId());
+            StoreUsersViewModel vm = new StoreUsersViewModel();
+            var store = await _Repo.FindStore(storeId, userId);
             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 substract fees"); }
-                }
-                if (command == "test")
-                {
-                    result = await hw.Test();
-                }
-                if (command == "getxpub")
-                {
-                    result = await hw.GetExtPubKey(network);
-                }
-                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")
-                {
-                    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);
-                    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.GetDerivationStrategies(_NetworkProvider).FirstOrDefault(s => s.Network.NBitcoinNetwork == network.NBitcoinNetwork);
-            if (strategy == null)
-            {
-                throw new Exception($"Derivation strategy for {network.CryptoCode} is not set");
-            }
-
-            return strategy.DerivationStrategyBase;
-        }
-
-        [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 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,
-                    Balances = balances[i].Select(t => t.Result).ToArray()
-                });
-            }
-            return View(result);
-        }
-
-        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 "--";
-                }
-            }
-        }
-
-        [HttpGet]
-        [Route("{storeId}/delete")]
-        public async Task<IActionResult> DeleteStore(string storeId)
-        {
-            var store = await _Repo.FindStore(storeId, GetUserId());
-            if (store == null)
+            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)
         {
-            var userId = GetUserId();
-            var store = await _Repo.FindStore(storeId, GetUserId());
-            if (store == null)
-                return NotFound();
-            await _Repo.RemoveStore(storeId, userId);
-            StatusMessage = "Store removed successfully";
-            return RedirectToAction(nameof(ListStores));
+            await _Repo.RemoveStoreUser(storeId, userId);
+            StatusMessage = "User removed successfully";
+            return RedirectToAction(nameof(StoreUsers), new { storeId = storeId, userId = userId });
         }
 
         [HttpGet]
@@ -390,125 +196,51 @@ namespace BTCPayServer.Controllers
             vm.Id = store.Id;
             vm.StoreName = store.StoreName;
             vm.SetCryptoCurrencies(_ExplorerProvider, store.GetDefaultCrypto());
+            vm.SetLanguages(_LangService, storeBlob.DefaultLang);
             vm.StoreWebsite = store.StoreWebsite;
             vm.NetworkFee = !storeBlob.NetworkFeeDisabled;
             vm.SpeedPolicy = store.SpeedPolicy;
-            AddDerivationSchemes(store, vm);
+            AddPaymentMethods(store, vm);
             vm.StatusMessage = StatusMessage;
             vm.MonitoringExpiration = storeBlob.MonitoringExpiration;
             vm.InvoiceExpiration = storeBlob.InvoiceExpiration;
             vm.RateMultiplier = (double)storeBlob.GetRateMultiplier();
             vm.PreferredExchange = storeBlob.PreferredExchange.IsCoinAverage() ? "coinaverage" : storeBlob.PreferredExchange;
+            vm.AllowCoinConversion = storeBlob.AllowCoinConversion;
             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.ServerUrl = GetStoreUrl(storeId);
-            vm.SetCryptoCurrencies(_ExplorerProvider, selectedScheme);
-            return View(vm);
-        }
-
-        [HttpPost]
-        [Route("{storeId}/derivations")]
-        public async Task<IActionResult> AddDerivationScheme(string storeId, DerivationSchemeViewModel vm, string selectedScheme = null)
-        {
-            selectedScheme = selectedScheme ?? "BTC";
-            vm.ServerUrl = GetStoreUrl(storeId);
-            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
+                });
             }
 
+            var lightningByCryptoCode = store
+                                        .GetSupportedPaymentMethods(_NetworkProvider)
+                                        .OfType<Payments.Lightning.LightningSupportedPaymentMethod>()
+                                        .ToDictionary(c => c.CryptoCode);
 
-            DerivationStrategyBase strategy = null;
-            try
+            foreach (var network in _NetworkProvider.GetAll())
             {
-                if (!string.IsNullOrEmpty(vm.DerivationScheme))
+                var lightning = lightningByCryptoCode.TryGet(network.CryptoCode);
+                vm.LightningNodes.Add(new StoreViewModel.LightningNode()
                 {
-                    strategy = ParseDerivationStrategy(vm.DerivationScheme, vm.DerivationSchemeFormat, network);
-                    vm.DerivationScheme = strategy.ToString();
-                }
-                store.SetDerivationStrategy(network, vm.DerivationScheme);
-            }
-            catch
-            {
-                ModelState.AddModelError(nameof(vm.DerivationScheme), "Invalid Derivation Scheme");
-                vm.Confirmation = false;
-                return View(vm);
-            }
-
-
-            if (strategy == null || vm.Confirmation)
-            {
-                try
-                {
-                    if (strategy != null)
-                        await wallet.TrackAsync(strategy);
-                    store.SetDerivationStrategy(network, vm.DerivationScheme);
-                }
-                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 });
-            }
-            else
-            {
-                if (!string.IsNullOrEmpty(vm.DerivationScheme))
-                {
-                    var line = strategy.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(network.NBitcoinNetwork).ToString()));
-                    }
-                }
-                vm.Confirmation = true;
-                return View(vm);
+                    CryptoCode = network.CryptoCode,
+                    Address = lightning?.GetLightningUrl()?.BaseUri.AbsoluteUri ?? string.Empty
+                });
             }
         }
 
@@ -516,6 +248,7 @@ namespace BTCPayServer.Controllers
         [Route("{storeId}")]
         public async Task<IActionResult> UpdateStore(string storeId, StoreViewModel model)
         {
+
             if (!ModelState.IsValid)
             {
                 return View(model);
@@ -525,7 +258,7 @@ namespace BTCPayServer.Controllers
             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)
@@ -550,16 +283,19 @@ namespace BTCPayServer.Controllers
                 store.SetDefaultCrypto(model.DefaultCryptoCurrency);
             }
             model.SetCryptoCurrencies(_ExplorerProvider, model.DefaultCryptoCurrency);
+            model.SetLanguages(_LangService, model.DefaultLang);
 
             var blob = store.GetStoreBlob();
             blob.NetworkFeeDisabled = !model.NetworkFee;
             blob.MonitoringExpiration = model.MonitoringExpiration;
             blob.InvoiceExpiration = model.InvoiceExpiration;
+            blob.DefaultLang = model.DefaultLang;
 
             bool newExchange = blob.PreferredExchange != model.PreferredExchange;
             blob.PreferredExchange = model.PreferredExchange;
 
             blob.SetRateMultiplier(model.RateMultiplier);
+            blob.AllowCoinConversion = model.AllowCoinConversion;
 
             if (store.SetStoreBlob(blob))
             {
@@ -591,41 +327,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, Array.Empty<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]
@@ -655,15 +361,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()
@@ -743,11 +451,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
             {
@@ -769,7 +479,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)
@@ -779,10 +489,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/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("#", StringComparison.InvariantCulture);
+            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("#", StringComparison.InvariantCulture);
+            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/HistoricalAddressInvoiceData.cs

@@ -27,9 +27,10 @@ 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()
         {

BTCPayServer/Data/StoreData.cs

@@ -12,6 +12,7 @@ using System.ComponentModel;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using BTCPayServer.Services.Rates;
+using BTCPayServer.Payments;
 
 namespace BTCPayServer.Data
 {
@@ -41,10 +42,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 +63,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 +213,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

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", Array.Empty<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", Array.Empty<object>())).ConfigureAwait(false);
-        }
-
-        public string[] Channels()
-        {
-            return ChannelsAsync().GetAwaiter().GetResult();
-        }
-
-        public async Task<string[]> ChannelsAsync()
-        {
-            return await SendCommandAsync<string[]>(new RPCRequest("channels", Array.Empty<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", Array.Empty<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/ExplorerClientProvider.cs

@@ -77,7 +77,7 @@ namespace BTCPayServer
 
         public bool IsAvailable(string cryptoCode)
         {
-            return _Clients.ContainsKey(cryptoCode) && _Dashboard.IsFullySynched(cryptoCode);
+            return _Clients.ContainsKey(cryptoCode) && _Dashboard.IsFullySynched(cryptoCode, out var unused);
         }
 
         public BTCPayNetwork GetNetwork(string cryptoCode)

BTCPayServer/Extensions.cs

@@ -22,11 +22,31 @@ using System.IO;
 using BTCPayServer.Logging;
 using Microsoft.Extensions.Logging;
 using System.Net.WebSockets;
+using BTCPayServer.Services.Invoices;
+using NBitpayClient;
+using BTCPayServer.Payments;
 
 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

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

@@ -70,82 +70,118 @@ namespace BTCPayServer.HostedServices
                 invoice.Status = "expired";
             }
 
-            var derivationStrategies = invoice.GetDerivationStrategies(_NetworkProvider).ToArray();
             var payments = invoice.GetPayments().Where(p => p.Accounted).ToArray();
-            foreach (BTCPayNetwork network in _NetworkProvider.GetAll())
+            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 cryptoData = invoice.GetCryptoData(network, _NetworkProvider);
-                if (cryptoData == null) // Altcoin not supported
-                    continue;
-                var cryptoDataAll = invoice.GetCryptoData(_NetworkProvider);
-                var accounting = cryptoData.Calculate();
-
-                if (invoice.Status == "new" || invoice.Status == "expired")
+                if (accounting.Paid >= accounting.TotalDue)
                 {
-                    var totalPaid = payments.Select(p => p.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
-                    if (totalPaid >= accounting.TotalDue)
+                    if (invoice.Status == "new")
                     {
-                        if (invoice.Status == "new")
-                        {
-                            context.Events.Add(new InvoiceEvent(invoice, 1003, "invoice_paidInFull"));
-                            invoice.Status = "paid";
-                            invoice.ExceptionStatus = totalPaid > 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();
-                        }
+                        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();
                     }
-
-                    if (totalPaid < accounting.TotalDue && invoice.GetPayments().Count != 0 && invoice.ExceptionStatus != "paidPartial")
+                    else if (invoice.Status == "expired" && invoice.ExceptionStatus != "paidLate")
                     {
-                        invoice.ExceptionStatus = "paidPartial";
+                        invoice.ExceptionStatus = "paidLate";
+                        context.Events.Add(new InvoiceEvent(invoice, 1009, "invoice_paidAfterExpiration"));
                         context.MarkDirty();
                     }
                 }
 
-                if (invoice.Status == "paid")
+                if (accounting.Paid < accounting.TotalDue && invoice.GetPayments().Count != 0 && invoice.ExceptionStatus != "paidPartial")
                 {
-                    var transactions = payments.Where(p => p.GetCryptoPaymentData().PaymentConfirmed(p, invoice.SpeedPolicy, network));
-
-                    var totalConfirmed = transactions.Select(t => t.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")
-                {
-                    var transactions = payments.Where(p => p.GetCryptoPaymentData().PaymentCompleted(p, network));
-                    var totalConfirmed = transactions.Select(t => t.GetValue(cryptoDataAll, cryptoData.CryptoCode)).Sum();
-                    if (totalConfirmed >= accounting.TotalDue)
-                    {
-                        context.Events.Add(new InvoiceEvent(invoice, 1006, "invoice_completed"));
-                        invoice.Status = "complete";
-                        context.MarkDirty();
-                    }
+                    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;
+                var currentAccounting = paymentMethod.Calculate();
+                var distanceFromZero = Math.Abs(currentAccounting.DueUncapped.ToDecimal(MoneyUnit.BTC));
+                if (result == null || distanceFromZero < nearestToZero)
+                {
+                    result = paymentMethod;
+                    nearestToZero = distanceFromZero;
+                    accounting = currentAccounting;
+                }
+            }
+            return result;
         }
 
         TimeSpan _PollInterval;

BTCPayServer/HostedServices/NBXplorerWaiter.cs

@@ -41,9 +41,11 @@ namespace BTCPayServer.HostedServices
             return _Summaries.All(s => s.Value.Status != null && s.Value.Status.IsFullySynched);
         }
 
-        public bool IsFullySynched(string cryptoCode)
+        public bool IsFullySynched(string cryptoCode, out NBXplorerSummary summary)
         {
-            return _Summaries.Any(s => s.Key.Equals(cryptoCode, StringComparison.OrdinalIgnoreCase) && s.Value.Status != null && s.Value.Status.IsFullySynched);
+            return _Summaries.TryGetValue(cryptoCode, out summary) && 
+                   summary.Status != null && 
+                   summary.Status.IsFullySynched;
         }
 
         public IEnumerable<NBXplorerSummary> GetAll()

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,8 +145,13 @@ namespace BTCPayServer.Hosting
                 BlockTarget = 20
             });
 
+            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>();
 
@@ -166,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;
         }
 
@@ -192,7 +212,7 @@ namespace BTCPayServer.Hosting
             }
 
             app.UseMiddleware<BTCPayMiddleware>();
-            return app;
+            return app; 
         }
 
         static void Retry(Action act)

BTCPayServer/Hosting/Startup.cs

@@ -39,6 +39,7 @@ 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
 {

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/Models/InvoicingModels/InvoiceDetailsModel.cs

@@ -12,16 +12,22 @@ 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 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,10 +9,12 @@ 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 DefaultLang { get; set; }
         public List<AvailableCrypto> AvailableCryptos { get; set; } = new List<AvailableCrypto>();
         public string CryptoCode { get; set; }
         public string ServerUrl { get; set; }
@@ -32,6 +34,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; }
@@ -40,5 +43,9 @@ namespace BTCPayServer.Models.InvoicingModels
         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; }
     }
 }

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/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,33 +22,12 @@ namespace BTCPayServer.Models.StoreViewModels
             get; set;
         } = new List<(string KeyPath, string Address)>();
 
-        [Display(Name = "Derivation Scheme format")]
-        public string DerivationSchemeFormat
-        {
-            get;
-            set;
-        }
-
-        [Display(Name = "Crypto currency")]
-        public string CryptoCurrency
-        {
-            get;
-            set;
-        }
-
+        public string CryptoCode { get; set; }
+        [Display(Name = "Hint address")]
+        public string HintAddress { get; set; }
         public bool Confirmation { get; set; }
 
-        public SelectList CryptoCurrencies { get; set; }
-        public SelectList DerivationSchemeFormats { get; set; }
-
         public string ServerUrl { 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 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;
@@ -94,21 +95,49 @@ namespace BTCPayServer.Models.StoreViewModels
             get; set;
         }
 
+        [Display(Name = "Allow conversion through third party (Shapeshift, Changelly...)")]
+        public bool AllowCoinConversion
+        {
+            get; set;
+        }
+
         public string StatusMessage
         {
             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; }
+
+        public class LightningNode
+        {
+            public string CryptoCode { get; set; }
+            public string Address { get; set; }
+        }
+        public List<LightningNode> LightningNodes
+        {
+            get; set;
+        } = new List<LightningNode>();
 
         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();
+            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/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

@@ -10,25 +10,10 @@ namespace BTCPayServer.Models.StoreViewModels
     public class WalletModel
     {
         public string ServerUrl { get; set; }
-        public SelectList CryptoCurrencies { get; set; }
-        [Display(Name = "Crypto currency")]
         public string CryptoCurrency
         {
             get;
             set;
         }
-
-        class Format
-        {
-            public string Name { get; set; }
-            public string Value { 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;
-        }
     }
 }

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,46 @@
+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)
+        {
+            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;
+        }
+
+        public override Task<bool> IsAvailable(DerivationStrategy supportedPaymentMethod, BTCPayNetwork network)
+        {
+            return Task.FromResult(_ExplorerProvider.IsAvailable(network));
+        }
+    }
+}

BTCPayServer/Payments/Bitcoin/NBXplorerListener.cs

@@ -16,9 +16,14 @@ using BTCPayServer.Services;
 using BTCPayServer.Services.Wallets;
 using NBitcoin;
 using NBXplorer.Models;
+using BTCPayServer.Payments;
+using BTCPayServer.HostedServices;
 
-namespace 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;
@@ -28,10 +33,12 @@ namespace BTCPayServer.HostedServices
         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);
@@ -40,10 +47,11 @@ namespace BTCPayServer.HostedServices
             _ExplorerClients = explorerClients;
             _Aggregator = aggregator;
             _Lifetime = lifetime;
+            _NetworkProvider = networkProvider;
         }
 
         CompositeDisposable leases = new CompositeDisposable();
-        ConcurrentDictionary<string, NotificationSession> _Sessions = new ConcurrentDictionary<string, NotificationSession>();
+        ConcurrentDictionary<string, NotificationSession> _SessionsByCryptoCode = new ConcurrentDictionary<string, NotificationSession>();
         private Timer _ListenPoller;
 
         TimeSpan _PollInterval;
@@ -90,24 +98,6 @@ namespace BTCPayServer.HostedServices
                 }
             }, 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;
         }
 
@@ -117,7 +107,7 @@ namespace BTCPayServer.HostedServices
             bool cleanup = false;
             try
             {
-                if (_Sessions.ContainsKey(network.CryptoCode))
+                if (_SessionsByCryptoCode.ContainsKey(network.CryptoCode))
                     return;
                 var client = _ExplorerClients.GetExplorerClient(network);
                 if (client == null)
@@ -125,7 +115,7 @@ namespace BTCPayServer.HostedServices
                 if (_Cts.IsCancellationRequested)
                     return;
                 var session = await client.CreateNotificationSessionAsync(_Cts.Token).ConfigureAwait(false);
-                if (!_Sessions.TryAdd(network.CryptoCode, session))
+                if (!_SessionsByCryptoCode.TryAdd(network.CryptoCode, session))
                 {
                     await session.DisposeAsync();
                     return;
@@ -135,7 +125,7 @@ namespace BTCPayServer.HostedServices
                 using (session)
                 {
                     await session.ListenNewBlockAsync(_Cts.Token).ConfigureAwait(false);
-                    await session.ListenDerivationSchemesAsync((await GetStrategies(network)).ToArray(), _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);
@@ -170,7 +160,8 @@ namespace BTCPayServer.HostedServices
                                             if (!alreadyExist)
                                             {
                                                 var payment = await _InvoiceRepository.AddPayment(invoice.Id, DateTimeOffset.UtcNow, paymentData, network.CryptoCode);
-                                                await ReceivedPayment(wallet, invoice.Id, payment, evt.DerivationStrategy);
+                                                if(payment != null)
+                                                    await ReceivedPayment(wallet, invoice.Id, payment, evt.DerivationStrategy);
                                             }
                                             else
                                             {
@@ -197,8 +188,8 @@ namespace BTCPayServer.HostedServices
                 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)
+                    _SessionsByCryptoCode.TryRemove(network.CryptoCode, out NotificationSession unused);
+                    if (_SessionsByCryptoCode.Count == 0 && _Cts.IsCancellationRequested)
                     {
                         _RunningTask.TrySetResult(true);
                     }
@@ -209,7 +200,7 @@ namespace BTCPayServer.HostedServices
         IEnumerable<BitcoinLikePaymentData> GetAllBitcoinPaymentData(InvoiceEntity invoice)
         {
             return invoice.GetPayments()
-                    .Where(p => p.GetCryptoPaymentDataType() == BitcoinLikePaymentData.OnchainBitcoinType)
+                    .Where(p => p.GetPaymentMethodId().PaymentType == PaymentTypes.BTCLike)
                     .Select(p => (BitcoinLikePaymentData)p.GetCryptoPaymentData());
         }
 
@@ -223,7 +214,7 @@ namespace BTCPayServer.HostedServices
             var conflicts = GetConflicts(transactions.Select(t => t.Value));
             foreach (var payment in invoice.GetPayments(wallet.Network))
             {
-                if (payment.GetCryptoPaymentDataType() != BitcoinLikePaymentData.OnchainBitcoinType)
+                if (payment.GetPaymentMethodId().PaymentType != PaymentTypes.BTCLike)
                     continue;
                 var paymentData = (BitcoinLikePaymentData)payment.GetCryptoPaymentData();
                 if (!transactions.TryGetValue(paymentData.Outpoint.Hash, out TransactionResult tx))
@@ -241,7 +232,7 @@ namespace BTCPayServer.HostedServices
 
                 if (paymentData.ConfirmationCount != tx.Confirmations)
                 {
-                    if(wallet.Network.MaxTrackedConfirmation >= paymentData.ConfirmationCount)
+                    if (wallet.Network.MaxTrackedConfirmation >= paymentData.ConfirmationCount)
                     {
                         paymentData.ConfirmationCount = tx.Confirmations;
                         payment.SetCryptoPaymentData(paymentData);
@@ -275,7 +266,7 @@ namespace BTCPayServer.HostedServices
                     }
                     else
                     {
-                        // Take the most recent (bitcoin node would not forward a conflict without a successfull RBF)
+                        // Take the most recent (bitcoin node would not forward a conflict without a successful RBF)
                         _Winner = Transactions
                                 .OrderByDescending(t => t.Value.Timestamp)
                                 .First()
@@ -325,11 +316,14 @@ namespace BTCPayServer.HostedServices
             {
                 var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId, true);
                 var alreadyAccounted = GetAllBitcoinPaymentData(invoice).Select(p => p.Outpoint).ToHashSet();
-                var strategy = invoice.GetDerivationStrategy(network);
+                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() + network.CryptoCode))
+                             .Where(c => invoice.AvailableAddressHashes.Contains(c.Coin.ScriptPubKey.Hash.ToString() + cryptoId))
                              .ToArray();
                 foreach (var coin in coins.Where(c => !alreadyAccounted.Contains(c.Coin.Outpoint)))
                 {
@@ -337,57 +331,42 @@ namespace BTCPayServer.HostedServices
                     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);
-                    invoice = await ReceivedPayment(wallet, invoice.Id, payment, strategy);
+                    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 cryptoData = invoice.GetCryptoData(wallet.Network, _ExplorerClients.NetworkProviders);
-            if (cryptoData.GetDepositAddress().ScriptPubKey == paymentData.Output.ScriptPubKey && cryptoData.Calculate().Due > Money.Zero)
+            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);
-                await _InvoiceRepository.NewAddress(invoiceId, address, wallet.Network);
+                btc.DepositAddress = address.ToString();
+                await _InvoiceRepository.NewAddress(invoiceId, btc, wallet.Network);
                 _Aggregator.Publish(new InvoiceNewAddressEvent(invoiceId, address.ToString(), wallet.Network));
-                cryptoData.DepositAddress = address.ToString();
-                invoice.SetCryptoData(cryptoData);
+                paymentMethod.SetPaymentMethodDetails(btc);
+                invoice.SetPaymentMethod(paymentMethod);
             }
             wallet.InvalidateCache(strategy);
             _Aggregator.Publish(new InvoiceEvent(invoiceId, 1002, "invoice_receivedPayment"));
             return invoice;
         }
-
-        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();

BTCPayServer/Payments/IPaymentMethodDetails.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+
+namespace BTCPayServer.Payments
+{
+    /// <summary>
+    /// Represent information necessary to track a payment
+    /// </summary>
+    public interface IPaymentMethodDetails
+    {
+        /// <summary>
+        /// A string representation of the payment destination
+        /// </summary>
+        /// <returns></returns>
+        string GetPaymentDestination();
+        PaymentTypes GetPaymentType();
+        /// <summary>
+        /// Returns what a merchant would need to pay to cashout this payment
+        /// </summary>
+        /// <returns></returns>
+        decimal GetTxFee();
+        void SetNoTxFee();
+        /// <summary>
+        /// Change the payment destination (internal plumbing)
+        /// </summary>
+        /// <param name="newPaymentDestination"></param>
+        void SetPaymentDestination(string newPaymentDestination);
+    }
+}

BTCPayServer/Payments/IPaymentMethodHandler.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Invoices;
+
+namespace BTCPayServer.Payments
+{
+    /// <summary>
+    /// This class customize invoice creation by the creation of payment details for the PaymentMethod during invoice creation
+    /// </summary>
+    public interface IPaymentMethodHandler
+    {
+        /// <summary>
+        /// Returns true if the dependencies for a specific payment method are satisfied. 
+        /// </summary>
+        /// <param name="supportedPaymentMethod"></param>
+        /// <param name="network"></param>
+        /// <returns>true if this payment method is available</returns>
+        Task<bool> IsAvailable(ISupportedPaymentMethod supportedPaymentMethod, BTCPayNetwork network);
+
+        /// <summary>
+        /// Create needed to track payments of this invoice
+        /// </summary>
+        /// <param name="supportedPaymentMethod"></param>
+        /// <param name="paymentMethod"></param>
+        /// <param name="network"></param>
+        /// <returns></returns>
+        Task<IPaymentMethodDetails> CreatePaymentMethodDetails(ISupportedPaymentMethod supportedPaymentMethod, PaymentMethod paymentMethod, BTCPayNetwork network);
+    }
+
+    public interface IPaymentMethodHandler<T> : IPaymentMethodHandler where T : ISupportedPaymentMethod
+    {
+        Task<bool> IsAvailable(T supportedPaymentMethod, BTCPayNetwork network);
+        Task<IPaymentMethodDetails> CreatePaymentMethodDetails(T supportedPaymentMethod, PaymentMethod paymentMethod, BTCPayNetwork network);
+    }
+
+    public abstract class PaymentMethodHandlerBase<T> : IPaymentMethodHandler<T> where T : ISupportedPaymentMethod
+    {
+        public abstract Task<IPaymentMethodDetails> CreatePaymentMethodDetails(T supportedPaymentMethod, PaymentMethod paymentMethod, BTCPayNetwork network);
+
+        Task<IPaymentMethodDetails> IPaymentMethodHandler.CreatePaymentMethodDetails(ISupportedPaymentMethod supportedPaymentMethod, PaymentMethod paymentMethod, BTCPayNetwork network)
+        {
+            if (supportedPaymentMethod is T method)
+            {
+                return CreatePaymentMethodDetails(method, paymentMethod, network);
+            }
+            throw new NotSupportedException("Invalid supportedPaymentMethod");
+        }
+
+        public abstract Task<bool> IsAvailable(T supportedPaymentMethod, BTCPayNetwork network);
+
+        Task<bool> IPaymentMethodHandler.IsAvailable(ISupportedPaymentMethod supportedPaymentMethod, BTCPayNetwork network)
+        {
+            if(supportedPaymentMethod is T method)
+            { 
+                return IsAvailable(method, network);
+            }
+            return Task.FromResult(false);
+        }
+    }
+}

BTCPayServer/Payments/ISupportedPaymentMethod.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Services.Invoices;
+
+namespace BTCPayServer.Payments
+{
+    /// <summary>
+    /// This class represent a mode of payment supported by a store.
+    /// It is stored at the store level and cloned to the invoice during invoice creation.
+    /// This object will be serialized in database in json
+    /// </summary>
+    public interface ISupportedPaymentMethod
+    {
+        PaymentMethodId PaymentId { get; }
+    }
+}

BTCPayServer/Payments/Lightning/CLightning/CLightningRPCClient.cs

@@ -0,0 +1,231 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Payments.Lightning.Charge;
+using Mono.Unix;
+using NBitcoin;
+using NBitcoin.RPC;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Payments.Lightning.CLightning
+{
+    public class LightningRPCException : Exception
+    {
+        public LightningRPCException(string message) : base(message)
+        {
+
+        }
+    }
+    public class CLightningRPCClient : ILightningInvoiceClient, ILightningListenInvoiceSession
+    {
+        public Network Network { get; private set; }
+        public Uri Address { get; private set; }
+
+        public CLightningRPCClient(Uri address, Network network)
+        {
+            if (address == null)
+                throw new ArgumentNullException(nameof(address));
+            if (network == null)
+                throw new ArgumentNullException(nameof(network));
+            if(address.Scheme == "file")
+            {
+                address = new UriBuilder(address) { Scheme = "unix" }.Uri;
+            }
+            Address = address;
+            Network = network;
+        }
+
+        public Task<GetInfoResponse> GetInfoAsync(CancellationToken cancellation = default(CancellationToken))
+        {
+            return SendCommandAsync<GetInfoResponse>("getinfo", cancellation: cancellation);
+        }
+
+        public Task SendAsync(string bolt11)
+        {
+            return SendCommandAsync<object>("pay", new[] { bolt11 }, true);
+        }
+
+        public async Task<PeerInfo[]> ListPeersAsync()
+        {
+            var peers = await SendCommandAsync<PeerInfo[]>("listpeers", isArray: true);
+            foreach (var peer in peers)
+            {
+                peer.Channels = peer.Channels ?? Array.Empty<ChannelInfo>();
+            }
+            return peers;
+        }
+
+        public Task FundChannelAsync(NodeInfo nodeInfo, Money money)
+        {
+            return SendCommandAsync<object>("fundchannel", new object[] { nodeInfo.NodeId, money.Satoshi }, true);
+        }
+
+        public Task ConnectAsync(NodeInfo nodeInfo)
+        {
+            return SendCommandAsync<object>("connect", new[] { $"{nodeInfo.NodeId}@{nodeInfo.Host}:{nodeInfo.Port}" }, true);
+        }
+
+        static Encoding UTF8 = new UTF8Encoding(false);
+        private async Task<T> SendCommandAsync<T>(string command, object[] parameters = null, bool noReturn = false, bool isArray = false, CancellationToken cancellation = default(CancellationToken))
+        {
+            parameters = parameters ?? Array.Empty<string>();
+            using (Socket socket = await Connect())
+            {
+                using (var networkStream = new NetworkStream(socket))
+                {
+                    using (var textWriter = new StreamWriter(networkStream, UTF8, 1024 * 10, true))
+                    {
+                        using (var jsonWriter = new JsonTextWriter(textWriter))
+                        {
+                            var req = new JObject();
+                            req.Add("id", 0);
+                            req.Add("method", command);
+                            req.Add("params", new JArray(parameters));
+                            await req.WriteToAsync(jsonWriter, cancellation);
+                            await jsonWriter.FlushAsync(cancellation);
+                        }
+                        await textWriter.FlushAsync();
+                    }
+                    await networkStream.FlushAsync(cancellation);
+                    using (var textReader = new StreamReader(networkStream, UTF8, false, 1024 * 10, true))
+                    {
+                        using (var jsonReader = new JsonTextReader(textReader))
+                        {
+                            var resultAsync = JObject.LoadAsync(jsonReader, cancellation);
+
+                            // without this hack resultAsync is blocking even if cancellation happen
+                            using (cancellation.Register(() => { socket.Dispose(); }))
+                            {
+                                var result = await resultAsync;
+                                var error = result.Property("error");
+                                if (error != null)
+                                {
+                                    throw new LightningRPCException(error.Value["message"].Value<string>());
+                                }
+                                if (noReturn)
+                                    return default(T);
+                                if (isArray)
+                                {
+                                    return result["result"].Children().First().Children().First().ToObject<T>();
+                                }
+                                return result["result"].ToObject<T>();
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        private async Task<Socket> Connect()
+        {
+            Socket socket = null;
+            EndPoint endpoint = null;
+            if (Address.Scheme == "tcp" || Address.Scheme == "tcp")
+            {
+                var domain = Address.DnsSafeHost;
+                if (!IPAddress.TryParse(domain, out IPAddress address))
+                {
+                    address = (await Dns.GetHostAddressesAsync(domain)).FirstOrDefault();
+                    if (address == null)
+                        throw new Exception("Host not found");
+                }
+                socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
+                endpoint = new IPEndPoint(address, Address.Port);
+            }
+            else if (Address.Scheme == "unix")
+            {
+                var path = Address.AbsoluteUri.Remove(0, "unix:".Length);
+                if (!path.StartsWith('/'))
+                    path = "/" + path;
+                while (path.Length >= 2 && (path[0] != '/' || path[1] == '/'))
+                {
+                    path = path.Remove(0, 1);
+                }
+                if (path.Length < 2)
+                    throw new FormatException("Invalid unix url");
+                socket = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.IP);
+                endpoint = new UnixEndPoint(path);
+            }
+            else
+                throw new NotSupportedException($"Protocol {Address.Scheme} for clightning not supported");
+
+            await socket.ConnectAsync(endpoint);
+            return socket;
+        }
+
+        public async Task<BitcoinAddress> NewAddressAsync()
+        {
+            var obj = await SendCommandAsync<JObject>("newaddr");
+            return BitcoinAddress.Create(obj.Property("address").Value.Value<string>(), Network);
+        }
+
+        async Task<LightningInvoice> ILightningInvoiceClient.GetInvoice(string invoiceId, CancellationToken cancellation)
+        {
+            var invoices = await SendCommandAsync<ChargeInvoice[]>("listinvoices", new[] { invoiceId }, false, true, cancellation);
+            if (invoices.Length == 0)
+                return null;
+            return ChargeClient.ToLightningInvoice(invoices[0]);
+        }
+
+        static NBitcoin.DataEncoders.DataEncoder InvoiceIdEncoder = NBitcoin.DataEncoders.Encoders.Base58;
+        async Task<LightningInvoice> ILightningInvoiceClient.CreateInvoice(LightMoney amount, TimeSpan expiry, CancellationToken cancellation)
+        {
+            var id = InvoiceIdEncoder.EncodeData(RandomUtils.GetBytes(20));
+            var invoice = await SendCommandAsync<CreateInvoiceResponse>("invoice", new object[] { amount.MilliSatoshi, id, "" }, cancellation: cancellation);
+            invoice.Label = id;
+            invoice.MilliSatoshi = amount;
+            invoice.Status = "unpaid";
+            return ToLightningInvoice(invoice);
+        }
+
+        private static LightningInvoice ToLightningInvoice(CreateInvoiceResponse invoice)
+        {
+            return new LightningInvoice()
+            {
+                Id = invoice.Label,
+                Amount = invoice.MilliSatoshi,
+                BOLT11 = invoice.BOLT11,
+                Status = invoice.Status,
+                PaidAt = invoice.PaidAt
+            };
+        }
+
+        Task<ILightningListenInvoiceSession> ILightningInvoiceClient.Listen(CancellationToken cancellation)
+        {
+            return Task.FromResult<ILightningListenInvoiceSession>(this);
+        }
+        long lastInvoiceIndex = 99999999999;
+        async Task<LightningInvoice> ILightningListenInvoiceSession.WaitInvoice(CancellationToken cancellation)
+        {
+            var chargeInvoice = await SendCommandAsync<CreateInvoiceResponse>("waitanyinvoice", new object[] { lastInvoiceIndex }, cancellation: cancellation);
+            lastInvoiceIndex = chargeInvoice.PayIndex.Value;
+            return ToLightningInvoice(chargeInvoice);
+        }
+
+        async Task<LightningNodeInformation> ILightningInvoiceClient.GetInfo(CancellationToken cancellation)
+        {
+            var info = await GetInfoAsync(cancellation);
+            var address = info.Address.Select(a => a.Address).FirstOrDefault();
+            var port = info.Port;
+            return new LightningNodeInformation()
+            {
+                NodeId = info.Id,
+                P2PPort = port,
+                Address = address,
+                BlockHeight = info.BlockHeight
+            };
+        }
+
+        void IDisposable.Dispose()
+        {
+
+        }
+    }
+}

BTCPayServer/Payments/Lightning/CLightning/CreateInvoiceResponse.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Payments.Lightning.CLightning
+{
+    public class CreateInvoiceResponse
+    {
+        [JsonConverter(typeof(NBitcoin.JsonConverters.UInt256JsonConverter))]
+        [JsonProperty("payment_hash")]
+        public uint256 PaymentHash { get; set; }
+
+        [JsonProperty("msatoshi")]
+        [JsonConverter(typeof(JsonConverters.LightMoneyJsonConverter))]
+        public LightMoney MilliSatoshi { get; set; }
+        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+        [JsonProperty("expiry_time")]
+        public DateTimeOffset ExpiryTime { get; set; }
+        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+        [JsonProperty("expires_at")]
+        public DateTimeOffset ExpiryAt { get; set; }
+        [JsonProperty("bolt11")]
+        public string BOLT11 { get; set; }
+        [JsonProperty("pay_index")]
+        public int? PayIndex { get; set; }
+        public string Label { get; set; }
+        public string Status { get; set; }
+        [JsonProperty("paid_at")]
+        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+        public DateTimeOffset? PaidAt { get; set; }
+    }
+}

BTCPayServer/Payments/Lightning/CLightning/NodeInfo.cs

@@ -3,7 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 
-namespace BTCPayServer.Eclair
+namespace BTCPayServer.Payments.Lightning.CLightning
 {
     public class NodeInfo
     {
@@ -20,5 +20,10 @@ namespace BTCPayServer.Eclair
         public string NodeId { get; private set; }
         public string Host { get; private set; }
         public int Port { get; private set; }
+
+        public override string ToString()
+        {
+            return $"{NodeId}@{Host}:{Port}";
+        }
     }
 }

BTCPayServer/Payments/Lightning/CLightning/PeerInfo.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Payments.Lightning.CLightning
+{
+    public class ChannelInfo
+    {
+        public string State { get; set; }
+        public string Owner { get; set; }
+
+        [JsonProperty("funding_txid")]
+        [JsonConverter(typeof(NBitcoin.JsonConverters.UInt256JsonConverter))]
+        public uint256 FundingTxId { get; set; }
+
+        [JsonProperty("msatoshi_to_us")]
+        [JsonConverter(typeof(JsonConverters.LightMoneyJsonConverter))]
+        public LightMoney ToUs { get; set; }
+
+        [JsonProperty("msatoshi_total")]
+        [JsonConverter(typeof(JsonConverters.LightMoneyJsonConverter))]
+        public LightMoney Total { get; set; }
+
+        [JsonProperty("dust_limit_satoshis")]
+        [JsonConverter(typeof(NBitcoin.JsonConverters.MoneyJsonConverter))]
+        public Money DustLimit { get; set; }
+
+        [JsonProperty("max_htlc_value_in_flight_msat")]
+        [JsonConverter(typeof(JsonConverters.LightMoneyJsonConverter))]
+        public LightMoney MaxHTLCValueInFlight { get; set; }
+
+        [JsonProperty("channel_reserve_satoshis")]
+        [JsonConverter(typeof(NBitcoin.JsonConverters.MoneyJsonConverter))]
+        public Money ChannelReserve { get; set; }
+
+        [JsonProperty("htlc_minimum_msat")]
+        [JsonConverter(typeof(JsonConverters.LightMoneyJsonConverter))]
+        public LightMoney HTLCMinimum { get; set; }
+
+        [JsonProperty("to_self_delay")]
+        public int ToSelfDelay { get; set; }
+        [JsonProperty("max_accepted_htlcs")]
+        public int MaxAcceptedHTLCS { get; set; }
+        public string[] Status { get; set; }
+    }
+    public class PeerInfo
+    {
+        public string State { get; set; }
+        public string Id { get; set; }
+        [JsonProperty("netaddr")]
+        public string[] NetworkAddresses { get; set; }
+        public bool Connected { get; set; }
+        public string Owner { get; set; }
+        public ChannelInfo[] Channels { get; set; }
+
+    }
+}

BTCPayServer/Payments/Lightning/CLightning/UnixEndPoint.cs

@@ -0,0 +1,140 @@
+//
+// Mono.Unix.UnixEndPoint: EndPoint derived class for AF_UNIX family sockets.
+//
+// Authors:
+//	Gonzalo Paniagua Javier (gonzalo@ximian.com)
+//
+// (C) 2003 Ximian, Inc (http://www.ximian.com)
+//
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+using System;
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+
+namespace Mono.Unix
+{
+    [Serializable]
+    public class UnixEndPoint : EndPoint
+    {
+        string filename;
+
+        public UnixEndPoint(string filename)
+        {
+            if (filename == null)
+                throw new ArgumentNullException("filename");
+
+            if (filename.Length == 0)
+                throw new ArgumentException("Cannot be empty.", "filename");
+            this.filename = filename;
+        }
+
+        public string Filename
+        {
+            get
+            {
+                return (filename);
+            }
+            set
+            {
+                filename = value;
+            }
+        }
+
+        public override AddressFamily AddressFamily
+        {
+            get { return AddressFamily.Unix; }
+        }
+
+        public override EndPoint Create(SocketAddress socketAddress)
+        {
+            /*
+			 * Should also check this
+			 *
+			int addr = (int) AddressFamily.Unix;
+			if (socketAddress [0] != (addr & 0xFF))
+				throw new ArgumentException ("socketAddress is not a unix socket address.");
+
+			if (socketAddress [1] != ((addr & 0xFF00) >> 8))
+				throw new ArgumentException ("socketAddress is not a unix socket address.");
+			 */
+
+            if (socketAddress.Size == 2)
+            {
+                // Empty filename.
+                // Probably from RemoteEndPoint which on linux does not return the file name.
+                UnixEndPoint uep = new UnixEndPoint("a");
+                uep.filename = "";
+                return uep;
+            }
+            int size = socketAddress.Size - 2;
+            byte[] bytes = new byte[size];
+            for (int i = 0; i < bytes.Length; i++)
+            {
+                bytes[i] = socketAddress[i + 2];
+                // There may be junk after the null terminator, so ignore it all.
+                if (bytes[i] == 0)
+                {
+                    size = i;
+                    break;
+                }
+            }
+
+            string name = Encoding.Default.GetString(bytes, 0, size);
+            return new UnixEndPoint(name);
+        }
+
+        public override SocketAddress Serialize()
+        {
+            byte[] bytes = Encoding.Default.GetBytes(filename);
+            SocketAddress sa = new SocketAddress(AddressFamily, 2 + bytes.Length + 1);
+            // sa [0] -> family low byte, sa [1] -> family high byte
+            for (int i = 0; i < bytes.Length; i++)
+                sa[2 + i] = bytes[i];
+
+            //NULL suffix for non-abstract path
+            sa[2 + bytes.Length] = 0;
+
+            return sa;
+        }
+
+        public override string ToString()
+        {
+            return (filename);
+        }
+
+        public override int GetHashCode()
+        {
+            return filename.GetHashCode(StringComparison.Ordinal);
+        }
+
+        public override bool Equals(object o)
+        {
+            UnixEndPoint other = o as UnixEndPoint;
+            if (other == null)
+                return false;
+
+            return (other.filename == filename);
+        }
+    }
+}

BTCPayServer/Payments/Lightning/Charge/ChargeClient.cs

@@ -0,0 +1,173 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Net.WebSockets;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using NBitcoin;
+using NBXplorer;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Payments.Lightning.Charge
+{
+    public class ChargeClient : ILightningInvoiceClient
+    {
+        private Uri _Uri;
+        public Uri Uri
+        {
+            get
+            {
+                return _Uri;
+            }
+        }
+        private Network _Network;
+        static HttpClient _Client = new HttpClient();
+
+        public ChargeClient(Uri uri, Network network)
+        {
+            if (uri == null)
+                throw new ArgumentNullException(nameof(uri));
+            if (network == null)
+                throw new ArgumentNullException(nameof(network));
+            this._Uri = uri;
+            this._Network = network;
+            if (uri.UserInfo == null)
+                throw new ArgumentException(paramName: nameof(uri), message: "User information not present in uri");
+            var userInfo = uri.UserInfo.Split(':');
+            if (userInfo.Length != 2)
+                throw new ArgumentException(paramName: nameof(uri), message: "User information not present in uri");
+            Credentials = new NetworkCredential(userInfo[0], userInfo[1]);
+        }
+
+        public async Task<CreateInvoiceResponse> CreateInvoiceAsync(CreateInvoiceRequest request, CancellationToken cancellation = default(CancellationToken))
+        {
+            var message = CreateMessage(HttpMethod.Post, "invoice");
+            Dictionary<string, string> parameters = new Dictionary<string, string>();
+            parameters.Add("msatoshi", request.Amont.MilliSatoshi.ToString(CultureInfo.InvariantCulture));
+            parameters.Add("expiry", ((int)request.Expiry.TotalSeconds).ToString(CultureInfo.InvariantCulture));
+            message.Content = new FormUrlEncodedContent(parameters);
+            var result = await _Client.SendAsync(message, cancellation);
+            result.EnsureSuccessStatusCode();
+            var content = await result.Content.ReadAsStringAsync();
+            return JsonConvert.DeserializeObject<CreateInvoiceResponse>(content);
+        }
+
+        public async Task<ChargeSession> Listen(CancellationToken cancellation = default(CancellationToken))
+        {
+            var socket = new ClientWebSocket();
+            socket.Options.SetRequestHeader("Authorization", $"Basic {GetBase64Creds()}");
+            var uri = new UriBuilder(Uri) { UserName = null, Password = null }.Uri.AbsoluteUri;
+            if (!uri.EndsWith('/'))
+                uri += "/";
+            uri += "ws";
+            uri = ToWebsocketUri(uri);
+            await socket.ConnectAsync(new Uri(uri), cancellation);
+            return new ChargeSession(socket);
+        }
+
+        private static string ToWebsocketUri(string uri)
+        {
+            if (uri.StartsWith("https://", StringComparison.OrdinalIgnoreCase))
+                uri = uri.Replace("https://", "wss://", StringComparison.OrdinalIgnoreCase);
+            if (uri.StartsWith("http://", StringComparison.OrdinalIgnoreCase))
+                uri = uri.Replace("http://", "ws://", StringComparison.OrdinalIgnoreCase);
+            return uri;
+        }
+
+        public NetworkCredential Credentials { get; set; }
+
+        public GetInfoResponse GetInfo()
+        {
+            return GetInfoAsync().GetAwaiter().GetResult();
+        }
+
+        public async Task<ChargeInvoice> GetInvoice(string invoiceId, CancellationToken cancellation = default(CancellationToken))
+        {
+            var request = CreateMessage(HttpMethod.Get, $"invoice/{invoiceId}");
+            var message = await _Client.SendAsync(request, cancellation);
+            if (message.StatusCode == HttpStatusCode.NotFound)
+                return null;
+            message.EnsureSuccessStatusCode();
+            var content = await message.Content.ReadAsStringAsync();
+            return JsonConvert.DeserializeObject<ChargeInvoice>(content);
+        }
+
+        public async Task<GetInfoResponse> GetInfoAsync(CancellationToken cancellation = default(CancellationToken))
+        {
+            var request = CreateMessage(HttpMethod.Get, "info");
+            var message = await _Client.SendAsync(request, cancellation);
+            message.EnsureSuccessStatusCode();
+            var content = await message.Content.ReadAsStringAsync();
+            return JsonConvert.DeserializeObject<GetInfoResponse>(content);
+        }
+
+        private HttpRequestMessage CreateMessage(HttpMethod method, string path)
+        {
+            var uri = GetFullUri(path);
+            var request = new HttpRequestMessage(method, uri);
+            request.Headers.Authorization = new AuthenticationHeaderValue("Basic", GetBase64Creds());
+            return request;
+        }
+
+        private string GetBase64Creds()
+        {
+            return Convert.ToBase64String(Encoding.ASCII.GetBytes($"{Credentials.UserName}:{Credentials.Password}"));
+        }
+
+        private Uri GetFullUri(string partialUrl)
+        {
+            var uri = _Uri.AbsoluteUri;
+            if (!uri.EndsWith("/", StringComparison.InvariantCultureIgnoreCase))
+                uri += "/";
+            return new Uri(uri + partialUrl);
+        }
+
+        async Task<LightningInvoice> ILightningInvoiceClient.GetInvoice(string invoiceId, CancellationToken cancellation)
+        {
+            var invoice = await GetInvoice(invoiceId, cancellation);
+            return ChargeClient.ToLightningInvoice(invoice);
+        }
+
+        async Task<ILightningListenInvoiceSession> ILightningInvoiceClient.Listen(CancellationToken cancellation)
+        {
+            return await Listen(cancellation);
+        }
+
+        internal static LightningInvoice ToLightningInvoice(ChargeInvoice invoice)
+        {
+            return new LightningInvoice()
+            {
+                Id = invoice.Id ?? invoice.Label,
+                Amount = invoice.MilliSatoshi,
+                BOLT11 = invoice.PaymentRequest,
+                PaidAt = invoice.PaidAt,
+                Status = invoice.Status
+            };
+        }
+
+        async Task<LightningInvoice> ILightningInvoiceClient.CreateInvoice(LightMoney amount, TimeSpan expiry, CancellationToken cancellation)
+        {
+            var invoice = await CreateInvoiceAsync(new CreateInvoiceRequest() { Amont = amount, Expiry = expiry });
+            return new LightningInvoice() { Id = invoice.Id, Amount = amount, BOLT11 = invoice.PayReq, Status = "unpaid" };
+        }
+
+        async Task<LightningNodeInformation> ILightningInvoiceClient.GetInfo(CancellationToken cancellation)
+        {
+            var info = await GetInfoAsync(cancellation);
+            var address = info.Address.Select(a => a.Address).FirstOrDefault();
+            var port = info.Port;
+            return new LightningNodeInformation()
+            {
+                NodeId = info.Id,
+                P2PPort = port,
+                Address = address,
+                BlockHeight = info.BlockHeight
+            };
+        }
+    }
+}

BTCPayServer/Payments/Lightning/Charge/ChargeSession.cs

@@ -0,0 +1,135 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.WebSockets;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using NBXplorer;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Payments.Lightning.Charge
+{
+    public class ChargeInvoice
+    {
+        public string Id { get; set; }
+
+        [JsonProperty("msatoshi")]
+        [JsonConverter(typeof(JsonConverters.LightMoneyJsonConverter))]
+        public LightMoney MilliSatoshi { get; set; }
+        [JsonProperty("paid_at")]
+        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+        public DateTimeOffset? PaidAt { get; set; }
+        [JsonProperty("expires_at")]
+        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+        public DateTimeOffset? ExpiresAt { get; set; }
+        public string Status { get; set; }
+
+        [JsonProperty("payreq")]
+        public string PaymentRequest { get; set; }
+        public string Label { get; set; }
+    }
+    public class ChargeSession : ILightningListenInvoiceSession
+    {
+        private ClientWebSocket socket;
+
+        const int ORIGINAL_BUFFER_SIZE = 1024 * 5;
+        const int MAX_BUFFER_SIZE = 1024 * 1024 * 5;
+        public ChargeSession(ClientWebSocket socket)
+        {
+            this.socket = socket;
+            var buffer = new byte[ORIGINAL_BUFFER_SIZE];
+            _Buffer = new ArraySegment<byte>(buffer, 0, buffer.Length);
+        }
+
+        ArraySegment<byte> _Buffer;
+        public async Task<ChargeInvoice> WaitInvoice(CancellationToken cancellation = default(CancellationToken))
+        {
+            var buffer = _Buffer;
+            var array = _Buffer.Array;
+            var originalSize = _Buffer.Array.Length;
+            var newSize = _Buffer.Array.Length;
+            while (true)
+            {
+                var message = await socket.ReceiveAsync(buffer, cancellation);
+                if (message.MessageType == WebSocketMessageType.Close)
+                {
+                    await CloseSocketAndThrow(WebSocketCloseStatus.NormalClosure, "Close message received from the peer", cancellation);
+                    break;
+                }
+                if (message.MessageType != WebSocketMessageType.Text)
+                {
+                    await CloseSocketAndThrow(WebSocketCloseStatus.InvalidMessageType, "Only Text is supported", cancellation);
+                    break;
+                }
+                if (message.EndOfMessage)
+                {
+                    buffer = new ArraySegment<byte>(array, 0, buffer.Offset + message.Count);
+                    try
+                    {
+                        var o = ParseMessage(buffer);
+                        if (newSize != originalSize)
+                        {
+                            Array.Resize(ref array, originalSize);
+                        }
+                        return o;
+                    }
+                    catch (Exception ex)
+                    {
+                        await CloseSocketAndThrow(WebSocketCloseStatus.InvalidPayloadData, $"Invalid payload: {ex.Message}", cancellation);
+                    }
+                }
+                else
+                {
+                    if (buffer.Count - message.Count <= 0)
+                    {
+                        newSize *= 2;
+                        if (newSize > MAX_BUFFER_SIZE)
+                            await CloseSocketAndThrow(WebSocketCloseStatus.MessageTooBig, "Message is too big", cancellation);
+                        Array.Resize(ref array, newSize);
+                        buffer = new ArraySegment<byte>(array, buffer.Offset, newSize - buffer.Offset);
+                    }
+
+                    buffer = buffer.Slice(message.Count, buffer.Count - message.Count);
+                }
+            }
+            throw new InvalidOperationException("Should never happen");
+        }
+
+        UTF8Encoding UTF8 = new UTF8Encoding(false, true);
+        private ChargeInvoice ParseMessage(ArraySegment<byte> buffer)
+        {
+            var str = UTF8.GetString(buffer.Array, 0, buffer.Count);
+            return JsonConvert.DeserializeObject<ChargeInvoice>(str, new JsonSerializerSettings());
+        }
+
+        private async Task CloseSocketAndThrow(WebSocketCloseStatus status, string description, CancellationToken cancellation)
+        {
+            var array = _Buffer.Array;
+            if (array.Length != ORIGINAL_BUFFER_SIZE)
+                Array.Resize(ref array, ORIGINAL_BUFFER_SIZE);
+            await socket.CloseSocket(status, description, cancellation);
+            throw new WebSocketException($"The socket has been closed ({status}: {description})");
+        }
+
+        public async void Dispose()
+        {
+            await this.socket.CloseSocket();
+        }
+
+        public async Task DisposeAsync()
+        {
+            await this.socket.CloseSocket();
+        }
+
+        async Task<LightningInvoice> ILightningListenInvoiceSession.WaitInvoice(CancellationToken token)
+        {
+            return ChargeClient.ToLightningInvoice(await WaitInvoice(token));
+        }
+
+        void IDisposable.Dispose()
+        {
+            Dispose();
+        }
+    }
+}

BTCPayServer/Payments/Lightning/Charge/CreateInvoiceRequest.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Payments.Lightning.Charge
+{
+    public class CreateInvoiceRequest
+    {
+        public LightMoney Amont { get; set; }
+        public TimeSpan Expiry { get; set; }
+    }
+}

BTCPayServer/Payments/Lightning/Charge/CreateInvoiceResponse.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Payments.Lightning.Charge
+{
+    public class CreateInvoiceResponse
+    {
+        public string PayReq { get; set; }
+        public string Id { get; set; }
+    }
+}

BTCPayServer/Payments/Lightning/Charge/GetInfoResponse.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Payments.Lightning.Charge
+{
+    //[{"type":"ipv4","address":"52.166.90.122","port":9735}]
+    public class GetInfoResponse
+    {
+        public class GetInfoAddress
+        {
+            public string Type { get; set; }
+            public string Address { get; set; }
+            public int Port { get; set; }
+        }
+        public string Id { get; set; }
+        public int Port { get; set; }
+        public GetInfoAddress[] Address { get; set; }
+        public string Version { get; set; }
+        public int BlockHeight { get; set; }
+        public string Network { get; set; }
+    }
+}

BTCPayServer/Payments/Lightning/ILightningInvoiceClient.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Payments.Lightning.Charge;
+
+namespace BTCPayServer.Payments.Lightning
+{
+    public class LightningInvoice
+    {
+        public string Id { get; set; }
+        public string Status { get; set; }
+        public string BOLT11 { get; set; }
+        public DateTimeOffset? PaidAt
+        {
+            get; set;
+        }
+        public LightMoney Amount { get; set; }
+    }
+
+    public class LightningNodeInformation
+    {
+        public string NodeId { get; set; }
+        public string Address { get; internal set; }
+        public int P2PPort { get; internal set; }
+        public int BlockHeight { get; set; }
+    }
+    public interface ILightningInvoiceClient
+    {
+        Task<LightningInvoice> GetInvoice(string invoiceId, CancellationToken cancellation = default(CancellationToken));
+        Task<LightningInvoice> CreateInvoice(LightMoney amount, TimeSpan expiry, CancellationToken cancellation = default(CancellationToken));
+        Task<ILightningListenInvoiceSession> Listen(CancellationToken cancellation = default(CancellationToken));
+        Task<LightningNodeInformation> GetInfo(CancellationToken cancellation = default(CancellationToken));
+    }
+
+    public interface ILightningListenInvoiceSession : IDisposable
+    {
+        Task<LightningInvoice> WaitInvoice(CancellationToken cancellation);
+    }
+}

BTCPayServer/Payments/Lightning/LightMoney.cs

@@ -3,8 +3,9 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
+using NBitcoin;
 
-namespace BTCPayServer.Eclair
+namespace BTCPayServer.Payments.Lightning
 {
     public enum LightMoneyUnit : ulong
     {
@@ -94,28 +95,31 @@ namespace BTCPayServer.Eclair
             return a;
         }
 
-        public LightMoney(int satoshis)
+        public LightMoney(int msatoshis)
         {
-            MilliSatoshi = satoshis;
+            MilliSatoshi = msatoshis;
         }
 
-        public LightMoney(uint satoshis)
+        public LightMoney(uint msatoshis)
         {
-            MilliSatoshi = satoshis;
+            MilliSatoshi = msatoshis;
+        }
+        public LightMoney(Money money)
+        {
+            MilliSatoshi = checked(money.Satoshi * 1000);
+        }
+        public LightMoney(long msatoshis)
+        {
+            MilliSatoshi = msatoshis;
         }
 
-        public LightMoney(long satoshis)
-        {
-            MilliSatoshi = satoshis;
-        }
-
-        public LightMoney(ulong satoshis)
+        public LightMoney(ulong msatoshis)
         {
             // overflow check. 
             // ulong.MaxValue is greater than long.MaxValue
             checked
             {
-                MilliSatoshi = (long)satoshis;
+                MilliSatoshi = (long)msatoshis;
             }
         }
 
@@ -171,7 +175,7 @@ namespace BTCPayServer.Eclair
             CheckMoneyUnit(unit, "unit");
             // overflow safe because (long / int) always fit in decimal 
             // decimal operations are checked by default
-            return (decimal)MilliSatoshi / (int)unit;
+            return (decimal)MilliSatoshi / (ulong)unit;
         }
         /// <summary>
         /// Convert Money to decimal (same as ToUnit)

BTCPayServer/Payments/Lightning/LightningClientFactory.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.Payments.Lightning.Charge;
+using BTCPayServer.Payments.Lightning.CLightning;
+
+namespace BTCPayServer.Payments.Lightning
+{
+    public class LightningClientFactory
+    {
+        public ILightningInvoiceClient CreateClient(LightningSupportedPaymentMethod supportedPaymentMethod, BTCPayNetwork network)
+        {
+            var uri = supportedPaymentMethod.GetLightningUrl();
+            if (uri.ConnectionType == LightningConnectionType.Charge)
+            {
+                return new ChargeClient(uri.ToUri(true), network.NBitcoinNetwork);
+            }
+            else if (uri.ConnectionType == LightningConnectionType.CLightning)
+            {
+                return new CLightningRPCClient(uri.ToUri(false), network.NBitcoinNetwork);
+            }
+            else
+                throw new NotSupportedException($"Unsupported connection string for lightning server ({uri.ConnectionType})");
+        }
+    }
+}

BTCPayServer/Payments/Lightning/LightningConnectionString.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Payments.Lightning
+{
+    public enum LightningConnectionType
+    {
+        Charge,
+        CLightning
+    }
+    public class LightningConnectionString
+    {
+        public static bool TryParse(string str, out LightningConnectionString connectionString)
+        {
+            return TryParse(str, out connectionString, out var error);
+        }
+        public static bool TryParse(string str, out LightningConnectionString connectionString, out string error)
+        {
+            if (str == null)
+                throw new ArgumentNullException(nameof(str));
+            if (str.StartsWith('/'))
+                str = "unix:" + str;
+            var result = new LightningConnectionString();
+            connectionString = null;
+            error = null;
+
+            Uri uri;
+            if (!System.Uri.TryCreate(str, UriKind.Absolute, out uri))
+            {
+                error = "Invalid URL";
+                return false;
+            }
+
+            var supportedDomains = new string[] { "unix", "tcp", "http", "https" };
+            if (!supportedDomains.Contains(uri.Scheme))
+            {
+                var protocols = String.Join(",", supportedDomains);
+                error = $"The url support the following protocols {protocols}";
+                return false;
+            }
+
+            if (uri.Scheme == "unix")
+            {
+                str = uri.AbsoluteUri.Substring("unix:".Length);
+                while (str.Length >= 1 && str[0] == '/')
+                {
+                    str = str.Substring(1);
+                }
+                uri = new Uri("unix://" + str, UriKind.Absolute);
+            }
+
+            if (uri.Scheme == "http" || uri.Scheme == "https")
+            {
+                var parts = uri.UserInfo.Split(':');
+                if (string.IsNullOrEmpty(uri.UserInfo) || parts.Length != 2)
+                {
+                    error = "The url is missing user and password";
+                    return false;
+                }
+                result.Username = parts[0];
+                result.Password = parts[1];
+            }
+            else if (!string.IsNullOrEmpty(uri.UserInfo))
+            {
+                error = "The url should not have user information";
+                return false;
+            }
+            result.BaseUri = new UriBuilder(uri) { UserName = "", Password = "" }.Uri;
+            connectionString = result;
+            return true;
+        }
+
+        public LightningConnectionString()
+        {
+
+        }
+
+        public string Username { get; set; }
+        public string Password { get; set; }
+        public Uri BaseUri { get; set; }
+
+        public LightningConnectionType ConnectionType
+        {
+            get
+            {
+                return BaseUri.Scheme == "http" || BaseUri.Scheme == "https" ? LightningConnectionType.Charge 
+                    : LightningConnectionType.CLightning;
+            }
+        }
+
+        public Uri ToUri(bool withCredentials)
+        {
+            if (withCredentials)
+            {
+                return new UriBuilder(BaseUri) { UserName = Username ?? "", Password = Password ?? "" }.Uri;
+            }
+            else
+            {
+                return BaseUri;
+            }
+        }
+
+        public override string ToString()
+        {
+            return ToUri(true).AbsoluteUri;
+        }
+    }
+}

BTCPayServer/Payments/Lightning/LightningLikePaymentData.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BTCPayServer.JsonConverters;
+using BTCPayServer.Payments.Lightning;
+using BTCPayServer.Services.Invoices;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Payments.Lightning
+{
+    public class LightningLikePaymentData : CryptoPaymentData
+    {
+        [JsonConverter(typeof(LightMoneyJsonConverter))]
+        public LightMoney Amount { get; set; }
+        public string BOLT11 { get; set; }
+        public string GetPaymentId()
+        {
+            return BOLT11;
+        }
+
+        public PaymentTypes GetPaymentType()
+        {
+            return PaymentTypes.LightningLike;
+        }
+
+        public string[] GetSearchTerms()
+        {
+            return new[] { BOLT11 };
+        }
+
+        public decimal GetValue()
+        {
+            return Amount.ToDecimal(LightMoneyUnit.BTC);
+        }
+
+        public bool PaymentCompleted(PaymentEntity entity, BTCPayNetwork network)
+        {
+            return true;
+        }
+
+        public bool PaymentConfirmed(PaymentEntity entity, SpeedPolicy speedPolicy, BTCPayNetwork network)
+        {
+            return true;
+        }
+    }
+}

BTCPayServer/Payments/Lightning/LightningLikePaymentHandler.cs

@@ -0,0 +1,141 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.HostedServices;
+using BTCPayServer.Payments.Lightning.Charge;
+using BTCPayServer.Payments.Lightning.CLightning;
+using BTCPayServer.Services.Invoices;
+
+namespace BTCPayServer.Payments.Lightning
+{
+    public class LightningLikePaymentHandler : PaymentMethodHandlerBase<LightningSupportedPaymentMethod>
+    {
+        NBXplorerDashboard _Dashboard;
+        LightningClientFactory _LightningClientFactory;
+        public LightningLikePaymentHandler(
+            LightningClientFactory lightningClientFactory,
+            NBXplorerDashboard dashboard)
+        {
+            _LightningClientFactory = lightningClientFactory;
+            _Dashboard = dashboard;
+        }
+        public override async Task<IPaymentMethodDetails> CreatePaymentMethodDetails(LightningSupportedPaymentMethod supportedPaymentMethod, PaymentMethod paymentMethod, BTCPayNetwork network)
+        {
+            var invoice = paymentMethod.ParentEntity;
+            var due = Extensions.RoundUp(invoice.ProductInformation.Price / paymentMethod.Rate, 8);
+            var client = _LightningClientFactory.CreateClient(supportedPaymentMethod, network);
+            var expiry = invoice.ExpirationTime - DateTimeOffset.UtcNow;
+            if (expiry < TimeSpan.Zero)
+                expiry = TimeSpan.FromSeconds(1);
+            var lightningInvoice = await client.CreateInvoice(new LightMoney(due, LightMoneyUnit.BTC), expiry);
+            return new LightningLikePaymentMethodDetails()
+            {
+                BOLT11 = lightningInvoice.BOLT11,
+                InvoiceId = lightningInvoice.Id
+            };
+        }
+
+        public async override Task<bool> IsAvailable(LightningSupportedPaymentMethod supportedPaymentMethod, BTCPayNetwork network)
+        {
+            try
+            {
+                await Test(supportedPaymentMethod, network);
+                return true;
+            }
+            catch { return false; }
+        }
+
+        /// <summary>
+        /// Used for testing
+        /// </summary>
+        public bool SkipP2PTest { get; set; }
+
+        public async Task<NodeInfo> Test(LightningSupportedPaymentMethod supportedPaymentMethod, BTCPayNetwork network)
+        {
+            if (!_Dashboard.IsFullySynched(network.CryptoCode, out var summary))
+                throw new Exception($"Full node not available");
+            
+            var cts = new CancellationTokenSource(5000);
+            var client = _LightningClientFactory.CreateClient(supportedPaymentMethod, network);
+            LightningNodeInformation info = null;
+            try
+            {
+                info = await client.GetInfo(cts.Token);
+            }
+            catch (OperationCanceledException) when (cts.IsCancellationRequested)
+            {
+                throw new Exception($"The lightning node did not replied in a timely maner");
+            }
+            catch (Exception ex)
+            {
+                throw new Exception($"Error while connecting to the API ({ex.Message})");
+            }
+
+            if(info.Address == null)
+            {
+                throw new Exception($"No lightning node public address has been configured");
+            }
+
+            var blocksGap = Math.Abs(info.BlockHeight - summary.Status.ChainHeight);
+            if (blocksGap > 10)
+            {
+                throw new Exception($"The lightning is not synched ({blocksGap} blocks)");
+            }
+
+            try
+            {
+                if(!SkipP2PTest)
+                    await TestConnection(info.Address, info.P2PPort, cts.Token);
+            }
+            catch (Exception ex)
+            {
+                throw new Exception($"Error while connecting to the lightning node via {info.Address}:{info.P2PPort} ({ex.Message})");
+            }
+            return new NodeInfo(info.NodeId, info.Address, info.P2PPort);
+        }
+
+        private async Task<bool> TestConnection(string addressStr, int port, CancellationToken cancellation)
+        {
+            IPAddress address = null;
+            try
+            {
+                address = IPAddress.Parse(addressStr);
+            }
+            catch
+            {
+                try
+                {
+                    address = (await Dns.GetHostAddressesAsync(addressStr)).FirstOrDefault();
+                }
+                catch { }
+            }
+
+            if (address == null)
+                throw new Exception($"DNS did not resolved {addressStr}");
+
+            using (var tcp = new Socket(address.AddressFamily, SocketType.Stream, ProtocolType.Tcp))
+            {
+                try
+                {
+                    await WithTimeout(tcp.ConnectAsync(new IPEndPoint(address, port)), cancellation);
+                }
+                catch { return false; }
+            }
+            return true;
+        }
+
+        static Task WithTimeout(Task task, CancellationToken token)
+        {
+            TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>();
+            var registration = token.Register(() => { try { tcs.TrySetResult(true); } catch { } });
+#pragma warning disable CA2008 // Do not create tasks without passing a TaskScheduler
+            var timeoutTask = tcs.Task;
+#pragma warning restore CA2008 // Do not create tasks without passing a TaskScheduler
+            return Task.WhenAny(task, timeoutTask).Unwrap().ContinueWith(t => registration.Dispose(), TaskScheduler.Default);
+        }
+    }
+}

BTCPayServer/Payments/Lightning/LightningLikePaymentMethodDetails.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Payments.Lightning
+{
+    public class LightningLikePaymentMethodDetails : IPaymentMethodDetails
+    {
+        public string BOLT11 { get; set; }
+        public string InvoiceId { get; set; }
+
+        public string GetPaymentDestination()
+        {
+            return BOLT11;
+        }
+
+        public PaymentTypes GetPaymentType()
+        {
+            return PaymentTypes.LightningLike;
+        }
+
+        public decimal GetTxFee()
+        {
+            return 0.0m;
+        }
+
+        public void SetNoTxFee()
+        {
+        }
+
+        public void SetPaymentDestination(string newPaymentDestination)
+        {
+            BOLT11 = newPaymentDestination;
+        }
+    }
+}

BTCPayServer/Payments/Lightning/LightningListener.cs

@@ -0,0 +1,268 @@
+using System;
+using Microsoft.Extensions.Logging;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Events;
+using BTCPayServer.Logging;
+using BTCPayServer.Services.Invoices;
+using Microsoft.Extensions.Hosting;
+using NBXplorer;
+
+namespace BTCPayServer.Payments.Lightning
+{
+    public class LightningListener : IHostedService
+    {
+        class ListenedInvoice
+        {
+            public LightningLikePaymentMethodDetails PaymentMethodDetails { get; set; }
+            public LightningSupportedPaymentMethod SupportedPaymentMethod { get; set; }
+            public PaymentMethod PaymentMethod { get; set; }
+            public string Uri { get; internal set; }
+            public BTCPayNetwork Network { get; internal set; }
+            public string InvoiceId { get; internal set; }
+        }
+
+        EventAggregator _Aggregator;
+        InvoiceRepository _InvoiceRepository;
+        BTCPayNetworkProvider _NetworkProvider;
+        LightningClientFactory _LightningClientFactory;
+        public LightningListener(EventAggregator aggregator,
+                              InvoiceRepository invoiceRepository,
+                              LightningClientFactory lightningClientFactory,
+                              BTCPayNetworkProvider networkProvider)
+        {
+            _Aggregator = aggregator;
+            _InvoiceRepository = invoiceRepository;
+            _NetworkProvider = networkProvider;
+            _LightningClientFactory = lightningClientFactory;
+        }
+
+        CompositeDisposable leases = new CompositeDisposable();
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            leases.Add(_Aggregator.Subscribe<Events.InvoiceEvent>(async inv =>
+            {
+                if (inv.Name == "invoice_created")
+                {
+                    await EnsureListening(inv.InvoiceId, false);
+                }
+            }));
+
+            _ListenPoller = new Timer(async s =>
+            {
+                await Task.WhenAll((await _InvoiceRepository.GetPendingInvoices())
+                .Select(async invoiceId => await EnsureListening(invoiceId, true))
+                .ToArray());
+            }, null, 0, (int)PollInterval.TotalMilliseconds);
+            leases.Add(_ListenPoller);
+            return Task.CompletedTask;
+        }
+
+        private async Task EnsureListening(string invoiceId, bool poll)
+        {
+            if (Listening(invoiceId))
+                return;
+            var invoice = await _InvoiceRepository.GetInvoice(null, invoiceId);
+            foreach (var paymentMethod in invoice.GetPaymentMethods(_NetworkProvider)
+                                                          .Where(c => c.GetId().PaymentType == PaymentTypes.LightningLike))
+            {
+                var lightningMethod = paymentMethod.GetPaymentMethodDetails() as LightningLikePaymentMethodDetails;
+                if (lightningMethod == null)
+                    continue;
+                var lightningSupportedMethod = invoice.GetSupportedPaymentMethod<LightningSupportedPaymentMethod>(_NetworkProvider)
+                                          .FirstOrDefault(c => c.CryptoCode == paymentMethod.GetId().CryptoCode);
+                if (lightningSupportedMethod == null)
+                    continue;
+                var network = _NetworkProvider.GetNetwork(paymentMethod.GetId().CryptoCode);
+
+                var listenedInvoice = new ListenedInvoice()
+                {
+                    Uri = lightningSupportedMethod.GetLightningUrl().BaseUri.AbsoluteUri,
+                    PaymentMethodDetails = lightningMethod,
+                    SupportedPaymentMethod = lightningSupportedMethod,
+                    PaymentMethod = paymentMethod,
+                    Network = network,
+                    InvoiceId = invoice.Id
+                };
+
+                if (poll)
+                {
+                    var charge = _LightningClientFactory.CreateClient(lightningSupportedMethod, network);
+                    var chargeInvoice = await charge.GetInvoice(lightningMethod.InvoiceId);
+                    if (chargeInvoice == null)
+                        continue;
+                    if (chargeInvoice.Status == "paid")
+                        await AddPayment(network, chargeInvoice, listenedInvoice);
+                    if (chargeInvoice.Status == "paid" || chargeInvoice.Status == "expired")
+                        continue;
+                }
+
+                StartListening(listenedInvoice);
+            }
+        }
+
+        TimeSpan _PollInterval = TimeSpan.FromMinutes(1.0);
+        public TimeSpan PollInterval
+        {
+            get
+            {
+                return _PollInterval;
+            }
+            set
+            {
+                _PollInterval = value;
+                if (_ListenPoller != null)
+                {
+                    _ListenPoller.Change(0, (int)value.TotalMilliseconds);
+                }
+            }
+        }
+
+        CancellationTokenSource _Cts = new CancellationTokenSource();
+        private async Task Listen(LightningSupportedPaymentMethod supportedPaymentMethod, BTCPayNetwork network)
+        {
+            try
+            {
+                Logs.PayServer.LogInformation($"{supportedPaymentMethod.CryptoCode} (Lightning): Start listening {supportedPaymentMethod.GetLightningUrl().BaseUri}");
+                var charge = _LightningClientFactory.CreateClient(supportedPaymentMethod, network);
+                var session = await charge.Listen(_Cts.Token);
+                while (true)
+                {
+                    var notification = await session.WaitInvoice(_Cts.Token);
+                    ListenedInvoice listenedInvoice = GetListenedInvoice(notification.Id);
+                    if (listenedInvoice == null)
+                        continue;
+                    if (notification.Id == listenedInvoice.PaymentMethodDetails.InvoiceId &&
+                       notification.BOLT11 == listenedInvoice.PaymentMethodDetails.BOLT11)
+                    {
+                        if (notification.Status == "paid" && notification.PaidAt.HasValue)
+                        {
+                            await AddPayment(network, notification, listenedInvoice);
+                            if (DoneListening(listenedInvoice))
+                                break;
+                        }
+                        if (notification.Status == "expired")
+                        {
+                            if (DoneListening(listenedInvoice))
+                                break;
+                        }
+                    }
+                }
+            }
+            catch when (_Cts.IsCancellationRequested)
+            {
+            }
+            catch (Exception ex)
+            {
+                Logs.PayServer.LogError(ex, $"{supportedPaymentMethod.CryptoCode} (Lightning): Error while contacting {supportedPaymentMethod.GetLightningUrl().BaseUri}");
+                DoneListening(supportedPaymentMethod.GetLightningUrl());
+            }
+            Logs.PayServer.LogInformation($"{supportedPaymentMethod.CryptoCode} (Lightning): Stop listening {supportedPaymentMethod.GetLightningUrl().BaseUri}");
+        }
+
+        private async Task AddPayment(BTCPayNetwork network, LightningInvoice notification, ListenedInvoice listenedInvoice)
+        {
+            var payment = await _InvoiceRepository.AddPayment(listenedInvoice.InvoiceId, notification.PaidAt.Value, new LightningLikePaymentData()
+            {
+                BOLT11 = notification.BOLT11,
+                Amount = notification.Amount
+            }, network.CryptoCode, accounted: true);
+            if(payment != null)
+                _Aggregator.Publish(new InvoiceEvent(listenedInvoice.InvoiceId, 1002, "invoice_receivedPayment"));
+        }
+
+        List<Task> _ListeningLightning = new List<Task>();
+        MultiValueDictionary<string, ListenedInvoice> _ListenedInvoiceByLightningUrl = new MultiValueDictionary<string, ListenedInvoice>();
+        Dictionary<string, ListenedInvoice> _ListenedInvoiceByChargeInvoiceId = new Dictionary<string, ListenedInvoice>();
+        HashSet<string> _InvoiceIds = new HashSet<string>();
+        private Timer _ListenPoller;
+
+        /// <summary>
+        /// Stop listening an invoice
+        /// </summary>
+        /// <param name="listenedInvoice">The invoice to stop listening</param>
+        /// <returns>true if still need to listen the lightning instance</returns>
+        bool DoneListening(ListenedInvoice listenedInvoice)
+        {
+            lock (_ListenedInvoiceByLightningUrl)
+            {
+                _ListenedInvoiceByChargeInvoiceId.Remove(listenedInvoice.PaymentMethodDetails.InvoiceId);
+                _ListenedInvoiceByLightningUrl.Remove(listenedInvoice.Uri, listenedInvoice);
+                _InvoiceIds.Remove(listenedInvoice.InvoiceId);
+                if (!_ListenedInvoiceByLightningUrl.ContainsKey(listenedInvoice.Uri))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Stop listening all invoices on this server
+        /// </summary>
+        /// <param name="uri"></param>
+        private void DoneListening(LightningConnectionString connectionString)
+        {
+            var uri = connectionString.BaseUri;
+            lock (_ListenedInvoiceByChargeInvoiceId)
+            {
+                foreach (var listenedInvoice in _ListenedInvoiceByLightningUrl[uri.AbsoluteUri])
+                {
+                    _ListenedInvoiceByChargeInvoiceId.Remove(listenedInvoice.PaymentMethodDetails.InvoiceId);
+                    _InvoiceIds.Remove(listenedInvoice.InvoiceId);
+                }
+                _ListenedInvoiceByLightningUrl.Remove(uri.AbsoluteUri);
+            }
+        }
+
+        bool Listening(string invoiceId)
+        {
+            lock (_ListenedInvoiceByLightningUrl)
+            {
+                return _InvoiceIds.Contains(invoiceId);
+            }
+        }
+
+        private ListenedInvoice GetListenedInvoice(string chargeInvoiceId)
+        {
+            ListenedInvoice listenedInvoice = null;
+            lock (_ListenedInvoiceByLightningUrl)
+            {
+                _ListenedInvoiceByChargeInvoiceId.TryGetValue(chargeInvoiceId, out listenedInvoice);
+            }
+            return listenedInvoice;
+        }
+
+        bool StartListening(ListenedInvoice listenedInvoice)
+        {
+            lock (_ListenedInvoiceByLightningUrl)
+            {
+                if (_InvoiceIds.Contains(listenedInvoice.InvoiceId))
+                    return false;
+                if (!_ListenedInvoiceByLightningUrl.ContainsKey(listenedInvoice.Uri))
+                {
+                    var listen = Listen(listenedInvoice.SupportedPaymentMethod, listenedInvoice.Network);
+                    _ListeningLightning.Add(listen);
+                }
+                _ListenedInvoiceByLightningUrl.Add(listenedInvoice.Uri, listenedInvoice);
+                _ListenedInvoiceByChargeInvoiceId.Add(listenedInvoice.PaymentMethodDetails.InvoiceId, listenedInvoice);
+                _InvoiceIds.Add(listenedInvoice.InvoiceId);
+            }
+            return true;
+        }
+
+        public async Task StopAsync(CancellationToken cancellationToken)
+        {
+            leases.Dispose();
+            _Cts.Cancel();
+            Task[] listening = null;
+            lock (_ListenedInvoiceByLightningUrl)
+            {
+                listening = _ListeningLightning.ToArray();
+            }
+            await Task.WhenAll(listening);
+        }
+    }
+}

BTCPayServer/Payments/Lightning/LightningSupportedPaymentMethod.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Payments.Lightning
+{
+    public class LightningSupportedPaymentMethod : ISupportedPaymentMethod
+    {
+        public string CryptoCode { get; set; }
+        [Obsolete("Use Get/SetLightningUrl")]
+        public string LightningChargeUrl { get; set; }
+
+        public LightningConnectionString GetLightningUrl()
+        {
+#pragma warning disable CS0618 // Type or member is obsolete
+            var fullUri = new UriBuilder(LightningChargeUrl) { UserName = Username, Password = Password }.Uri.AbsoluteUri;
+            if(!LightningConnectionString.TryParse(fullUri, out var connectionString, out var error))
+            {
+                throw new FormatException(error);
+            }
+            return connectionString;
+#pragma warning restore CS0618 // Type or member is obsolete
+        }
+
+        public void SetLightningUrl(LightningConnectionString connectionString)
+        {
+            if (connectionString == null)
+                throw new ArgumentNullException(nameof(connectionString));
+
+#pragma warning disable CS0618 // Type or member is obsolete
+            Username = connectionString.Username;
+            Password = connectionString.Password;
+            LightningChargeUrl = connectionString.BaseUri.AbsoluteUri;
+#pragma warning restore CS0618 // Type or member is obsolete
+        }
+
+        [Obsolete("Use Get/SetLightningUrl")]
+        public string Username { get; set; }
+        [Obsolete("Use Get/SetLightningUrl")]
+        public string Password { get; set; }
+        public PaymentMethodId PaymentId => new PaymentMethodId(CryptoCode, PaymentTypes.LightningLike);
+    }
+}

BTCPayServer/Payments/PaymentMethodExtensions.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Payments
+{
+    public class PaymentMethodExtensions
+    {
+        public static ISupportedPaymentMethod Deserialize(PaymentMethodId paymentMethodId, JToken value, BTCPayNetwork network)
+        {
+            // Legacy
+            if (paymentMethodId.PaymentType == PaymentTypes.BTCLike)
+            {
+                return BTCPayServer.DerivationStrategy.Parse(((JValue)value).Value<string>(), network);
+            }
+            //////////
+            else if (paymentMethodId.PaymentType == PaymentTypes.LightningLike)
+            {
+                return JsonConvert.DeserializeObject<Payments.Lightning.LightningSupportedPaymentMethod>(value.ToString());
+            }
+            throw new NotSupportedException();
+        }
+
+        public static IPaymentMethodDetails DeserializePaymentMethodDetails(PaymentMethodId paymentMethodId, JObject jobj)
+        {
+            if(paymentMethodId.PaymentType == PaymentTypes.BTCLike)
+            {
+                return JsonConvert.DeserializeObject<Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod>(jobj.ToString());
+            }
+            if (paymentMethodId.PaymentType == PaymentTypes.LightningLike)
+            {
+                return JsonConvert.DeserializeObject<Payments.Lightning.LightningLikePaymentMethodDetails>(jobj.ToString());
+            }
+            throw new NotSupportedException(paymentMethodId.PaymentType.ToString());
+        }
+
+
+        public static JToken Serialize(ISupportedPaymentMethod factory)
+        {
+            // Legacy
+            if (factory.PaymentId.PaymentType == PaymentTypes.BTCLike)
+            {
+                return new JValue(((DerivationStrategy)factory).DerivationStrategyBase.ToString());
+            }
+            //////////////
+            else
+            {
+                var str = JsonConvert.SerializeObject(factory);
+                return JObject.Parse(str);
+            }
+            throw new NotSupportedException();
+        }
+
+    }
+}

BTCPayServer/Payments/PaymentMethodId.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Payments
+{
+
+    /// <summary>
+    /// A value object which represent a crypto currency with his payment type (ie, onchain or offchain)
+    /// </summary>
+    public class PaymentMethodId
+    {
+        public PaymentMethodId(string cryptoCode, PaymentTypes paymentType)
+        {
+            if (cryptoCode == null)
+                throw new ArgumentNullException(nameof(cryptoCode));
+            PaymentType = paymentType;
+            CryptoCode = cryptoCode;
+        }
+
+        [Obsolete("Should only be used for legacy stuff")]
+        public bool IsBTCOnChain
+        {
+            get
+            {
+                return CryptoCode == "BTC" && PaymentType == PaymentTypes.BTCLike;
+            }
+        }
+
+        public string CryptoCode { get; private set; }
+        public PaymentTypes PaymentType { get; private set; }
+
+
+        public override bool Equals(object obj)
+        {
+            PaymentMethodId item = obj as PaymentMethodId;
+            if (item == null)
+                return false;
+            return ToString().Equals(item.ToString(), StringComparison.InvariantCulture);
+        }
+        public static bool operator ==(PaymentMethodId a, PaymentMethodId b)
+        {
+            if (System.Object.ReferenceEquals(a, b))
+                return true;
+            if (((object)a == null) || ((object)b == null))
+                return false;
+            return a.ToString() == b.ToString();
+        }
+
+        public static bool operator !=(PaymentMethodId a, PaymentMethodId b)
+        {
+            return !(a == b);
+        }
+
+        public override int GetHashCode()
+        {
+#pragma warning disable CA1307 // Specify StringComparison
+            return ToString().GetHashCode();
+#pragma warning restore CA1307 // Specify StringComparison
+        }
+
+        public override string ToString()
+        {
+            if (PaymentType == PaymentTypes.BTCLike)
+                return CryptoCode;
+            return CryptoCode + "_" + PaymentType.ToString();
+        }
+
+        public static PaymentMethodId Parse(string str)
+        {
+            var parts = str.Split('_');
+            return new PaymentMethodId(parts[0], parts.Length == 1 ? PaymentTypes.BTCLike : Enum.Parse<PaymentTypes>(parts[1]));
+        }
+    }
+}

BTCPayServer/Payments/PaymentTypes.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Payments
+{
+    /// <summary>
+    /// The different ways to pay an invoice
+    /// </summary>
+    public enum PaymentTypes
+    {
+        /// <summary>
+        /// On-Chain UTXO based, bitcoin compatible
+        /// </summary>
+        BTCLike,
+        /// <summary>
+        /// Lightning payment
+        /// </summary>
+        LightningLike
+    }
+}

BTCPayServer/Properties/launchSettings.json

@@ -1,17 +1,5 @@
 {
-  "iisSettings": {
-    "windowsAuthentication": false,
-    "anonymousAuthentication": true,
-    "iisExpress": {
-      "applicationUrl": "http://localhost:14139/",
-      "sslPort": 0
-    }
-  },
   "profiles": {
-    "Default": {
-      "commandName": "Project",
-      "commandLineArgs": "--network testnet --chains ltc --ltcexplorerurl http://127.0.0.1:2727/"
-    },
     "Docker-Regtest": {
       "commandName": "Project",
       "launchBrowser": true,
@@ -21,9 +9,11 @@
         "BTCPAY_BTCEXPLORERURL": "http://127.0.0.1:32838/",
         "ASPNETCORE_ENVIRONMENT": "Development",
         "BTCPAY_CHAINS": "btc,ltc",
-        "BTCPAY_POSTGRES": "User ID=postgres;Host=127.0.0.1;Port=39372;Database=btcpayserver"
+        "BTCPAY_BTCLIGHTNING": "http://api-token:foiewnccewuify@127.0.0.1:54938/",
+        "BTCPAY_POSTGRES": "User ID=postgres;Host=127.0.0.1;Port=39372;Database=btcpayserver",
+        "BTCPAY_BUNDLEJSCSS": "false"
       },
-      "applicationUrl": "http://localhost:14142/"
+      "applicationUrl": "http://127.0.0.1:14142/"
     }
   }
-}
+}

BTCPayServer/Services/BTCPayServerEnvironment.cs

@@ -35,6 +35,14 @@ namespace BTCPayServer.Services
         {
             get; set;
         }
+
+        public bool IsDevelopping
+        {
+            get
+            {
+                return ChainType == ChainType.Regtest && Environment.IsDevelopment();
+            }
+        }
         public override string ToString()
         {
             StringBuilder txt = new StringBuilder();

BTCPayServer/Services/HardwareWalletService.cs

@@ -8,6 +8,7 @@ using BTCPayServer.Services.Wallets;
 using LedgerWallet;
 using NBitcoin;
 using NBXplorer.DerivationStrategy;
+using Newtonsoft.Json;
 
 namespace BTCPayServer.Services
 {
@@ -76,18 +77,19 @@ namespace BTCPayServer.Services
             return new LedgerTestResult() { Success = true };
         }
 
-        public async Task<GetXPubResult> GetExtPubKey(BTCPayNetwork network)
+        public async Task<GetXPubResult> GetExtPubKey(BTCPayNetwork network, int account)
         {
             if (network == null)
                 throw new ArgumentNullException(nameof(network));
 
-            var pubkey = await GetExtPubKey(_Ledger, network, new KeyPath("49'").Derive(network.CoinType).Derive(0, true), false);
+            var path = new KeyPath("49'").Derive(network.CoinType).Derive(account, true);
+            var pubkey = await GetExtPubKey(_Ledger, network, path, false);
             var derivation = new DerivationStrategyFactory(network.NBitcoinNetwork).CreateDirectDerivationStrategy(pubkey, new DerivationStrategyOptions()
             {
                 P2SH = true,
                 Legacy = false
             });
-            return new GetXPubResult() { ExtPubKey = derivation.ToString() };
+            return new GetXPubResult() { ExtPubKey = derivation.ToString(), KeyPath = path };
         }
 
         private static async Task<BitcoinExtPubKey> GetExtPubKey(LedgerClient ledger, BTCPayNetwork network, KeyPath account, bool onlyChaincode)
@@ -152,7 +154,8 @@ namespace BTCPayServer.Services
                                                              (IDestination destination, Money amount, bool substractFees)[] send, 
                                                              FeeRate feeRate, 
                                                              IDestination changeAddress,
-                                                             KeyPath changeKeyPath)
+                                                             KeyPath changeKeyPath,
+                                                             FeeRate minTxRelayFee)
         {
             if (strategy == null)
                 throw new ArgumentNullException(nameof(strategy));
@@ -185,6 +188,7 @@ namespace BTCPayServer.Services
             }
 
             TransactionBuilder builder = new TransactionBuilder();
+            builder.StandardTransactionPolicy.MinRelayTxFee = minTxRelayFee;
             builder.AddCoins(coins.Select(c=>c.Coin).ToArray());
 
             foreach (var element in send)
@@ -229,5 +233,8 @@ namespace BTCPayServer.Services
     public class GetXPubResult
     {
         public string ExtPubKey { get; set; }
+        [JsonConverter(typeof(NBitcoin.JsonConverters.KeyPathJsonConverter))]
+        public KeyPath KeyPath { get; set; }
+        public int CoinType { get; internal set; }
     }
 }

BTCPayServer/Services/Invoices/InvoiceEntity.cs

@@ -11,6 +11,7 @@ using BTCPayServer.Data;
 using NBXplorer.Models;
 using NBXplorer;
 using NBXplorer.DerivationStrategy;
+using BTCPayServer.Payments;
 
 namespace BTCPayServer.Services.Invoices
 {
@@ -121,7 +122,7 @@ namespace BTCPayServer.Services.Invoices
         {
             get; set;
         }
-        [Obsolete("Use GetCryptoData(network).Rate instead")]
+        [Obsolete("Use GetPaymentMethod(network) instead")]
         public decimal Rate
         {
             get; set;
@@ -135,7 +136,7 @@ namespace BTCPayServer.Services.Invoices
             get; set;
         }
 
-        [Obsolete("Use GetCryptoData(network).DepositAddress instead")]
+        [Obsolete("Use GetPaymentMethod(network).GetPaymentMethodDetails().GetDestinationAddress() instead")]
         public string DepositAddress
         {
             get; set;
@@ -161,36 +162,24 @@ namespace BTCPayServer.Services.Invoices
             set;
         }
 
-        [Obsolete("Use GetDerivationStrategies instead")]
+        [Obsolete("Use GetPaymentMethodFactories() instead")]
         public string DerivationStrategies
         {
             get;
             set;
         }
-
-        public DerivationStrategyBase GetDerivationStrategy(BTCPayNetwork network)
+        public IEnumerable<T> GetSupportedPaymentMethod<T>(PaymentMethodId paymentMethodId, BTCPayNetworkProvider networks) where T : ISupportedPaymentMethod
         {
-#pragma warning disable CS0618
-            JObject strategies = JObject.Parse(DerivationStrategies);
-#pragma warning restore CS0618
-            foreach (var strat in strategies.Properties())
-            {
-                if (strat.Name == network.CryptoCode)
-                {
-                    return BTCPayServer.DerivationStrategy.Parse(strat.Value.Value<string>(), network).DerivationStrategyBase;
-                }
-            }
-
-#pragma warning disable CS0618
-            if (network.IsBTC && !string.IsNullOrEmpty(DerivationStrategy))
-            {
-                return BTCPayServer.DerivationStrategy.Parse(DerivationStrategy, network).DerivationStrategyBase;
-            }
-            return null;
-#pragma warning restore CS0618
+            return
+                GetSupportedPaymentMethod(networks)
+                .Where(p => paymentMethodId == null || p.PaymentId == paymentMethodId)
+                .OfType<T>();
         }
-
-        public IEnumerable<DerivationStrategy> GetDerivationStrategies(BTCPayNetworkProvider networks)
+        public IEnumerable<T> GetSupportedPaymentMethod<T>(BTCPayNetworkProvider networks) where T : ISupportedPaymentMethod
+        {
+            return GetSupportedPaymentMethod<T>(null, networks);
+        }
+        public IEnumerable<ISupportedPaymentMethod> GetSupportedPaymentMethod(BTCPayNetworkProvider networks)
         {
 #pragma warning disable CS0618
             bool btcReturned = false;
@@ -199,12 +188,13 @@ namespace BTCPayServer.Services.Invoices
                 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)
+                        if (network == networks.BTC && paymentMethodId.PaymentType == PaymentTypes.BTCLike)
                             btcReturned = true;
-                        yield return BTCPayServer.DerivationStrategy.Parse(strat.Value.Value<string>(), network);
+                        yield return PaymentMethodExtensions.Deserialize(paymentMethodId, strat.Value, network);
                     }
                 }
             }
@@ -219,15 +209,15 @@ namespace BTCPayServer.Services.Invoices
 #pragma warning restore CS0618
         }
 
-        internal void SetDerivationStrategies(IEnumerable<DerivationStrategy> derivationStrategies)
+        internal void SetSupportedPaymentMethods(IEnumerable<ISupportedPaymentMethod> derivationStrategies)
         {
             JObject obj = new JObject();
             foreach (var strat in derivationStrategies)
             {
-                obj.Add(strat.Network.CryptoCode, new JValue(strat.DerivationStrategyBase.ToString()));
+                obj.Add(strat.PaymentId.ToString(), PaymentMethodExtensions.Serialize(strat));
 #pragma warning disable CS0618
-                if (strat.Network.IsBTC)
-                    DerivationStrategy = strat.DerivationStrategyBase.ToString();
+                if (strat.PaymentId.IsBTCOnChain)
+                    DerivationStrategy = ((JValue)PaymentMethodExtensions.Serialize(strat)).Value<string>();
             }
             DerivationStrategies = JsonConvert.SerializeObject(obj);
 #pragma warning restore CS0618
@@ -279,7 +269,7 @@ namespace BTCPayServer.Services.Invoices
             set;
         }
 
-        [Obsolete("Use GetCryptoData(network).TxFee instead")]
+        [Obsolete("Use GetPaymentMethod(network).GetTxFee() instead")]
         public Money TxFee
         {
             get;
@@ -301,8 +291,9 @@ namespace BTCPayServer.Services.Invoices
             set;
         }
 
-        [Obsolete("Use Set/GetCryptoData() instead")]
-        public JObject CryptoData { get; set; }
+        [Obsolete("Use Set/GetPaymentMethod() instead")]
+        [JsonProperty(PropertyName = "cryptoData")]
+        public JObject PaymentMethod { get; set; }
 
         [JsonProperty(DefaultValueHandling = DefaultValueHandling.Populate)]
         public DateTimeOffset MonitoringExpiration
@@ -347,11 +338,12 @@ namespace BTCPayServer.Services.Invoices
             };
 
             dto.CryptoInfo = new List<NBitpayClient.InvoiceCryptoInfo>();
-            foreach (var info in this.GetCryptoData(networkProvider, true).Values)
+            foreach (var info in this.GetPaymentMethods(networkProvider, true))
             {
                 var accounting = info.Calculate();
                 var cryptoInfo = new NBitpayClient.InvoiceCryptoInfo();
-                cryptoInfo.CryptoCode = info.CryptoCode;
+                cryptoInfo.CryptoCode = info.GetId().CryptoCode;
+                cryptoInfo.PaymentType = info.GetId().PaymentType.ToString();
                 cryptoInfo.Rate = info.Rate;
                 cryptoInfo.Price = Money.Coins(ProductInformation.Price / cryptoInfo.Rate).ToString();
 
@@ -362,7 +354,7 @@ namespace BTCPayServer.Services.Invoices
                 cryptoInfo.TxCount = accounting.TxCount;
                 cryptoInfo.CryptoPaid = accounting.CryptoPaid.ToString();
 
-                cryptoInfo.Address = info.DepositAddress;
+                cryptoInfo.Address = info.GetPaymentMethodDetails()?.GetPaymentDestination();
                 cryptoInfo.ExRates = new Dictionary<string, double>
                 {
                     { ProductInformation.Currency, (double)cryptoInfo.Rate }
@@ -373,13 +365,23 @@ namespace BTCPayServer.Services.Invoices
                 cryptoInfo.Url = ServerUrl.WithTrailingSlash() + $"invoice{cryptoSuffix}?id=" + Id;
 
 
-                cryptoInfo.PaymentUrls = new NBitpayClient.InvoicePaymentUrls()
+                if (info.GetId().PaymentType == PaymentTypes.BTCLike)
                 {
-                    BIP72 = $"{scheme}:{cryptoInfo.Address}?amount={cryptoInfo.Due}&r={ServerUrl.WithTrailingSlash() + ($"i/{Id}{cryptoSuffix}")}",
-                    BIP72b = $"{scheme}:?r={ServerUrl.WithTrailingSlash() + ($"i/{Id}{cryptoSuffix}")}",
-                    BIP73 = ServerUrl.WithTrailingSlash() + ($"i/{Id}{cryptoSuffix}"),
-                    BIP21 = $"{scheme}:{cryptoInfo.Address}?amount={cryptoInfo.Due}",
-                };
+                    cryptoInfo.PaymentUrls = new NBitpayClient.InvoicePaymentUrls()
+                    {
+                        BIP72 = $"{scheme}:{cryptoInfo.Address}?amount={cryptoInfo.Due}&r={ServerUrl.WithTrailingSlash() + ($"i/{Id}{cryptoSuffix}")}",
+                        BIP72b = $"{scheme}:?r={ServerUrl.WithTrailingSlash() + ($"i/{Id}{cryptoSuffix}")}",
+                        BIP73 = ServerUrl.WithTrailingSlash() + ($"i/{Id}{cryptoSuffix}"),
+                        BIP21 = $"{scheme}:{cryptoInfo.Address}?amount={cryptoInfo.Due}",
+                    };
+                }
+                if (info.GetId().PaymentType == PaymentTypes.LightningLike)
+                {
+                    cryptoInfo.PaymentUrls = new NBitpayClient.InvoicePaymentUrls()
+                    {
+                        BOLT11 = $"lightning:{cryptoInfo.Address}"
+                    };
+                }
 #pragma warning disable CS0618
                 if (info.CryptoCode == "BTC")
                 {
@@ -413,48 +415,50 @@ namespace BTCPayServer.Services.Invoices
             JsonConvert.PopulateObject(str, dest);
         }
 
-        internal bool Support(BTCPayNetwork network)
+        internal bool Support(PaymentMethodId paymentMethodId)
         {
-            var rates = GetCryptoData(null);
-            return rates.TryGetValue(network.CryptoCode, out var data);
+            var rates = GetPaymentMethods(null);
+            return rates.TryGet(paymentMethodId) != null;
         }
 
-        public CryptoData GetCryptoData(string cryptoCode, BTCPayNetworkProvider networkProvider, bool alwaysIncludeBTC = false)
+        public PaymentMethod GetPaymentMethod(PaymentMethodId paymentMethodId, BTCPayNetworkProvider networkProvider)
         {
-            GetCryptoData(networkProvider, alwaysIncludeBTC).TryGetValue(cryptoCode, out var data);
+            GetPaymentMethods(networkProvider).TryGetValue(paymentMethodId, out var data);
             return data;
         }
-
-        public CryptoData GetCryptoData(BTCPayNetwork network, BTCPayNetworkProvider networkProvider)
+        public PaymentMethod GetPaymentMethod(BTCPayNetwork network, PaymentTypes paymentType, BTCPayNetworkProvider networkProvider)
         {
-            GetCryptoData(networkProvider).TryGetValue(network.CryptoCode, out var data);
-            return data;
+            return GetPaymentMethod(new PaymentMethodId(network.CryptoCode, paymentType), networkProvider);
         }
 
-        public Dictionary<string, CryptoData> GetCryptoData(BTCPayNetworkProvider networkProvider, bool alwaysIncludeBTC = false)
+        public PaymentMethodDictionary GetPaymentMethods(BTCPayNetworkProvider networkProvider, bool alwaysIncludeBTC = false)
         {
-            Dictionary<string, CryptoData> rates = new Dictionary<string, CryptoData>();
+            PaymentMethodDictionary rates = new PaymentMethodDictionary(networkProvider);
             var serializer = new Serializer(Dummy);
-            CryptoData phantom = null;
+            PaymentMethod phantom = null;
 #pragma warning disable CS0618
             // Legacy
             if (alwaysIncludeBTC)
             {
                 var btcNetwork = networkProvider?.GetNetwork("BTC");
-                phantom = new CryptoData() { ParentEntity = this, IsPhantomBTC = true, Rate = Rate, CryptoCode = "BTC", TxFee = TxFee, FeeRate = new FeeRate(TxFee, 100), DepositAddress = DepositAddress, Network = btcNetwork };
-                rates.Add("BTC", phantom);
+                phantom = new PaymentMethod() { ParentEntity = this, IsPhantomBTC = true, Rate = Rate, CryptoCode = "BTC", TxFee = TxFee, FeeRate = new FeeRate(TxFee, 100), DepositAddress = DepositAddress, Network = btcNetwork };
+                if (btcNetwork != null || networkProvider == null)
+                    rates.Add(phantom);
             }
-            if (CryptoData != null)
+            if (PaymentMethod != null)
             {
-                foreach (var prop in CryptoData.Properties())
+                foreach (var prop in PaymentMethod.Properties())
                 {
                     if (prop.Name == "BTC" && phantom != null)
-                        rates.Remove("BTC");
-                    var r = serializer.ToObject<CryptoData>(prop.Value.ToString());
-                    r.CryptoCode = prop.Name;
+                        rates.Remove(phantom);
+                    var r = serializer.ToObject<PaymentMethod>(prop.Value.ToString());
+                    var paymentMethodId = PaymentMethodId.Parse(prop.Name);
+                    r.CryptoCode = paymentMethodId.CryptoCode;
+                    r.PaymentType = paymentMethodId.PaymentType.ToString();
                     r.ParentEntity = this;
                     r.Network = networkProvider?.GetNetwork(r.CryptoCode);
-                    rates.Add(r.CryptoCode, r);
+                    if (r.Network != null || networkProvider == null)
+                        rates.Add(r);
                 }
             }
 #pragma warning restore CS0618
@@ -463,30 +467,37 @@ namespace BTCPayServer.Services.Invoices
 
         Network Dummy = Network.Main;
 
-        public void SetCryptoData(CryptoData cryptoData)
+        public void SetPaymentMethod(PaymentMethod paymentMethod)
         {
-            var dict = GetCryptoData(null);
-            dict.AddOrReplace(cryptoData.CryptoCode, cryptoData);
-            SetCryptoData(dict);
+            var dict = GetPaymentMethods(null);
+            dict.AddOrReplace(paymentMethod);
+            SetPaymentMethods(dict);
         }
 
-        public void SetCryptoData(Dictionary<string, CryptoData> cryptoData)
+        public void SetPaymentMethods(PaymentMethodDictionary paymentMethods)
         {
+            if (paymentMethods.NetworkProvider != null)
+                throw new InvalidOperationException($"{nameof(paymentMethods)} should have NetworkProvider to null");
             var obj = new JObject();
             var serializer = new Serializer(Dummy);
-            foreach (var kv in cryptoData)
-            {
-                var clone = serializer.ToObject<CryptoData>(serializer.ToString(kv.Value));
-                clone.CryptoCode = null;
-                obj.Add(new JProperty(kv.Key, JObject.Parse(serializer.ToString(clone))));
-            }
 #pragma warning disable CS0618
-            CryptoData = obj;
+            foreach (var v in paymentMethods)
+            {
+                var clone = serializer.ToObject<PaymentMethod>(serializer.ToString(v));
+                clone.CryptoCode = null;
+                clone.PaymentType = null;
+                obj.Add(new JProperty(v.GetId().ToString(), JObject.Parse(serializer.ToString(clone))));
+            }
+            PaymentMethod = obj;
+            foreach (var cryptoData in paymentMethods)
+            {
+                cryptoData.ParentEntity = this;
+            }
 #pragma warning restore CS0618
         }
     }
 
-    public class CryptoDataAccounting
+    public class PaymentMethodAccounting
     {
         /// <summary>
         /// Total amount of this invoice
@@ -498,6 +509,10 @@ namespace BTCPayServer.Services.Invoices
         /// </summary>
         public Money Due { get; set; }
 
+        /// <summary>
+        /// Same as Due, can be negative
+        /// </summary>
+        public Money DueUncapped { get; set; }
         /// <summary>
         /// Total amount of the invoice paid after conversion to this crypto currency
         /// </summary>
@@ -511,6 +526,11 @@ namespace BTCPayServer.Services.Invoices
         /// <summary>
         /// Number of transactions required to pay
         /// </summary>
+        public int TxRequired { get; set; }
+
+        /// <summary>
+        /// Number of transactions using this payment method
+        /// </summary>
         public int TxCount { get; set; }
         /// <summary>
         /// Total amount of network fee to pay to the invoice
@@ -518,84 +538,167 @@ namespace BTCPayServer.Services.Invoices
         public Money NetworkFee { get; set; }
     }
 
-    public class CryptoData
+    public class PaymentMethod
     {
         [JsonIgnore]
         public InvoiceEntity ParentEntity { get; set; }
         [JsonIgnore]
         public BTCPayNetwork Network { get; set; }
         [JsonProperty(PropertyName = "cryptoCode", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [Obsolete("Use GetId().CryptoCode instead")]
         public string CryptoCode { get; set; }
+        [JsonProperty(PropertyName = "paymentType", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [Obsolete("Use GetId().PaymentType instead")]
+        public string PaymentType { get; set; }
+
+
+        public PaymentMethodId GetId()
+        {
+#pragma warning disable CS0618 // Type or member is obsolete
+            return new PaymentMethodId(CryptoCode, string.IsNullOrEmpty(PaymentType) ? PaymentTypes.BTCLike : Enum.Parse<PaymentTypes>(PaymentType));
+#pragma warning restore CS0618 // Type or member is obsolete
+        }
+
+        public void SetId(PaymentMethodId id)
+        {
+#pragma warning disable CS0618 // Type or member is obsolete
+            CryptoCode = id.CryptoCode;
+            PaymentType = id.PaymentType.ToString();
+#pragma warning restore CS0618 // Type or member is obsolete
+        }
+
         [JsonProperty(PropertyName = "rate")]
         public decimal Rate { get; set; }
+
+        [Obsolete("Use GetPaymentMethodDetails() instead")]
+        [JsonProperty(PropertyName = "paymentMethod")]
+        public JObject PaymentMethodDetails { get; set; }
+        public IPaymentMethodDetails GetPaymentMethodDetails()
+        {
+#pragma warning disable CS0618 // Type or member is obsolete
+            // Legacy, old code does not have PaymentMethods
+            if (string.IsNullOrEmpty(PaymentType) || PaymentMethodDetails == null)
+            {
+                return new Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod()
+                {
+                    FeeRate = FeeRate,
+                    DepositAddress = string.IsNullOrEmpty(DepositAddress) ? null : DepositAddress,
+                    TxFee = TxFee
+                };
+            }
+            else
+            {
+                var details = PaymentMethodExtensions.DeserializePaymentMethodDetails(GetId(), PaymentMethodDetails);
+                if (details is Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod btcLike)
+                {
+                    btcLike.TxFee = TxFee;
+                    btcLike.DepositAddress = string.IsNullOrEmpty(DepositAddress) ? null : DepositAddress;
+                    btcLike.FeeRate = FeeRate;
+                }
+                return details;
+            }
+            throw new NotSupportedException(PaymentType);
+#pragma warning restore CS0618 // Type or member is obsolete
+        }
+
+        public PaymentMethod SetPaymentMethodDetails(IPaymentMethodDetails paymentMethod)
+        {
+#pragma warning disable CS0618 // Type or member is obsolete
+            // Legacy, need to fill the old fields
+
+            if (PaymentType == null)
+                PaymentType = paymentMethod.GetPaymentType().ToString();
+            else if (PaymentType != paymentMethod.GetPaymentType().ToString())
+                throw new InvalidOperationException("Invalid payment method affected");
+
+            if (paymentMethod is Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod bitcoinPaymentMethod)
+            {
+                TxFee = bitcoinPaymentMethod.TxFee;
+                FeeRate = bitcoinPaymentMethod.FeeRate;
+                DepositAddress = bitcoinPaymentMethod.DepositAddress;
+            }
+            var jobj = JObject.Parse(JsonConvert.SerializeObject(paymentMethod));
+            PaymentMethodDetails = jobj;
+
+#pragma warning restore CS0618 // Type or member is obsolete
+            return this;
+        }
+
         [JsonProperty(PropertyName = "feeRate")]
+        [Obsolete("Use ((BitcoinLikeOnChainPaymentMethod)GetPaymentMethod()).FeeRate")]
         public FeeRate FeeRate { get; set; }
         [JsonProperty(PropertyName = "txFee")]
+        [Obsolete("Use ((BitcoinLikeOnChainPaymentMethod)GetPaymentMethod()).TxFee")]
         public Money TxFee { get; set; }
         [JsonProperty(PropertyName = "depositAddress")]
+        [Obsolete("Use ((BitcoinLikeOnChainPaymentMethod)GetPaymentMethod()).DepositAddress")]
         public string DepositAddress { get; set; }
 
-        public BitcoinAddress GetDepositAddress()
-        {
-            if (string.IsNullOrEmpty(DepositAddress))
-            {
-                return null;
-            }
-            return BitcoinAddress.Create(DepositAddress, Network.NBitcoinNetwork);
-        }
-
         [JsonIgnore]
         public bool IsPhantomBTC { get; set; }
 
-        public CryptoDataAccounting Calculate()
+        public PaymentMethodAccounting Calculate(Func<PaymentEntity, bool> paymentPredicate = null)
         {
-            var cryptoData = ParentEntity.GetCryptoData(null, IsPhantomBTC);
-            var totalDue = Money.Coins(ParentEntity.ProductInformation.Price / Rate);
-            var paid = Money.Zero;
-            var cryptoPaid = Money.Zero;
+            paymentPredicate = paymentPredicate ?? new Func<PaymentEntity, bool>((p) => true);
+            var paymentMethods = ParentEntity.GetPaymentMethods(null, IsPhantomBTC);
 
-            var paidTxFee = Money.Zero;
-            bool paidEnough = totalDue <= paid;
-            int txCount = 0;
+            var totalDue = ParentEntity.ProductInformation.Price / Rate;
+            var paid = 0m;
+            var cryptoPaid = 0.0m;
+
+            int precision = 8;
+            var paidTxFee = 0m;
+            bool paidEnough = paid >= Extensions.RoundUp(totalDue, precision);
+            int txRequired = 0;
             var payments =
                 ParentEntity.GetPayments()
-                .Where(p => p.Accounted)
+                .Where(p => p.Accounted && paymentPredicate(p))
                 .OrderBy(p => p.ReceivedTime)
                 .Select(_ =>
                 {
-                    var txFee = _.GetValue(cryptoData, CryptoCode, cryptoData[_.GetCryptoCode()].TxFee);
-                    paid += _.GetValue(cryptoData, CryptoCode);
+                    var txFee = _.GetValue(paymentMethods, GetId(), paymentMethods[_.GetPaymentMethodId()].GetTxFee());
+                    paid += _.GetValue(paymentMethods, GetId());
                     if (!paidEnough)
                     {
                         totalDue += txFee;
                         paidTxFee += txFee;
                     }
-                    paidEnough |= totalDue <= paid;
-                    if (CryptoCode == _.GetCryptoCode())
+                    paidEnough |= paid >= Extensions.RoundUp(totalDue, precision);
+                    if (GetId() == _.GetPaymentMethodId())
                     {
                         cryptoPaid += _.GetCryptoPaymentData().GetValue();
-                        txCount++;
+                        txRequired++;
                     }
                     return _;
                 })
                 .ToArray();
 
+            var accounting = new PaymentMethodAccounting();
+            accounting.TxCount = txRequired;
             if (!paidEnough)
             {
-                txCount++;
-                totalDue += TxFee;
-                paidTxFee += TxFee;
+                txRequired++;
+                totalDue += GetTxFee();
+                paidTxFee += GetTxFee();
             }
-            var accounting = new CryptoDataAccounting();
-            accounting.TotalDue = totalDue;
-            accounting.Paid = paid;
-            accounting.TxCount = txCount;
-            accounting.CryptoPaid = cryptoPaid;
+
+            accounting.TotalDue = Money.Coins(Extensions.RoundUp(totalDue, precision));
+            accounting.Paid = Money.Coins(paid);
+            accounting.TxRequired = txRequired;
+            accounting.CryptoPaid = Money.Coins(cryptoPaid);
             accounting.Due = Money.Max(accounting.TotalDue - accounting.Paid, Money.Zero);
-            accounting.NetworkFee = paidTxFee;
+            accounting.DueUncapped = accounting.TotalDue - accounting.Paid;
+            accounting.NetworkFee = Money.Coins(paidTxFee);
             return accounting;
         }
 
+        private decimal GetTxFee()
+        {
+            var method = GetPaymentMethodDetails();
+            if (method == null)
+                return 0.0m;
+            return method.GetTxFee();
+        }
     }
 
     public class PaymentEntity
@@ -623,7 +726,7 @@ namespace BTCPayServer.Services.Invoices
         }
 
 
-        [Obsolete("Use GetCryptoCode() instead")]
+        [Obsolete("Use GetpaymentMethodId().CryptoCode instead")]
         public string CryptoCode
         {
             get;
@@ -632,15 +735,9 @@ namespace BTCPayServer.Services.Invoices
 
         [Obsolete("Use GetCryptoPaymentData() instead")]
         public string CryptoPaymentData { get; set; }
-        [Obsolete("Use GetCryptoPaymentDataType() instead")]
+        [Obsolete("Use GetpaymentMethodId().PaymentType instead")]
         public string CryptoPaymentDataType { get; set; }
 
-        public string GetCryptoPaymentDataType()
-        {
-#pragma warning disable CS0618 // Type or member is obsolete
-            return String.IsNullOrEmpty(CryptoPaymentDataType) ? BitcoinLikePaymentData.OnchainBitcoinType : CryptoPaymentDataType;
-#pragma warning restore CS0618 // Type or member is obsolete
-        }
 
         public CryptoPaymentData GetCryptoPaymentData()
         {
@@ -648,7 +745,7 @@ namespace BTCPayServer.Services.Invoices
             if (string.IsNullOrEmpty(CryptoPaymentDataType))
             {
                 // In case this is a payment done before this update, consider it unconfirmed with RBF for safety
-                var paymentData = new BitcoinLikePaymentData();
+                var paymentData = new Payments.Bitcoin.BitcoinLikePaymentData();
                 paymentData.Outpoint = Outpoint;
                 paymentData.Output = Output;
                 paymentData.RBF = true;
@@ -656,50 +753,58 @@ namespace BTCPayServer.Services.Invoices
                 paymentData.Legacy = true;
                 return paymentData;
             }
-            if (CryptoPaymentDataType == BitcoinLikePaymentData.OnchainBitcoinType)
+            if (GetPaymentMethodId().PaymentType == PaymentTypes.BTCLike)
             {
-                var paymentData = JsonConvert.DeserializeObject<BitcoinLikePaymentData>(CryptoPaymentData);
+                var paymentData = JsonConvert.DeserializeObject<Payments.Bitcoin.BitcoinLikePaymentData>(CryptoPaymentData);
                 // legacy
                 paymentData.Output = Output;
                 paymentData.Outpoint = Outpoint;
                 return paymentData;
             }
+            if(GetPaymentMethodId().PaymentType== PaymentTypes.LightningLike)
+            {
+                return JsonConvert.DeserializeObject<Payments.Lightning.LightningLikePaymentData>(CryptoPaymentData);
+            }
 
             throw new NotSupportedException(nameof(CryptoPaymentDataType) + " does not support " + CryptoPaymentDataType);
 #pragma warning restore CS0618
         }
 
-        public void SetCryptoPaymentData(CryptoPaymentData cryptoPaymentData)
+        public PaymentEntity SetCryptoPaymentData(CryptoPaymentData cryptoPaymentData)
         {
 #pragma warning disable CS0618
-            if (cryptoPaymentData is BitcoinLikePaymentData paymentData)
+            if (cryptoPaymentData is Payments.Bitcoin.BitcoinLikePaymentData paymentData)
             {
-                CryptoPaymentDataType = BitcoinLikePaymentData.OnchainBitcoinType;
                 // Legacy
                 Outpoint = paymentData.Outpoint;
                 Output = paymentData.Output;
                 ///
             }
-            else
-                throw new NotSupportedException(cryptoPaymentData.ToString());
+            CryptoPaymentDataType = cryptoPaymentData.GetPaymentType().ToString();
             CryptoPaymentData = JsonConvert.SerializeObject(cryptoPaymentData);
 #pragma warning restore CS0618
+            return this;
         }
-        public Money GetValue(Dictionary<string, CryptoData> cryptoData, string cryptoCode, Money value = null)
+        internal decimal GetValue(PaymentMethodDictionary paymentMethods, PaymentMethodId paymentMethodId, decimal? value = null)
         {
-#pragma warning disable CS0618
-            value = value ?? Output.Value;
-#pragma warning restore CS0618
-            var to = cryptoCode;
-            var from = GetCryptoCode();
+            value = value ?? this.GetCryptoPaymentData().GetValue();
+            var to = paymentMethodId;
+            var from = this.GetPaymentMethodId();
             if (to == from)
-                return value;
-            var fromRate = cryptoData[from].Rate;
-            var toRate = cryptoData[to].Rate;
+                return decimal.Round(value.Value, 8);
+            var fromRate = paymentMethods[from].Rate;
+            var toRate = paymentMethods[to].Rate;
 
-            var fiatValue = fromRate * value.ToDecimal(MoneyUnit.BTC);
+            var fiatValue = fromRate * decimal.Round(value.Value, 8);
             var otherCurrencyValue = toRate == 0 ? 0.0m : fiatValue / toRate;
-            return Money.Coins(otherCurrencyValue);
+            return otherCurrencyValue;
+        }
+
+        public PaymentMethodId GetPaymentMethodId()
+        {
+#pragma warning disable CS0618 // Type or member is obsolete
+            return new PaymentMethodId(CryptoCode ?? "BTC", string.IsNullOrEmpty(CryptoPaymentDataType) ? PaymentTypes.BTCLike : Enum.Parse<PaymentTypes>(CryptoPaymentDataType));
+#pragma warning restore CS0618 // Type or member is obsolete
         }
 
         public string GetCryptoCode()
@@ -727,73 +832,10 @@ namespace BTCPayServer.Services.Invoices
         /// Get value of what as been paid
         /// </summary>
         /// <returns>The amount paid</returns>
-        Money GetValue();
+        decimal GetValue();
         bool PaymentCompleted(PaymentEntity entity, BTCPayNetwork network);
         bool PaymentConfirmed(PaymentEntity entity, SpeedPolicy speedPolicy, BTCPayNetwork network);
 
-    }
-
-    public class BitcoinLikePaymentData : CryptoPaymentData
-    {
-        public readonly static string OnchainBitcoinType = "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 Money GetValue()
-        {
-            return Output.Value;
-        }
-
-        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;
-        }
+        PaymentTypes GetPaymentType();
     }
 }

BTCPayServer/Services/Invoices/InvoiceRepository.cs

@@ -18,6 +18,7 @@ using BTCPayServer.Data;
 using System.Globalization;
 using BTCPayServer.Models.InvoicingModels;
 using BTCPayServer.Logging;
+using BTCPayServer.Payments;
 
 namespace BTCPayServer.Services.Invoices
 {
@@ -123,22 +124,26 @@ namespace BTCPayServer.Services.Invoices
                     CustomerEmail = invoice.RefundMail
                 });
 
-                foreach (var cryptoData in invoice.GetCryptoData(networkProvider).Values)
+                foreach (var paymentMethod in invoice.GetPaymentMethods(networkProvider))
                 {
-                    if (cryptoData.Network == null)
+                    if (paymentMethod.Network == null)
                         throw new InvalidOperationException("CryptoCode unsupported");
+                    var paymentDestination = paymentMethod.GetPaymentMethodDetails().GetPaymentDestination();
+
+                    string address = GetDestination(paymentMethod, paymentMethod.Network.NBitcoinNetwork);
                     context.AddressInvoices.Add(new AddressInvoiceData()
                     {
                         InvoiceDataId = invoice.Id,
                         CreatedTime = DateTimeOffset.UtcNow,
-                    }.SetHash(cryptoData.GetDepositAddress().ScriptPubKey.Hash, cryptoData.CryptoCode));
+                    }.Set(address, paymentMethod.GetId()));
+
                     context.HistoricalAddressInvoices.Add(new HistoricalAddressInvoiceData()
                     {
                         InvoiceDataId = invoice.Id,
                         Assigned = DateTimeOffset.UtcNow
-                    }.SetAddress(cryptoData.DepositAddress, cryptoData.CryptoCode));
-                    textSearch.Add(cryptoData.DepositAddress);
-                    textSearch.Add(cryptoData.Calculate().TotalDue.ToString());
+                    }.SetAddress(paymentDestination, paymentMethod.GetId().ToString()));
+                    textSearch.Add(paymentDestination);
+                    textSearch.Add(paymentMethod.Calculate().TotalDue.ToString());
                 }
                 context.PendingInvoices.Add(new PendingInvoiceData() { Id = invoice.Id });
                 await context.SaveChangesAsync().ConfigureAwait(false);
@@ -157,7 +162,18 @@ namespace BTCPayServer.Services.Invoices
             return invoice;
         }
 
-        public async Task<bool> NewAddress(string invoiceId, BitcoinAddress bitcoinAddress, BTCPayNetwork network)
+        private static string GetDestination(PaymentMethod paymentMethod, Network network)
+        {
+            // For legacy reason, BitcoinLikeOnChain is putting the hashes of addresses in database
+            if (paymentMethod.GetId().PaymentType == Payments.PaymentTypes.BTCLike)
+            {
+                return ((Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod)paymentMethod.GetPaymentMethodDetails()).GetDepositAddress(network).ScriptPubKey.Hash.ToString();
+            }
+            ///////////////
+            return paymentMethod.GetPaymentMethodDetails().GetPaymentDestination();
+        }
+
+        public async Task<bool> NewAddress(string invoiceId, IPaymentMethodDetails paymentMethod, BTCPayNetwork network)
         {
             using (var context = _ContextFactory.CreateContext())
             {
@@ -166,24 +182,26 @@ namespace BTCPayServer.Services.Invoices
                     return false;
 
                 var invoiceEntity = ToObject<InvoiceEntity>(invoice.Blob, network.NBitcoinNetwork);
-                var currencyData = invoiceEntity.GetCryptoData(network, null);
+                var currencyData = invoiceEntity.GetPaymentMethod(network, paymentMethod.GetPaymentType(), null);
                 if (currencyData == null)
                     return false;
 
-                if (currencyData.DepositAddress != null)
+                var existingPaymentMethod = currencyData.GetPaymentMethodDetails();
+                if (existingPaymentMethod.GetPaymentDestination() != null)
                 {
-                    MarkUnassigned(invoiceId, invoiceEntity, context, network.CryptoCode);
+                    MarkUnassigned(invoiceId, invoiceEntity, context, currencyData.GetId());
                 }
 
-                currencyData.DepositAddress = bitcoinAddress.ToString();
+                existingPaymentMethod.SetPaymentDestination(paymentMethod.GetPaymentDestination());
 
+                currencyData.SetPaymentMethodDetails(existingPaymentMethod);
 #pragma warning disable CS0618
                 if (network.IsBTC)
                 {
                     invoiceEntity.DepositAddress = currencyData.DepositAddress;
                 }
 #pragma warning restore CS0618
-                invoiceEntity.SetCryptoData(currencyData);
+                invoiceEntity.SetPaymentMethod(currencyData);
                 invoice.Blob = ToBytes(invoiceEntity, network.NBitcoinNetwork);
 
                 context.AddressInvoices.Add(new AddressInvoiceData()
@@ -191,15 +209,15 @@ namespace BTCPayServer.Services.Invoices
                     InvoiceDataId = invoiceId,
                     CreatedTime = DateTimeOffset.UtcNow
                 }
-                .SetHash(bitcoinAddress.ScriptPubKey.Hash, network.CryptoCode));
+                .Set(GetDestination(currencyData, network.NBitcoinNetwork), currencyData.GetId()));
                 context.HistoricalAddressInvoices.Add(new HistoricalAddressInvoiceData()
                 {
                     InvoiceDataId = invoiceId,
                     Assigned = DateTimeOffset.UtcNow
-                }.SetAddress(bitcoinAddress.ToString(), network.CryptoCode));
+                }.SetAddress(paymentMethod.GetPaymentDestination(), network.CryptoCode));
 
                 await context.SaveChangesAsync();
-                AddToTextSearch(invoice.Id, bitcoinAddress.ToString());
+                AddToTextSearch(invoice.Id, paymentMethod.GetPaymentDestination());
                 return true;
             }
         }
@@ -219,15 +237,15 @@ namespace BTCPayServer.Services.Invoices
             }
         }
 
-        private static void MarkUnassigned(string invoiceId, InvoiceEntity entity, ApplicationDbContext context, string cryptoCode)
+        private static void MarkUnassigned(string invoiceId, InvoiceEntity entity, ApplicationDbContext context, PaymentMethodId paymentMethodId)
         {
-            foreach (var address in entity.GetCryptoData(null))
+            foreach (var address in entity.GetPaymentMethods(null))
             {
-                if (cryptoCode != null && cryptoCode != address.Value.CryptoCode)
+                if (paymentMethodId != null && paymentMethodId != address.GetId())
                     continue;
                 var historical = new HistoricalAddressInvoiceData();
                 historical.InvoiceDataId = invoiceId;
-                historical.SetAddress(address.Value.DepositAddress, address.Value.CryptoCode);
+                historical.SetAddress(address.GetPaymentMethodDetails().GetPaymentDestination(), address.GetId().ToString());
                 historical.UnAssigned = DateTimeOffset.UtcNow;
                 context.Attach(historical);
                 context.Entry(historical).Property(o => o.UnAssigned).IsModified = true;
@@ -343,9 +361,9 @@ namespace BTCPayServer.Services.Invoices
             }
             if (invoice.AddressInvoices != null)
             {
-                entity.AvailableAddressHashes = invoice.AddressInvoices.Select(a => a.GetHash() + a.GetCryptoCode()).ToHashSet();
+                entity.AvailableAddressHashes = invoice.AddressInvoices.Select(a => a.GetAddress() + a.GetpaymentMethodId().ToString()).ToHashSet();
             }
-            if(invoice.Events != null)
+            if (invoice.Events != null)
             {
                 entity.Events = invoice.Events.OrderBy(c => c.Timestamp).ToList();
             }
@@ -443,7 +461,16 @@ namespace BTCPayServer.Services.Invoices
             AddToTextSearch(invoiceId, addresses.Select(a => a.ToString()).ToArray());
         }
 
-        public async Task<PaymentEntity> AddPayment(string invoiceId, DateTimeOffset date, CryptoPaymentData paymentData, string cryptoCode)
+        /// <summary>
+        /// Add a payment to an invoice
+        /// </summary>
+        /// <param name="invoiceId"></param>
+        /// <param name="date"></param>
+        /// <param name="paymentData"></param>
+        /// <param name="cryptoCode"></param>
+        /// <param name="accounted"></param>
+        /// <returns>The PaymentEntity or null if already added</returns>
+        public async Task<PaymentEntity> AddPayment(string invoiceId, DateTimeOffset date, CryptoPaymentData paymentData, string cryptoCode, bool accounted = false)
         {
             using (var context = _ContextFactory.CreateContext())
             {
@@ -453,22 +480,26 @@ namespace BTCPayServer.Services.Invoices
                     CryptoCode = cryptoCode,
 #pragma warning restore CS0618
                     ReceivedTime = date.UtcDateTime,
-                    Accounted = false
+                    Accounted = accounted
                 };
                 entity.SetCryptoPaymentData(paymentData);
-                
+
 
                 PaymentData data = new PaymentData
                 {
                     Id = paymentData.GetPaymentId(),
                     Blob = ToBytes(entity, null),
                     InvoiceDataId = invoiceId,
-                    Accounted = false
+                    Accounted = accounted
                 };
 
                 context.Payments.Add(data);
 
-                await context.SaveChangesAsync().ConfigureAwait(false);
+                try
+                {
+                    await context.SaveChangesAsync().ConfigureAwait(false);
+                }
+                catch(DbUpdateException) { return null; } // Already exists
                 AddToTextSearch(invoiceId, paymentData.GetSearchTerms());
                 return entity;
             }