Fix alignement in Dynamic DNS

* Update Login.cshtml

[UI] Removed Unneeded string on login page with registering disabled. #881

* Update Login.cshtml

.circleci/config.yml

@@ -1,29 +1,41 @@
 version: 2
 jobs:
-  build:
-    machine: 
-      docker_layer_caching: true
-    steps: 
-      - checkout
-
-  test:
+  fast_tests:
     machine:
         docker_layer_caching: true
     steps:
       - checkout
       - run:
           command: |
-            cd BTCPayServer.Tests
-            docker-compose down --v
-            docker-compose build
-            TESTS_RUN_EXTERNAL_INTEGRATION="true"
-            if [ -n "$CIRCLE_PULL_REQUEST" ] || [ -n "$CIRCLE_PR_NUMBER" ]; then
-                TESTS_RUN_EXTERNAL_INTEGRATION="false"
-            fi
-            docker-compose run -e TESTS_RUN_EXTERNAL_INTEGRATION=$TESTS_RUN_EXTERNAL_INTEGRATION tests
+            cd .circleci && ./run-tests.sh "Fast=Fast"
+  selenium_tests:
+    machine:
+        docker_layer_caching: true
+    steps:
+      - checkout
+      - run:
+          command: |
+            cd .circleci && ./run-tests.sh "Selenium=Selenium"
+  integration_tests:
+    machine:
+        docker_layer_caching: true
+    steps:
+      - checkout
+      - run:
+          command: |
+            cd .circleci && ./run-tests.sh "Integration=Integration"
+  external_tests:
+    machine:
+        docker_layer_caching: true
+    steps:
+      - checkout
+      - run:
+          command: |
+            cd .circleci && ./run-tests.sh "ExternalIntegration=ExternalIntegration"
+
 
   # publish jobs require $DOCKERHUB_REPO, $DOCKERHUB_USER, $DOCKERHUB_PASS defined
-  publish_docker_linuxamd64:
+  amd64:
     machine:
       docker_layer_caching: true
     steps:
@@ -32,11 +44,11 @@ jobs:
           command: |
             LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
             #
-            sudo docker build --pull -t $DOCKERHUB_REPO:$LATEST_TAG-amd64 -f Dockerfile.linuxamd64 .
+            sudo docker build --pull -t $DOCKERHUB_REPO:$LATEST_TAG-amd64 -f amd64.Dockerfile .
             sudo docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
             sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-amd64
 
-  publish_docker_linuxarm:
+  arm32v7:
     machine:
       docker_layer_caching: true
     steps:
@@ -46,11 +58,11 @@ jobs:
             sudo docker run --rm --privileged multiarch/qemu-user-static:register --reset
             LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
             #
-            sudo docker build --pull -t $DOCKERHUB_REPO:$LATEST_TAG-arm32v7 -f Dockerfile.linuxarm32v7 .
+            sudo docker build --pull -t $DOCKERHUB_REPO:$LATEST_TAG-arm32v7 -f arm32v7.Dockerfile .
             sudo docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
             sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-arm32v7
 
-  publish_docker_multiarch:
+  multiarch:
     machine:
       enabled: true
       image: circleci/classic:201808-01
@@ -73,11 +85,17 @@ workflows:
   version: 2
   build_and_test:
     jobs:
-      - test
+      - fast_tests
+      - selenium_tests
+      - integration_tests
+      - external_tests:
+          filters:
+            branches:
+                only: master
 
   publish:
     jobs:
-      - publish_docker_linuxamd64:
+      - amd64:
           filters:
             # ignore any commit on any branch by default
             branches:
@@ -85,16 +103,16 @@ workflows:
             # only act on version tags
             tags:
               only: /v[1-9]+(\.[0-9]+)*/
-      - publish_docker_linuxarm:
+      - arm32v7:
           filters:
             branches:
               ignore: /.*/
             tags:
               only: /v[1-9]+(\.[0-9]+)*/
-      - publish_docker_multiarch:
+      - multiarch:
           requires:
-            - publish_docker_linuxamd64
-            - publish_docker_linuxarm
+            - amd64
+            - arm32v7
           filters:
             branches:
               ignore: /.*/

.circleci/run-tests.sh

@@ -0,0 +1,8 @@
+#!/bin/sh
+set -e
+
+cd ../BTCPayServer.Tests
+docker-compose -v
+docker-compose down --v
+docker-compose build
+docker-compose run -e "TEST_FILTERS=$1" tests

BTCPayServer.Common/BTCPayNetwork.cs

@@ -3,13 +3,18 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
-using BTCPayServer.Services.Invoices;
-using BTCPayServer.Services.Rates;
 using NBitcoin;
 using NBXplorer;
+using Newtonsoft.Json;
 
 namespace BTCPayServer
 {
+    public enum DerivationType
+    {
+        Legacy,
+        SegwitP2SH,
+        Segwit
+    }
     public class BTCPayDefaultSettings
     {
         static BTCPayDefaultSettings()
@@ -38,13 +43,69 @@ namespace BTCPayServer
         public string DefaultConfigurationFile { get; set; }
         public int DefaultPort { get; set; }
     }
-    public class BTCPayNetwork
+
+    public class BTCPayNetwork:BTCPayNetworkBase
     {
         public Network NBitcoinNetwork { get; set; }
+        public NBXplorer.NBXplorerNetwork NBXplorerNetwork { get; set; }
+        public bool SupportRBF { get; internal set; }
+        public string LightningImagePath { get; set; }
+        public BTCPayDefaultSettings DefaultSettings { get; set; }
+        public KeyPath CoinType { get; internal set; }
+        public Dictionary<uint, DerivationType> ElectrumMapping = new Dictionary<uint, DerivationType>();
+
+
+        public KeyPath GetRootKeyPath(DerivationType type)
+        {
+            KeyPath baseKey;
+            if (!NBitcoinNetwork.Consensus.SupportSegwit)
+            {
+                baseKey = new KeyPath("44'");
+            }
+            else
+            {
+                switch (type)
+                {
+                    case DerivationType.Legacy:
+                        baseKey = new KeyPath("44'");
+                        break;
+                    case DerivationType.SegwitP2SH:
+                        baseKey = new KeyPath("49'");
+                        break;
+                    case DerivationType.Segwit:
+                        baseKey = new KeyPath("84'");
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(type), type, null);
+                }
+            }
+            return baseKey
+                .Derive(CoinType);
+        }
+
+        public KeyPath GetRootKeyPath()
+        {
+            return new KeyPath(NBitcoinNetwork.Consensus.SupportSegwit ? "49'" : "44'")
+                .Derive(CoinType);
+        }
+
+        public override T ToObject<T>(string json)
+        {
+            return NBXplorerNetwork.Serializer.ToObject<T>(json);
+        }
+
+        public override string ToString<T>(T obj)
+        {
+            return NBXplorerNetwork.Serializer.ToString(obj);
+        }
+    }
+
+    public abstract class BTCPayNetworkBase
+    {
+        
         public string CryptoCode { get; internal set; }
         public string BlockExplorerLink { get; internal set; }
         public string UriScheme { get; internal set; }
-        public Money MinFee { get; internal set; }
         public string DisplayName { get; set; }
 
         [Obsolete("Should not be needed")]
@@ -57,23 +118,22 @@ namespace BTCPayServer
         }
 
         public string CryptoImagePath { get; set; }
-        public string LightningImagePath { get; set; }
-        public NBXplorer.NBXplorerNetwork NBXplorerNetwork { get; set; }
 
-        public BTCPayDefaultSettings DefaultSettings { get; set; }
-        public KeyPath CoinType { get; internal set; }
         public int MaxTrackedConfirmation { get; internal set; } = 6;
         public string[] DefaultRateRules { get; internal set; } = Array.Empty<string>();
-
         public override string ToString()
         {
             return CryptoCode;
         }
 
-        internal KeyPath GetRootKeyPath()
+        public virtual T ToObject<T>(string json)
         {
-            return new KeyPath(NBitcoinNetwork.Consensus.SupportSegwit ? "49'" : "44'")
-                        .Derive(CoinType); 
+            return JsonConvert.DeserializeObject<T>(json);
+        }
+
+        public virtual string ToString<T>(T obj)
+        {
+            return JsonConvert.SerializeObject(obj);
         }
     }
 }

BTCPayServer.Common/BTCPayNetworkProvider.Bitcoin.cs

@@ -2,9 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using BTCPayServer.Services.Rates;
 using NBitcoin;
-using NBitpayClient;
 using NBXplorer;
 
 namespace BTCPayServer
@@ -18,14 +16,29 @@ namespace BTCPayServer
             {
                 CryptoCode = nbxplorerNetwork.CryptoCode,
                 DisplayName = "Bitcoin",
-                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://www.smartbit.com.au/tx/{0}" : "https://testnet.smartbit.com.au/tx/{0}",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://blockstream.info/tx/{0}" : "https://blockstream.info/testnet/tx/{0}",
                 NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
                 NBXplorerNetwork = nbxplorerNetwork,
                 UriScheme = "bitcoin",
                 CryptoImagePath = "imlegacy/bitcoin.svg",
                 LightningImagePath = "imlegacy/bitcoin-lightning.svg",
                 DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
-                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("0'") : new KeyPath("1'")
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("0'") : new KeyPath("1'"),
+                SupportRBF = true,
+                //https://github.com/spesmilo/electrum/blob/11733d6bc271646a00b69ff07657119598874da4/electrum/constants.py
+                ElectrumMapping = NetworkType == NetworkType.Mainnet
+                    ? new Dictionary<uint, DerivationType>()
+                    {
+                        {0x0488b21eU, DerivationType.Legacy }, // xpub
+                        {0x049d7cb2U, DerivationType.SegwitP2SH }, // ypub
+                        {0x4b24746U, DerivationType.Segwit }, //zpub
+                    }
+                    : new Dictionary<uint, DerivationType>()
+                    {
+                        {0x043587cfU, DerivationType.Legacy},
+                        {0x044a5262U, DerivationType.SegwitP2SH},
+                        {0x045f1cf6U, DerivationType.Segwit}
+                    }
             });
         }
     }

BTCPayServer.Common/BTCPayNetworkProvider.Bitcoinplus.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using BTCPayServer.Services.Rates;
 using NBitcoin;
 using NBXplorer;
 

BTCPayServer.Common/BTCPayNetworkProvider.Bitcore.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using BTCPayServer.Services.Rates;
 using NBitcoin;
 using NBXplorer;
 

BTCPayServer.Common/BTCPayNetworkProvider.Dash.cs

@@ -27,8 +27,7 @@ namespace BTCPayServer
                 DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
                 //https://github.com/satoshilabs/slips/blob/master/slip-0044.md
                 CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("5'")
-                    : new KeyPath("1'"),
-                MinFee = Money.Satoshis(1m)
+                    : new KeyPath("1'")
             });
         }
     }

BTCPayServer.Common/BTCPayNetworkProvider.Dogecoin.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using BTCPayServer.Services.Rates;
 using NBitcoin;
 using NBXplorer;
 
@@ -28,8 +27,7 @@ namespace BTCPayServer
                 },
                 CryptoImagePath = "imlegacy/dogecoin.png",
                 DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
-                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("3'") : new KeyPath("1'"),
-                MinFee = Money.Coins(1m)
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("3'") : new KeyPath("1'")
             });
         }
     }

BTCPayServer.Common/BTCPayNetworkProvider.Feathercoin.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using BTCPayServer.Services.Rates;
 using NBitcoin;
 using NBXplorer;
 

BTCPayServer.Common/BTCPayNetworkProvider.Groestlcoin.cs

@@ -10,20 +10,21 @@ namespace BTCPayServer
     {
         public void InitGroestlcoin()
         {
-
             var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("GRS");
             Add(new BTCPayNetwork()
             {
                 CryptoCode = nbxplorerNetwork.CryptoCode,
                 DisplayName = "Groestlcoin",
-                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://chainz.cryptoid.info/grs/tx.dws?{0}.htm" : "https://chainz.cryptoid.info/grs-test/tx.dws?{0}.htm",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet
+                    ? "https://chainz.cryptoid.info/grs/tx.dws?{0}.htm"
+                    : "https://chainz.cryptoid.info/grs-test/tx.dws?{0}.htm",
                 NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
                 NBXplorerNetwork = nbxplorerNetwork,
                 UriScheme = "groestlcoin",
                 DefaultRateRules = new[]
                 {
-                                "GRS_X = GRS_BTC * BTC_X",
-                                "GRS_BTC = bittrex(GRS_BTC)"
+                    "GRS_X = GRS_BTC * BTC_X",
+                    "GRS_BTC = bittrex(GRS_BTC)"
                 },
                 CryptoImagePath = "imlegacy/groestlcoin.png",
                 LightningImagePath = "imlegacy/groestlcoin-lightning.svg",

BTCPayServer.Common/BTCPayNetworkProvider.Litecoin.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using BTCPayServer.Services.Rates;
 using NBitcoin;
 using NBXplorer;
 
@@ -17,14 +16,30 @@ namespace BTCPayServer
             {
                 CryptoCode = nbxplorerNetwork.CryptoCode,
                 DisplayName = "Litecoin",
-                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://live.blockcypher.com/ltc/tx/{0}/" : "http://explorer.litecointools.com/tx/{0}",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet
+                    ? "https://live.blockcypher.com/ltc/tx/{0}/"
+                    : "http://explorer.litecointools.com/tx/{0}",
                 NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
                 NBXplorerNetwork = nbxplorerNetwork,
                 UriScheme = "litecoin",
                 CryptoImagePath = "imlegacy/litecoin.svg",
                 LightningImagePath = "imlegacy/litecoin-lightning.svg",
                 DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
-                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("2'") : new KeyPath("1'")
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("2'") : new KeyPath("1'"),
+                //https://github.com/pooler/electrum-ltc/blob/0d6989a9d2fb2edbea421c116e49d1015c7c5a91/electrum_ltc/constants.py
+                ElectrumMapping = NetworkType == NetworkType.Mainnet
+                    ? new Dictionary<uint, DerivationType>()
+                    {
+                        {0x0488b21eU, DerivationType.Legacy },
+                        {0x049d7cb2U, DerivationType.SegwitP2SH },
+                        {0x04b24746U, DerivationType.Segwit },
+                    }
+                    : new Dictionary<uint, DerivationType>()
+                    {
+                        {0x043587cfU, DerivationType.Legacy },
+                        {0x044a5262U, DerivationType.SegwitP2SH },
+                        {0x045f1cf6U, DerivationType.Segwit }
+                    }
             });
         }
     }

BTCPayServer.Common/BTCPayNetworkProvider.Monacoin.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using BTCPayServer.Services.Rates;
 using NBitcoin;
 using NBXplorer;
 

BTCPayServer.Common/BTCPayNetworkProvider.Polis.cs

@@ -2,7 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using BTCPayServer.Services.Rates;
 using NBitcoin;
 using NBXplorer;
 

BTCPayServer.Common/BTCPayNetworkProvider.Ufo.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using BTCPayServer.Services.Rates;
 using NBitcoin;
 using NBXplorer;
 

BTCPayServer.Common/BTCPayNetworkProvider.Viacoin.cs

@@ -2,7 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using BTCPayServer.Services.Rates;
 using NBitcoin;
 using NBXplorer;
 

BTCPayServer.Common/BTCPayNetworkProvider.cs

@@ -3,17 +3,14 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
-using BTCPayServer.Services.Rates;
-using Microsoft.Extensions.Caching.Memory;
 using NBitcoin;
-using NBitpayClient;
 using NBXplorer;
 
 namespace BTCPayServer
 {
     public partial class BTCPayNetworkProvider
     {
-        Dictionary<string, BTCPayNetwork> _Networks = new Dictionary<string, BTCPayNetwork>();
+        Dictionary<string, BTCPayNetworkBase> _Networks = new Dictionary<string, BTCPayNetworkBase>();
 
 
         private readonly NBXplorerNetworkProvider _NBXplorerNetworkProvider;
@@ -25,13 +22,14 @@ namespace BTCPayServer
             }
         }
 
-        BTCPayNetworkProvider(BTCPayNetworkProvider filtered, string[] cryptoCodes)
+        BTCPayNetworkProvider(BTCPayNetworkProvider unfiltered, string[] cryptoCodes)
         {
-            NetworkType = filtered.NetworkType;
-            _NBXplorerNetworkProvider = new NBXplorerNetworkProvider(filtered.NetworkType);
-            _Networks = new Dictionary<string, BTCPayNetwork>();
+            UnfilteredNetworks = unfiltered.UnfilteredNetworks ?? unfiltered;
+            NetworkType = unfiltered.NetworkType;
+            _NBXplorerNetworkProvider = new NBXplorerNetworkProvider(unfiltered.NetworkType);
+            _Networks = new Dictionary<string, BTCPayNetworkBase>();
             cryptoCodes = cryptoCodes.Select(c => c.ToUpperInvariant()).ToArray();
-            foreach (var network in filtered._Networks)
+            foreach (var network in unfiltered._Networks)
             {
                 if(cryptoCodes.Contains(network.Key))
                 {
@@ -40,9 +38,12 @@ namespace BTCPayServer
             }
         }
 
+        public BTCPayNetworkProvider UnfilteredNetworks { get; }
+
         public NetworkType NetworkType { get; private set; }
         public BTCPayNetworkProvider(NetworkType networkType)
         {
+            UnfilteredNetworks = this;
             _NBXplorerNetworkProvider = new NBXplorerNetworkProvider(networkType);
             NetworkType = networkType;
             InitBitcoin();
@@ -56,6 +57,22 @@ namespace BTCPayServer
             InitGroestlcoin();
             InitViacoin();
 
+            // Assume that electrum mappings are same as BTC if not specified
+            foreach (var network in _Networks.Values.OfType<BTCPayNetwork>())
+            {
+                if(network.ElectrumMapping.Count == 0)
+                {
+                    network.ElectrumMapping = GetNetwork<BTCPayNetwork>("BTC").ElectrumMapping;
+                    if (!network.NBitcoinNetwork.Consensus.SupportSegwit)
+                    {
+                        network.ElectrumMapping =
+                            network.ElectrumMapping
+                            .Where(kv => kv.Value == DerivationType.Legacy)
+                            .ToDictionary(k => k.Key, k => k.Value);
+                    }
+                }
+            }
+
             // Disabled because of https://twitter.com/Cryptopia_NZ/status/1085084168852291586
             //InitPolis();
             //InitBitcoinplus();
@@ -73,20 +90,14 @@ namespace BTCPayServer
         }
 
         [Obsolete("To use only for legacy stuff")]
-        public BTCPayNetwork BTC
-        {
-            get
-            {
-                return GetNetwork("BTC");
-            }
-        }
+        public BTCPayNetwork BTC => GetNetwork<BTCPayNetwork>("BTC");
 
-        public void Add(BTCPayNetwork network)
+        public void Add(BTCPayNetworkBase network)
         {
             _Networks.Add(network.CryptoCode.ToUpperInvariant(), network);
         }
 
-        public IEnumerable<BTCPayNetwork> GetAll()
+        public IEnumerable<BTCPayNetworkBase> GetAll()
         {
             return _Networks.Values.ToArray();
         }
@@ -95,15 +106,20 @@ namespace BTCPayServer
         {
             return _Networks.ContainsKey(cryptoCode.ToUpperInvariant());
         }
-
-        public BTCPayNetwork GetNetwork(string cryptoCode)
+        public BTCPayNetworkBase GetNetwork(string cryptoCode)
         {
-            if(!_Networks.TryGetValue(cryptoCode.ToUpperInvariant(), out BTCPayNetwork network))
+            return GetNetwork<BTCPayNetworkBase>(cryptoCode);
+        }
+        public T GetNetwork<T>(string cryptoCode) where T: BTCPayNetworkBase
+        {
+            if (cryptoCode == null)
+                throw new ArgumentNullException(nameof(cryptoCode));
+            if(!_Networks.TryGetValue(cryptoCode.ToUpperInvariant(), out BTCPayNetworkBase network))
             {
                 if (cryptoCode == "XBT")
-                    return GetNetwork("BTC");
+                    return GetNetwork<T>("BTC");
             }
-            return network;
+            return network as T;
         }
     }
 }

BTCPayServer.Common/BTCPayServer.Common.csproj

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../Build/Version.csproj" Condition="Exists('../Build/Version.csproj')" />
+  <Import Project="../Build/Common.csproj" />
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.App" Version="2.1.9" />
+    <PackageReference Include="NBitcoin" Version="4.1.2.38" />
+    <PackageReference Include="NBXplorer.Client" Version="2.0.0.18" />
+  </ItemGroup>
+</Project>

BTCPayServer.Common/CustomThreadPool.cs

@@ -7,7 +7,7 @@ using System.Threading.Tasks;
 
 namespace BTCPayServer
 {
-    class CustomThreadPool : IDisposable
+    public class CustomThreadPool : IDisposable
     {
         CancellationTokenSource _Cancel = new CancellationTokenSource();
         TaskCompletionSource<bool> _Exited;

BTCPayServer.Common/Extensions.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace BTCPayServer
+{
+    public static class UtilitiesExtensions
+    {
+        public static void AddRange<T>(this HashSet<T> hashSet, IEnumerable<T> items)
+        {
+            foreach (var item in items)
+            {
+                hashSet.Add(item);
+            }
+        }
+    }
+}

BTCPayServer.Common/ZipUtils.cs

@@ -6,7 +6,7 @@ using System.Text;
 
 namespace BTCPayServer
 {
-    class ZipUtils
+    public class ZipUtils
     {
         public static byte[] Zip(string unzipped)
         {

BTCPayServer.Rating/BTCPayServer.Rating.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../Build/Version.csproj" Condition="Exists('../Build/Version.csproj')" />
+  <Import Project="../Build/Common.csproj" />
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
+    <LangVersion>7.3</LangVersion>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Folder Include="Providers\" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.App" Version="2.1.9" />
+    <PackageReference Include="Newtonsoft.Json" Version="12.0.2" />
+    <PackageReference Include="DigitalRuby.ExchangeSharp" Version="0.5.3" />
+    <PackageReference Include="NBitpayClient" Version="1.0.0.34" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\BTCPayServer.Common\BTCPayServer.Common.csproj" />
+  </ItemGroup>
+
+</Project>

BTCPayServer.Rating/CurrencyPair.cs

@@ -53,7 +53,7 @@ namespace BTCPayServer.Rating
                 for (int i = 3; i < 5; i++)
                 {
                     var potentialCryptoName = currencyPair.Substring(0, i);
-                    var network = _NetworkProvider.GetNetwork(potentialCryptoName);
+                    var network = _NetworkProvider.GetNetwork<BTCPayNetworkBase>(potentialCryptoName);
                     if (network != null)
                     {
                         value = new CurrencyPair(network.CryptoCode, currencyPair.Substring(i));

BTCPayServer.Rating/Providers/BackgroundFetcherRateProvider.cs

@@ -4,10 +4,10 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.ExceptionServices;
 using System.Threading.Tasks;
-using BTCPayServer.Data;
-using BTCPayServer.Logging;
 using BTCPayServer.Rating;
 using System.Threading;
+using Microsoft.Extensions.Logging.Abstractions;
+using BTCPayServer.Logging;
 
 namespace BTCPayServer.Services.Rates
 {
@@ -39,6 +39,7 @@ namespace BTCPayServer.Services.Rates
         }
 
         IRateProvider _Inner;
+
         public BackgroundFetcherRateProvider(IRateProvider inner)
         {
             if (inner == null)

BTCPayServer.Rating/Providers/BitpayRateProvider.cs

@@ -4,7 +4,6 @@ using System;
 using System.Collections.Generic;
 using System.Text;
 using System.Threading.Tasks;
-using NBitcoin;
 using BTCPayServer.Rating;
 using System.Threading;
 

BTCPayServer.Rating/Providers/CoinAverageSettings.cs

@@ -70,61 +70,73 @@ namespace BTCPayServer.Services.Rates
             //}
             //b.AppendLine("}.ToArray()");
             AvailableExchanges = new CoinAverageExchanges();
-            foreach(var item in
+            foreach (var item in
              new[] {
-                (DisplayName: "BitBargain", Name: "bitbargain"),
-                (DisplayName: "Tidex", Name: "tidex"),
-                (DisplayName: "LocalBitcoins", Name: "localbitcoins"),
-                (DisplayName: "EtherDelta", Name: "etherdelta"),
-                (DisplayName: "Kraken", Name: "kraken"),
-                (DisplayName: "BitBay", Name: "bitbay"),
-                (DisplayName: "Independent Reserve", Name: "independentreserve"),
-                (DisplayName: "Exmoney", Name: "exmoney"),
-                (DisplayName: "Bitcoin.co.id", Name: "bitcoin_co_id"),
-                (DisplayName: "Huobi", Name: "huobi"),
-                (DisplayName: "GDAX", Name: "gdax"),
-                (DisplayName: "Coincheck", Name: "coincheck"),
-                (DisplayName: "Bittylicious", Name: "bittylicious"),
-                (DisplayName: "Gemini", Name: "gemini"),
-                (DisplayName: "Bit2C", Name: "bit2c"),
-                (DisplayName: "Luno", Name: "luno"),
-                (DisplayName: "Negocie Coins", Name: "negociecoins"),
-                (DisplayName: "FYB-SE", Name: "fybse"),
-                (DisplayName: "Hitbtc", Name: "hitbtc"),
-                (DisplayName: "Bitex.la", Name: "bitex"),
-                (DisplayName: "Korbit", Name: "korbit"),
-                (DisplayName: "itBit", Name: "itbit"),
-                (DisplayName: "Okex", Name: "okex"),
-                (DisplayName: "Bitsquare", Name: "bitsquare"),
-                (DisplayName: "Bitfinex", Name: "bitfinex"),
-                (DisplayName: "CoinMate", Name: "coinmate"),
-                (DisplayName: "Bitstamp", Name: "bitstamp"),
-                (DisplayName: "Cryptonit", Name: "cryptonit"),
-                (DisplayName: "Foxbit", Name: "foxbit"),
-                (DisplayName: "QuickBitcoin", Name: "quickbitcoin"),
-                (DisplayName: "Poloniex", Name: "poloniex"),
-                (DisplayName: "Bit-Z", Name: "bitz"),
-                (DisplayName: "Liqui", Name: "liqui"),
-                (DisplayName: "BitKonan", Name: "bitkonan"),
-                (DisplayName: "Kucoin", Name: "kucoin"),
-                (DisplayName: "Binance", Name: "binance"),
-                (DisplayName: "Rock Trading", Name: "rocktrading"),
-                (DisplayName: "Mercado Bitcoin", Name: "mercado"),
-                (DisplayName: "Coinsecure", Name: "coinsecure"),
+                (DisplayName: "Idex", Name: "idex"),
                 (DisplayName: "Coinfloor", Name: "coinfloor"),
-                (DisplayName: "bitFlyer", Name: "bitflyer"),
-                (DisplayName: "BTCTurk", Name: "btcturk"),
-                (DisplayName: "Bittrex", Name: "bittrex"),
-                (DisplayName: "CampBX", Name: "campbx"),
-                (DisplayName: "Zaif", Name: "zaif"),
-                (DisplayName: "FYB-SG", Name: "fybsg"),
-                (DisplayName: "Quoine", Name: "quoine"),
+                (DisplayName: "Okex", Name: "okex"),
+                (DisplayName: "Bitfinex", Name: "bitfinex"),
+                (DisplayName: "Bittylicious", Name: "bittylicious"),
                 (DisplayName: "BTC Markets", Name: "btcmarkets"),
+                (DisplayName: "Kucoin", Name: "kucoin"),
+                (DisplayName: "IDAX", Name: "idax"),
+                (DisplayName: "Kraken", Name: "kraken"),
+                (DisplayName: "Bit2C", Name: "bit2c"),
+                (DisplayName: "Mercado Bitcoin", Name: "mercado"),
+                (DisplayName: "CEX.IO", Name: "cex"),
+                (DisplayName: "Bitex.la", Name: "bitex"),
+                (DisplayName: "Quoine", Name: "quoine"),
+                (DisplayName: "Stex", Name: "stex"),
+                (DisplayName: "CoinTiger", Name: "cointiger"),
+                (DisplayName: "Poloniex", Name: "poloniex"),
+                (DisplayName: "Zaif", Name: "zaif"),
+                (DisplayName: "Huobi", Name: "huobi"),
+                (DisplayName: "QuickBitcoin", Name: "quickbitcoin"),
+                (DisplayName: "Tidex", Name: "tidex"),
+                (DisplayName: "Tokenomy", Name: "tokenomy"),
+                (DisplayName: "Bitcoin.co.id", Name: "bitcoin_co_id"),
+                (DisplayName: "Kryptono", Name: "kryptono"),
                 (DisplayName: "Bitso", Name: "bitso"),
+                (DisplayName: "Korbit", Name: "korbit"),
+                (DisplayName: "Yobit", Name: "yobit"),
+                (DisplayName: "BitBargain", Name: "bitbargain"),
+                (DisplayName: "Livecoin", Name: "livecoin"),
+                (DisplayName: "Hotbit", Name: "hotbit"),
+                (DisplayName: "Coincheck", Name: "coincheck"),
+                (DisplayName: "Binance", Name: "binance"),
+                (DisplayName: "Bit-Z", Name: "bitz"),
+                (DisplayName: "Coinbase Pro", Name: "coinbasepro"),
+                (DisplayName: "Rock Trading", Name: "rocktrading"),
+                (DisplayName: "Bittrex", Name: "bittrex"),
+                (DisplayName: "BitBay", Name: "bitbay"),
+                (DisplayName: "Tokenize", Name: "tokenize"),
+                (DisplayName: "Hitbtc", Name: "hitbtc"),
+                (DisplayName: "Upbit", Name: "upbit"),
+                (DisplayName: "Bitstamp", Name: "bitstamp"),
+                (DisplayName: "Luno", Name: "luno"),
+                (DisplayName: "Trade.io", Name: "tradeio"),
+                (DisplayName: "LocalBitcoins", Name: "localbitcoins"),
+                (DisplayName: "Independent Reserve", Name: "independentreserve"),
+                (DisplayName: "Coinsquare", Name: "coinsquare"),
+                (DisplayName: "Exmoney", Name: "exmoney"),
+                (DisplayName: "Coinegg", Name: "coinegg"),
+                (DisplayName: "FYB-SG", Name: "fybsg"),
+                (DisplayName: "Cryptonit", Name: "cryptonit"),
+                (DisplayName: "BTCTurk", Name: "btcturk"),
+                (DisplayName: "bitFlyer", Name: "bitflyer"),
+                (DisplayName: "Negocie Coins", Name: "negociecoins"),
+                (DisplayName: "OasisDEX", Name: "oasisdex"),
+                (DisplayName: "CoinMate", Name: "coinmate"),
+                (DisplayName: "BitForex", Name: "bitforex"),
+                (DisplayName: "Bitsquare", Name: "bitsquare"),
+                (DisplayName: "FYB-SE", Name: "fybse"),
+                (DisplayName: "itBit", Name: "itbit"),
                 })
             {
                 AvailableExchanges.TryAdd(item.Name, new CoinAverageExchange(item.Name, item.DisplayName, $"https://apiv2.bitcoinaverage.com/exchanges/{item.Name}"));
             }
+            // Keep back-compat
+            AvailableExchanges.Add(new CoinAverageExchange("gdax", string.Empty, $"https://apiv2.bitcoinaverage.com/exchanges/coinbasepro"));
         }
 
         public Task AddHeader(HttpRequestMessage message)

BTCPayServer.Rating/Services/RateProviderFactory.cs

@@ -7,6 +7,7 @@ using System.Threading.Tasks;
 using BTCPayServer.Rating;
 using ExchangeSharp;
 using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 
 namespace BTCPayServer.Services.Rates
@@ -115,7 +116,6 @@ namespace BTCPayServer.Services.Rates
             Providers.Add("bitbank", new BitbankRateProvider(_httpClientFactory?.CreateClient("EXCHANGE_BITBANK")));
 
             // Those exchanges make multiple requests when calling GetTickers so we remove them
-            //DirectProviders.Add("gdax", new ExchangeSharpRateProvider("gdax", new ExchangeGdaxAPI()));
             //DirectProviders.Add("gemini", new ExchangeSharpRateProvider("gemini", new ExchangeGeminiAPI()));
             //DirectProviders.Add("bitfinex", new ExchangeSharpRateProvider("bitfinex", new ExchangeBitfinexAPI()));
             //DirectProviders.Add("okex", new ExchangeSharpRateProvider("okex", new ExchangeOkexAPI()));

BTCPayServer.Tests/AuthenticationTests.cs

@@ -0,0 +1,368 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+using AspNet.Security.OpenIdConnect.Primitives;
+using BTCPayServer.Tests.Logging;
+using Microsoft.IdentityModel.Protocols.OpenIdConnect;
+using Xunit;
+using Xunit.Abstractions;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using BTCPayServer.Data;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using OpenIddict.Abstractions;
+using OpenQA.Selenium;
+
+namespace BTCPayServer.Tests
+{
+    public class AuthenticationTests
+    {
+        public AuthenticationTests(ITestOutputHelper helper)
+        {
+            Logs.Tester = new XUnitLog(helper) {Name = "Tests"};
+            Logs.LogProvider = new XUnitLogProvider(helper);
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async Task GetRedirectedToLoginPathOnChallenge()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var client = tester.PayTester.HttpClient;
+                //Wallets endpoint is protected
+                var response = await client.GetAsync("wallets");
+                var urlPath = response.RequestMessage.RequestUri.ToString()
+                    .Replace(tester.PayTester.ServerUri.ToString(), "");
+                //Cookie Challenge redirects you to login page
+                Assert.StartsWith("Account/Login", urlPath, StringComparison.InvariantCultureIgnoreCase);
+
+                var queryString = response.RequestMessage.RequestUri.ParseQueryString();
+
+                Assert.NotNull(queryString["ReturnUrl"]);
+                Assert.Equal("/wallets", queryString["ReturnUrl"]);
+            }
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async Task CanGetOpenIdConfiguration()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                using (var response =
+                    await tester.PayTester.HttpClient.GetAsync("/.well-known/openid-configuration"))
+                {
+                    using (var streamToReadFrom = new StreamReader(await response.Content.ReadAsStreamAsync()))
+                    {
+                        var json = await streamToReadFrom.ReadToEndAsync();
+                        Assert.NotNull(json);
+                        var configuration = OpenIdConnectConfiguration.Create(json);
+                        Assert.NotNull(configuration);
+                    }
+                }
+            }
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async Task CanUseNonInteractiveFlows()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var token = await RegisterPasswordClientAndGetAccessToken(user, null, tester);
+                await TestApiAgainstAccessToken(token, tester, user);
+                token = await RegisterPasswordClientAndGetAccessToken(user, "secret", tester);
+                await TestApiAgainstAccessToken(token, tester, user);
+                token = await RegisterClientCredentialsFlowAndGetAccessToken(user, "secret", tester);
+                await TestApiAgainstAccessToken(token, tester, user);
+            }
+        }
+
+        [Trait("Selenium", "Selenium")]
+        [Fact]
+        public async Task CanUseImplicitFlow()
+        {
+            using (var s = SeleniumTester.Create())
+            {
+                s.Start();
+                var tester = s.Server;
+
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var id = Guid.NewGuid().ToString();
+                var redirecturi = new Uri("http://127.0.0.1/oidc-callback");
+                var openIdClient = await user.RegisterOpenIdClient(
+                    new OpenIddictApplicationDescriptor()
+                    {
+                        ClientId = id,
+                        DisplayName = id,
+                        Permissions = {OpenIddictConstants.Permissions.GrantTypes.Implicit},
+                        RedirectUris = {redirecturi}
+                    });
+                var implicitAuthorizeUrl = new Uri(tester.PayTester.ServerUri,
+                    $"connect/authorize?response_type=token&client_id={id}&redirect_uri={redirecturi.AbsoluteUri}&scope=openid&nonce={Guid.NewGuid().ToString()}");
+                s.Driver.Navigate().GoToUrl(implicitAuthorizeUrl);
+                s.Login(user.RegisterDetails.Email, user.RegisterDetails.Password);
+                var url = s.Driver.Url;
+                var results = url.Split("#").Last().Split("&")
+                    .ToDictionary(s1 => s1.Split("=")[0], s1 => s1.Split("=")[1]);
+                await TestApiAgainstAccessToken(results["access_token"], tester, user);
+
+
+                //in Implicit mode, you renew your token  by hitting the same endpoint but adding prompt=none. If you are still logged in on the site, you will receive a fresh token.
+                var implicitAuthorizeUrlSilentModel = new Uri($"{implicitAuthorizeUrl.OriginalString}&prompt=none");
+                s.Driver.Navigate().GoToUrl(implicitAuthorizeUrl);
+                url = s.Driver.Url;
+                results = url.Split("#").Last().Split("&").ToDictionary(s1 => s1.Split("=")[0], s1 => s1.Split("=")[1]);
+                await TestApiAgainstAccessToken(results["access_token"], tester, user);
+
+                LogoutFlow(tester, id, s);
+            }
+        }
+
+        void LogoutFlow(ServerTester tester, string clientId, SeleniumTester seleniumTester)
+        {
+            var logoutUrl = new Uri(tester.PayTester.ServerUri,
+                $"connect/logout?response_type=token&client_id={clientId}");
+            seleniumTester.Driver.Navigate().GoToUrl(logoutUrl);
+            seleniumTester.GoToHome();
+            Assert.Throws<NoSuchElementException>(() => seleniumTester.Driver.FindElement(By.Id("Logout")));
+            
+        }
+
+        [Trait("Selenium", "Selenium")]
+        [Fact]
+        public async Task CanUseCodeFlow()
+        {
+            using (var s = SeleniumTester.Create())
+            {
+                s.Start();
+                var tester = s.Server;
+
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var id = Guid.NewGuid().ToString();
+                var redirecturi = new Uri("http://127.0.0.1/oidc-callback");
+                var secret = "secret";
+                var openIdClient = await user.RegisterOpenIdClient(
+                    new OpenIddictApplicationDescriptor()
+                    {
+                        ClientId = id,
+                        DisplayName = id,
+                        Permissions =
+                        {
+                            OpenIddictConstants.Permissions.GrantTypes.AuthorizationCode,
+                            OpenIddictConstants.Permissions.GrantTypes.RefreshToken
+                        },
+                        RedirectUris = {redirecturi}
+                    }, secret);
+                var authorizeUrl = new Uri(tester.PayTester.ServerUri,
+                    $"connect/authorize?response_type=code&client_id={id}&redirect_uri={redirecturi.AbsoluteUri}&scope=openid offline_access&state={Guid.NewGuid().ToString()}");
+                s.Driver.Navigate().GoToUrl(authorizeUrl);
+                s.Login(user.RegisterDetails.Email, user.RegisterDetails.Password);
+                var url = s.Driver.Url;
+                var results = url.Split("?").Last().Split("&")
+                    .ToDictionary(s1 => s1.Split("=")[0], s1 => s1.Split("=")[1]);
+
+                var httpClient = tester.PayTester.HttpClient;
+
+                var httpRequest = new HttpRequestMessage(HttpMethod.Post,
+                    new Uri(tester.PayTester.ServerUri, "/connect/token"))
+                {
+                    Content = new FormUrlEncodedContent(new List<KeyValuePair<string, string>>()
+                    {
+                        new KeyValuePair<string, string>("grant_type",
+                            OpenIddictConstants.GrantTypes.AuthorizationCode),
+                        new KeyValuePair<string, string>("client_id", openIdClient.ClientId),
+                        new KeyValuePair<string, string>("client_secret", secret),
+                        new KeyValuePair<string, string>("code", results["code"]),
+                        new KeyValuePair<string, string>("redirect_uri", redirecturi.AbsoluteUri)
+                    })
+                };
+
+
+                var response = await httpClient.SendAsync(httpRequest);
+
+                Assert.True(response.IsSuccessStatusCode);
+
+                string content = await response.Content.ReadAsStringAsync();
+                var result = JObject.Parse(content).ToObject<OpenIdConnectResponse>();
+
+                await TestApiAgainstAccessToken(result.AccessToken, tester, user);
+
+                var refreshedAccessToken = await RefreshAnAccessToken(result.RefreshToken, httpClient, id, secret);
+
+                await TestApiAgainstAccessToken(refreshedAccessToken, tester, user);
+            }
+        }
+
+        private static async Task<string> RefreshAnAccessToken(string refreshToken, HttpClient client, string clientId,
+            string clientSecret = null)
+        {
+            var httpRequest = new HttpRequestMessage(HttpMethod.Post,
+                new Uri(client.BaseAddress, "/connect/token"))
+            {
+                Content = new FormUrlEncodedContent(new List<KeyValuePair<string, string>>()
+                {
+                    new KeyValuePair<string, string>("grant_type",
+                        OpenIddictConstants.GrantTypes.RefreshToken),
+                    new KeyValuePair<string, string>("client_id", clientId),
+                    new KeyValuePair<string, string>("client_secret", clientSecret),
+                    new KeyValuePair<string, string>("refresh_token", refreshToken)
+                })
+            };
+
+            var response = await client.SendAsync(httpRequest);
+
+            Assert.True(response.IsSuccessStatusCode);
+
+            string content = await response.Content.ReadAsStringAsync();
+            var result = JObject.Parse(content).ToObject<OpenIdConnectResponse>();
+            Assert.NotEmpty(result.AccessToken);
+            Assert.Null(result.Error);
+            return result.AccessToken;
+        }
+
+        private static async Task<string> RegisterClientCredentialsFlowAndGetAccessToken(TestAccount user,
+            string secret,
+            ServerTester tester)
+        {
+            var id = Guid.NewGuid().ToString();
+            var openIdClient = await user.RegisterOpenIdClient(
+                new OpenIddictApplicationDescriptor()
+                {
+                    ClientId = id,
+                    DisplayName = id,
+                    Permissions = {OpenIddictConstants.Permissions.GrantTypes.ClientCredentials}
+                }, secret);
+
+
+            var httpClient = tester.PayTester.HttpClient;
+
+            var httpRequest = new HttpRequestMessage(HttpMethod.Post,
+                new Uri(tester.PayTester.ServerUri, "/connect/token"))
+            {
+                Content = new FormUrlEncodedContent(new List<KeyValuePair<string, string>>()
+                {
+                    new KeyValuePair<string, string>("grant_type",
+                        OpenIddictConstants.GrantTypes.ClientCredentials),
+                    new KeyValuePair<string, string>("client_id", openIdClient.ClientId),
+                    new KeyValuePair<string, string>("client_secret", secret)
+                })
+            };
+
+
+            var response = await httpClient.SendAsync(httpRequest);
+
+            Assert.True(response.IsSuccessStatusCode);
+
+            string content = await response.Content.ReadAsStringAsync();
+            var result = JObject.Parse(content).ToObject<OpenIdConnectResponse>();
+            Assert.NotEmpty(result.AccessToken);
+            Assert.Null(result.Error);
+            return result.AccessToken;
+        }
+
+        private static async Task<string> RegisterPasswordClientAndGetAccessToken(TestAccount user, string secret,
+            ServerTester tester)
+        {
+            var id = Guid.NewGuid().ToString();
+            var openIdClient = await user.RegisterOpenIdClient(
+                new OpenIddictApplicationDescriptor()
+                {
+                    ClientId = id,
+                    DisplayName = id,
+                    Permissions = {OpenIddictConstants.Permissions.GrantTypes.Password}
+                }, secret);
+
+
+            var httpClient = tester.PayTester.HttpClient;
+
+            var httpRequest = new HttpRequestMessage(HttpMethod.Post,
+                new Uri(tester.PayTester.ServerUri, "/connect/token"))
+            {
+                Content = new FormUrlEncodedContent(new List<KeyValuePair<string, string>>()
+                {
+                    new KeyValuePair<string, string>("grant_type", OpenIddictConstants.GrantTypes.Password),
+                    new KeyValuePair<string, string>("username", user.RegisterDetails.Email),
+                    new KeyValuePair<string, string>("password", user.RegisterDetails.Password),
+                    new KeyValuePair<string, string>("client_id", openIdClient.ClientId),
+                    new KeyValuePair<string, string>("client_secret", secret)
+                })
+            };
+
+
+            var response = await httpClient.SendAsync(httpRequest);
+
+            Assert.True(response.IsSuccessStatusCode);
+
+            string content = await response.Content.ReadAsStringAsync();
+            var result = JObject.Parse(content).ToObject<OpenIdConnectResponse>();
+            Assert.NotEmpty(result.AccessToken);
+            Assert.Null(result.Error);
+            return result.AccessToken;
+        }
+
+        async Task TestApiAgainstAccessToken(string accessToken, ServerTester tester, TestAccount testAccount)
+        {
+            var resultUser =
+                await TestApiAgainstAccessToken<string>(accessToken, "api/test/me/id",
+                    tester.PayTester.HttpClient);
+            Assert.Equal(testAccount.UserId, resultUser);
+
+            var secondUser = tester.NewAccount();
+            secondUser.GrantAccess();
+
+            var resultStores =
+                await TestApiAgainstAccessToken<StoreData[]>(accessToken, "api/test/me/stores",
+                    tester.PayTester.HttpClient);
+            Assert.Contains(resultStores,
+                data => data.Id.Equals(testAccount.StoreId, StringComparison.InvariantCultureIgnoreCase));
+            Assert.DoesNotContain(resultStores,
+                data => data.Id.Equals(secondUser.StoreId, StringComparison.InvariantCultureIgnoreCase));
+
+            Assert.True(await TestApiAgainstAccessToken<bool>(accessToken,
+                $"api/test/me/stores/{testAccount.StoreId}/can-edit",
+                tester.PayTester.HttpClient));
+
+
+            Assert.Equal(testAccount.RegisterDetails.IsAdmin, await TestApiAgainstAccessToken<bool>(accessToken,
+                $"api/test/me/is-admin",
+                tester.PayTester.HttpClient));
+
+            await Assert.ThrowsAnyAsync<HttpRequestException>(async () =>
+            {
+                await TestApiAgainstAccessToken<bool>(accessToken, $"api/test/me/stores/{secondUser.StoreId}/can-edit",
+                    tester.PayTester.HttpClient);
+            });
+        }
+
+        public async Task<T> TestApiAgainstAccessToken<T>(string accessToken, string url, HttpClient client)
+        {
+            var httpRequest = new HttpRequestMessage(HttpMethod.Get,
+                new Uri(client.BaseAddress, url));
+            httpRequest.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
+            var result = await client.SendAsync(httpRequest);
+            result.EnsureSuccessStatusCode();
+
+            var rawJson = await result.Content.ReadAsStringAsync();
+            if (typeof(T).IsPrimitive || typeof(T) == typeof(string))
+            {
+                return (T)Convert.ChangeType(rawJson, typeof(T));
+            }
+
+            return JsonConvert.DeserializeObject<T>(rawJson);
+        }
+    }
+}

BTCPayServer.Tests/BTCPayServer.Tests.csproj

@@ -11,6 +11,8 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.0.1" />
+    <PackageReference Include="Selenium.WebDriver" Version="3.141.0" />
+    <PackageReference Include="Selenium.WebDriver.ChromeDriver" Version="74.0.3729.6" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1">
       <PrivateAssets>all</PrivateAssets>
@@ -31,6 +33,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\BTCPayServer.Rating\BTCPayServer.Rating.csproj" />
     <ProjectReference Include="..\BTCPayServer\BTCPayServer.csproj" />
   </ItemGroup>
 

BTCPayServer.Tests/BTCPayServerTester.cs

@@ -1,4 +1,4 @@
-using BTCPayServer.Configuration;
+using BTCPayServer.Configuration;
 using System.Linq;
 using BTCPayServer.HostedServices;
 using BTCPayServer.Hosting;
@@ -33,9 +33,12 @@ using System.Security.Claims;
 using System.Security.Principal;
 using System.Text;
 using System.Threading;
+using AspNet.Security.OpenIdConnect.Primitives;
 using Xunit;
 using BTCPayServer.Services;
 using System.Net.Http;
+using Microsoft.AspNetCore.Hosting.Server.Features;
+using System.Threading.Tasks;
 
 namespace BTCPayServer.Tests
 {
@@ -102,12 +105,16 @@ namespace BTCPayServer.Tests
 
             StringBuilder config = new StringBuilder();
             config.AppendLine($"{chain.ToLowerInvariant()}=1");
+            if (InContainer)
+            {
+                config.AppendLine($"bind=0.0.0.0");
+            }
             config.AppendLine($"port={Port}");
             config.AppendLine($"chains=btc,ltc");
 
             config.AppendLine($"btc.explorer.url={NBXplorerUri.AbsoluteUri}");
             config.AppendLine($"btc.explorer.cookiefile=0");
-
+            config.AppendLine("allow-admin-registration=1");
             config.AppendLine($"ltc.explorer.url={LTCNBXplorerUri.AbsoluteUri}");
             config.AppendLine($"ltc.explorer.cookiefile=0");
             config.AppendLine($"btc.lightning={IntegratedLightning.AbsoluteUri}");
@@ -141,14 +148,18 @@ namespace BTCPayServer.Tests
                     .UseKestrel()
                     .UseStartup<Startup>()
                     .Build();
-            _Host.Start();
+            _Host.StartWithTasksAsync().GetAwaiter().GetResult();
+
+            var urls = _Host.ServerFeatures.Get<IServerAddressesFeature>().Addresses;
+            foreach (var url in urls)
+            {
+                Logs.Tester.LogInformation("Listening on " + url);
+            }
+            Logs.Tester.LogInformation("Server URI " + ServerUri);
+
             InvoiceRepository = (InvoiceRepository)_Host.Services.GetService(typeof(InvoiceRepository));
             StoreRepository = (StoreRepository)_Host.Services.GetService(typeof(StoreRepository));
-            var dashBoard = (NBXplorerDashboard)_Host.Services.GetService(typeof(NBXplorerDashboard));
-            while(!dashBoard.IsFullySynched())
-            {
-                Thread.Sleep(10);
-            }
+            Networks = (BTCPayNetworkProvider)_Host.Services.GetService(typeof(BTCPayNetworkProvider));
 
             if (MockRates)
             {
@@ -209,6 +220,35 @@ namespace BTCPayServer.Tests
                 });
                 rateProvider.Providers.Add("bittrex", bittrex);
             }
+
+            
+
+            WaitSiteIsOperational().GetAwaiter().GetResult();
+        }
+
+        private async Task WaitSiteIsOperational()
+        {
+            var synching = WaitIsFullySynched();
+            var accessingHomepage = WaitCanAccessHomepage();
+            await Task.WhenAll(synching, accessingHomepage).ConfigureAwait(false);
+        }
+
+        private async Task WaitCanAccessHomepage()
+        {
+            var resp = await HttpClient.GetAsync("/").ConfigureAwait(false);
+            while (resp.StatusCode != HttpStatusCode.OK)
+            {
+                await Task.Delay(10).ConfigureAwait(false);
+            }
+        }
+
+        private async Task WaitIsFullySynched()
+        {
+            var dashBoard = GetService<NBXplorerDashboard>();
+            while (!dashBoard.IsFullySynched())
+            {
+                await Task.Delay(10).ConfigureAwait(false);
+            }
         }
 
         private string FindBTCPayServerDirectory()
@@ -226,6 +266,7 @@ namespace BTCPayServer.Tests
         }
         public InvoiceRepository InvoiceRepository { get; private set; }
         public StoreRepository StoreRepository { get; private set; }
+        public BTCPayNetworkProvider Networks { get; private set; }
         public Uri IntegratedLightning { get; internal set; }
         public bool InContainer { get; internal set; }
 
@@ -234,6 +275,8 @@ namespace BTCPayServer.Tests
             return _Host.Services.GetRequiredService<T>();
         }
 
+        public IServiceProvider ServiceProvider => _Host.Services; 
+
         public T GetController<T>(string userId = null, string storeId = null, Claim[] additionalClaims = null) where T : Controller
         {
             var context = new DefaultHttpContext();
@@ -243,7 +286,7 @@ namespace BTCPayServer.Tests
             if (userId != null)
             {
                 List<Claim> claims = new List<Claim>();
-                claims.Add(new Claim(ClaimTypes.NameIdentifier, userId));
+                claims.Add(new Claim(OpenIdConnectConstants.Claims.Subject, userId));
                 if (additionalClaims != null)
                     claims.AddRange(additionalClaims);
                 context.User = new ClaimsPrincipal(new ClaimsIdentity(claims.ToArray(), Policies.CookieAuthentication));

BTCPayServer.Tests/ChangellyTests.cs

@@ -27,7 +27,7 @@ namespace BTCPayServer.Tests
             Logs.LogProvider = new XUnitLogProvider(helper);
         }
 
-        [Fact]
+        [Fact(Timeout = 60000)]
         [Trait("Integration", "Integration")]
         public async void CanSetChangellyPaymentMethod()
         {

BTCPayServer.Tests/Dockerfile

@@ -5,10 +5,24 @@ ENV LC_ALL en_US.UTF-8
 ENV LANG en_US.UTF-8
 
 WORKDIR /source
+COPY Build/Common.csproj Build/Common.csproj
 COPY BTCPayServer/BTCPayServer.csproj BTCPayServer/BTCPayServer.csproj
+COPY BTCPayServer.Common/BTCPayServer.Common.csproj BTCPayServer.Common/BTCPayServer.Common.csproj
+COPY BTCPayServer.Rating/BTCPayServer.Rating.csproj BTCPayServer.Rating/BTCPayServer.Rating.csproj
 COPY BTCPayServer.Tests/BTCPayServer.Tests.csproj BTCPayServer.Tests/BTCPayServer.Tests.csproj
 RUN dotnet restore BTCPayServer.Tests/BTCPayServer.Tests.csproj
+
+ENV DOTNET_SYSTEM_GLOBALIZATION_INVARIANT false
+
+ENV LC_ALL en_US.UTF-8
+ENV LANG en_US.UTF-8
+
+RUN apk add --no-cache chromium chromium-chromedriver icu-libs
+
+ENV SCREEN_HEIGHT 600 \
+    SCREEN_WIDTH 1200
+
 COPY . .
-RUN dotnet build
+RUN cd BTCPayServer.Tests && dotnet build
 WORKDIR /source/BTCPayServer.Tests
 ENTRYPOINT ["./docker-entrypoint.sh"]

BTCPayServer.Tests/Extensions.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using BTCPayServer.Tests.Logging;
+using Microsoft.AspNetCore.Mvc;
+using OpenQA.Selenium;
+using Xunit;
+
+namespace BTCPayServer.Tests
+{
+    public static class Extensions
+    {
+        public static void ScrollTo(this IWebDriver driver, By by)
+        {
+            var element = driver.FindElement(by);
+            ((IJavaScriptExecutor)driver).ExecuteScript($"window.scrollBy({element.Location.X},{element.Location.Y});");
+        }
+        /// <summary>
+        /// Sometimes the chrome driver is fucked up and we need some magic to click on the element.
+        /// </summary>
+        /// <param name="element"></param>
+        public static void ForceClick(this IWebElement element)
+        {
+            element.SendKeys(Keys.Return);
+        }
+        public static void AssertNoError(this IWebDriver driver)
+        {
+            try
+            {
+                Assert.NotEmpty(driver.FindElements(By.ClassName("navbar-brand")));
+            }
+            catch
+            {
+                StringBuilder builder = new StringBuilder();
+                builder.AppendLine();
+                foreach (var logKind in new []{ LogType.Browser, LogType.Client, LogType.Driver, LogType.Server })
+                {
+                    try
+                    {
+                        var logs = driver.Manage().Logs.GetLog(logKind);
+                        builder.AppendLine($"Selenium [{logKind}]:");
+                        foreach (var entry in logs)
+                        {
+                            builder.AppendLine($"[{entry.Level}]: {entry.Message}");
+                        }
+                    }
+                    catch { }
+                    builder.AppendLine($"---------");
+                }
+                Logs.Tester.LogInformation(builder.ToString());
+                builder = new StringBuilder();
+                builder.AppendLine($"Selenium [Sources]:");
+                builder.AppendLine(driver.PageSource);
+                builder.AppendLine($"---------");
+                Logs.Tester.LogInformation(builder.ToString());
+                throw;
+            }
+        }
+        public static T AssertViewModel<T>(this IActionResult result)
+        {
+            Assert.NotNull(result);
+            var vr = Assert.IsType<ViewResult>(result);
+            return Assert.IsType<T>(vr.Model);
+        }
+        public static async Task<T> AssertViewModelAsync<T>(this Task<IActionResult> task)
+        {
+            var result = await task;
+            Assert.NotNull(result);
+            var vr = Assert.IsType<ViewResult>(result);
+            return Assert.IsType<T>(vr.Model);
+        }
+    }
+}

BTCPayServer.Tests/PSBTTests.cs

@@ -0,0 +1,126 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using BTCPayServer.Controllers;
+using BTCPayServer.Models.WalletViewModels;
+using BTCPayServer.Tests.Logging;
+using Microsoft.AspNetCore.Mvc;
+using NBitcoin;
+using NBitpayClient;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace BTCPayServer.Tests
+{
+    public class PSBTTests
+    {
+        public PSBTTests(ITestOutputHelper helper)
+        {
+            Logs.Tester = new XUnitLog(helper) { Name = "Tests" };
+            Logs.LogProvider = new XUnitLogProvider(helper);
+        }
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async Task CanPlayWithPSBT()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                user.RegisterDerivationScheme("BTC");
+                var invoice = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Price = 10,
+                    Currency = "USD",
+                    PosData = "posData",
+                    OrderId = "orderId",
+                    ItemDesc = "Some \", description",
+                    FullNotifications = true
+                }, Facade.Merchant);
+                var cashCow = tester.ExplorerNode;
+                var invoiceAddress = BitcoinAddress.Create(invoice.CryptoInfo[0].Address, cashCow.Network);
+                cashCow.SendToAddress(invoiceAddress, Money.Coins(1.5m));
+                TestUtils.Eventually(() =>
+                {
+                    invoice = user.BitPay.GetInvoice(invoice.Id);
+                    Assert.Equal("paid", invoice.Status);
+                });
+
+                var walletController = tester.PayTester.GetController<WalletsController>(user.UserId);
+                var walletId = new WalletId(user.StoreId, "BTC");
+                var sendDestination = new Key().PubKey.Hash.GetAddress(user.SupportedNetwork.NBitcoinNetwork).ToString();
+                var sendModel = new WalletSendModel()
+                {
+                    Outputs = new List<WalletSendModel.TransactionOutput>()
+                    {
+                        new WalletSendModel.TransactionOutput()
+                        {
+                            DestinationAddress = sendDestination,
+                            Amount = 0.1m,
+                        }
+                    },
+                    FeeSatoshiPerByte = 1,
+                    CurrentBalance = 1.5m
+                };
+                var vmLedger = await walletController.WalletSend(walletId, sendModel, command: "ledger").AssertViewModelAsync<WalletSendLedgerModel>();
+                PSBT.Parse(vmLedger.PSBT, user.SupportedNetwork.NBitcoinNetwork);
+                BitcoinAddress.Create(vmLedger.HintChange, user.SupportedNetwork.NBitcoinNetwork);
+                Assert.NotNull(vmLedger.SuccessPath);
+                Assert.NotNull(vmLedger.WebsocketPath);
+
+                var redirectedPSBT = (string)Assert.IsType<RedirectToActionResult>(await walletController.WalletSend(walletId, sendModel, command: "analyze-psbt")).RouteValues["psbt"];
+                var vmPSBT = await walletController.WalletPSBT(walletId, new WalletPSBTViewModel() { PSBT = redirectedPSBT }).AssertViewModelAsync<WalletPSBTViewModel>();
+                var unsignedPSBT = PSBT.Parse(vmPSBT.PSBT, user.SupportedNetwork.NBitcoinNetwork);
+                Assert.NotNull(vmPSBT.Decoded);
+
+                var filePSBT = (FileContentResult)(await walletController.WalletPSBT(walletId, vmPSBT, "save-psbt"));
+                PSBT.Load(filePSBT.FileContents, user.SupportedNetwork.NBitcoinNetwork);
+
+                await walletController.WalletPSBT(walletId, vmPSBT, "ledger").AssertViewModelAsync<WalletSendLedgerModel>();
+                var vmPSBT2 = await walletController.WalletPSBT(walletId, vmPSBT, "broadcast").AssertViewModelAsync<WalletPSBTReadyViewModel>();
+                Assert.NotEmpty(vmPSBT2.Inputs.Where(i => i.Error != null));
+                Assert.Equal(vmPSBT.PSBT, vmPSBT2.PSBT);
+
+                var signedPSBT = unsignedPSBT.Clone();
+                signedPSBT.SignAll(user.DerivationScheme, user.ExtKey);
+                vmPSBT.PSBT = signedPSBT.ToBase64();
+                var psbtReady = await walletController.WalletPSBT(walletId, vmPSBT, "broadcast").AssertViewModelAsync<WalletPSBTReadyViewModel>();
+                Assert.Equal(2 + 1, psbtReady.Destinations.Count); // The fee is a destination
+                Assert.Contains(psbtReady.Destinations, d => d.Destination == sendDestination && !d.Positive);
+                Assert.Contains(psbtReady.Destinations, d => d.Positive);
+                var redirect = Assert.IsType<RedirectToActionResult>(await walletController.WalletPSBTReady(walletId, psbtReady, command: "broadcast"));
+                Assert.Equal(nameof(walletController.WalletTransactions), redirect.ActionName);
+
+                vmPSBT.PSBT = unsignedPSBT.ToBase64();
+                var combineVM = await walletController.WalletPSBT(walletId, vmPSBT, "combine").AssertViewModelAsync<WalletPSBTCombineViewModel>();
+                Assert.Equal(vmPSBT.PSBT, combineVM.OtherPSBT);
+                combineVM.PSBT = signedPSBT.ToBase64();
+                vmPSBT = await walletController.WalletPSBTCombine(walletId, combineVM).AssertViewModelAsync<WalletPSBTViewModel>();
+
+                var signedPSBT2 = PSBT.Parse(vmPSBT.PSBT, user.SupportedNetwork.NBitcoinNetwork);
+                Assert.True(signedPSBT.TryFinalize(out _));
+                Assert.True(signedPSBT2.TryFinalize(out _));
+                Assert.Equal(signedPSBT, signedPSBT2);
+
+                // Can use uploaded file?
+                combineVM.PSBT = null;
+                combineVM.UploadedPSBTFile = TestUtils.GetFormFile("signedPSBT", signedPSBT.ToBytes());
+                vmPSBT = await walletController.WalletPSBTCombine(walletId, combineVM).AssertViewModelAsync<WalletPSBTViewModel>();
+                signedPSBT2 = PSBT.Parse(vmPSBT.PSBT, user.SupportedNetwork.NBitcoinNetwork);
+                Assert.True(signedPSBT.TryFinalize(out _));
+                Assert.True(signedPSBT2.TryFinalize(out _));
+                Assert.Equal(signedPSBT, signedPSBT2);
+
+                var ready = (await walletController.WalletPSBTReady(walletId, signedPSBT.ToBase64())).AssertViewModel<WalletPSBTReadyViewModel>();
+                Assert.Equal(signedPSBT.ToBase64(), ready.PSBT);
+                redirect = Assert.IsType<RedirectToActionResult>(await walletController.WalletPSBTReady(walletId, ready, command: "analyze-psbt"));
+                Assert.Equal(signedPSBT.ToBase64(), (string)redirect.RouteValues["psbt"]);
+                redirect = Assert.IsType<RedirectToActionResult>(await walletController.WalletPSBTReady(walletId, ready, command: "broadcast"));
+                Assert.Equal(nameof(walletController.WalletTransactions), redirect.ActionName);
+            }
+        }
+    }
+}

BTCPayServer.Tests/README.md

@@ -41,10 +41,15 @@ You can call bitcoin-cli inside the container with `docker exec`, for example, i
 ```
 
 If you are using Powershell:
-```
+```powershell
 .\docker-bitcoin-cli.ps1 sendtoaddress "mohu16LH66ptoWGEL1GtP6KHTBJYXMWhEf" 0.23111090
 ```
 
+You can also generate blocks:
+```powershell
+.\docker-bitcoin-generate.ps1 3
+```
+
 ### Using the test litecoin-cli
 
 Same as bitcoin-cli, but with `.\docker-litecoin-cli.ps1` and `.\docker-litecoin-cli.sh` instead. 

BTCPayServer.Tests/RateRulesTest.cs

@@ -34,7 +34,7 @@ namespace BTCPayServer.Tests
             builder.AppendLine("DOGE_X = DOGE_BTC * BTC_X * 1.1");
             builder.AppendLine("DOGE_BTC = Bittrex(DOGE_BTC)");
             builder.AppendLine("// Some other cool comments");
-            builder.AppendLine("BTC_usd = GDax(BTC_USD)");
+            builder.AppendLine("BTC_usd = kraken(BTC_USD)");
             builder.AppendLine("BTC_X = Coinbase(BTC_X);");
             builder.AppendLine("X_X = CoinAverage(X_X) * 1.02");
 
@@ -45,14 +45,14 @@ namespace BTCPayServer.Tests
                 "DOGE_X = DOGE_BTC * BTC_X * 1.1;\n" +
                 "DOGE_BTC = bittrex(DOGE_BTC);\n" +
                 "// Some other cool comments\n" +
-                "BTC_USD = gdax(BTC_USD);\n" +
+                "BTC_USD = kraken(BTC_USD);\n" +
                 "BTC_X = coinbase(BTC_X);\n" +
                 "X_X = coinaverage(X_X) * 1.02;",
                 rules.ToString());
             var tests = new[]
             {
-                (Pair: "DOGE_USD", Expected: "bittrex(DOGE_BTC) * gdax(BTC_USD) * 1.1"),
-                (Pair: "BTC_USD", Expected: "gdax(BTC_USD)"),
+                (Pair: "DOGE_USD", Expected: "bittrex(DOGE_BTC) * kraken(BTC_USD) * 1.1"),
+                (Pair: "BTC_USD", Expected: "kraken(BTC_USD)"),
                 (Pair: "BTC_CAD", Expected: "coinbase(BTC_CAD)"),
                 (Pair: "DOGE_CAD", Expected: "bittrex(DOGE_BTC) * coinbase(BTC_CAD) * 1.1"),
                 (Pair: "LTC_CAD", Expected: "coinaverage(LTC_CAD) * 1.02"),
@@ -62,14 +62,14 @@ namespace BTCPayServer.Tests
                 Assert.Equal(test.Expected, rules.GetRuleFor(CurrencyPair.Parse(test.Pair)).ToString());
             }
             rules.Spread = 0.2m;
-            Assert.Equal("(bittrex(DOGE_BTC) * gdax(BTC_USD) * 1.1) * (0.8, 1.2)", rules.GetRuleFor(CurrencyPair.Parse("DOGE_USD")).ToString());
+            Assert.Equal("(bittrex(DOGE_BTC) * kraken(BTC_USD) * 1.1) * (0.8, 1.2)", rules.GetRuleFor(CurrencyPair.Parse("DOGE_USD")).ToString());
             ////////////////
 
             // Check errors conditions
             builder = new StringBuilder();
             builder.AppendLine("DOGE_X = LTC_CAD * BTC_X * 1.1");
             builder.AppendLine("DOGE_BTC = Bittrex(DOGE_BTC)");
-            builder.AppendLine("BTC_usd = GDax(BTC_USD)");
+            builder.AppendLine("BTC_usd = kraken(BTC_USD)");
             builder.AppendLine("LTC_CHF = LTC_CHF * 1.01");
             builder.AppendLine("BTC_X = Coinbase(BTC_X)");
             Assert.True(RateRules.TryParse(builder.ToString(), out rules));
@@ -77,7 +77,7 @@ namespace BTCPayServer.Tests
             tests = new[]
             {
                 (Pair: "LTC_CAD", Expected: "ERR_NO_RULE_MATCH(LTC_CAD)"),
-                (Pair: "DOGE_USD", Expected: "ERR_NO_RULE_MATCH(LTC_CAD) * gdax(BTC_USD) * 1.1"),
+                (Pair: "DOGE_USD", Expected: "ERR_NO_RULE_MATCH(LTC_CAD) * kraken(BTC_USD) * 1.1"),
                 (Pair: "LTC_CHF", Expected: "ERR_TOO_MUCH_NESTED_CALLS(LTC_CHF) * 1.01"),
             };
             foreach (var test in tests)
@@ -90,15 +90,15 @@ namespace BTCPayServer.Tests
             builder = new StringBuilder();
             builder.AppendLine("DOGE_X = DOGE_BTC * BTC_X * 1.1");
             builder.AppendLine("DOGE_BTC = Bittrex(DOGE_BTC)");
-            builder.AppendLine("BTC_usd = GDax(BTC_USD)");
+            builder.AppendLine("BTC_usd = kraken(BTC_USD)");
             builder.AppendLine("BTC_X = Coinbase(BTC_X)");
             builder.AppendLine("X_X = CoinAverage(X_X) * 1.02");
             Assert.True(RateRules.TryParse(builder.ToString(), out rules));
 
             var tests2 = new[]
             {
-                (Pair: "DOGE_USD", Expected: "bittrex(DOGE_BTC) * gdax(BTC_USD) * 1.1", ExpectedExchangeRates: "bittrex(DOGE_BTC),gdax(BTC_USD)"),
-                (Pair: "BTC_USD", Expected: "gdax(BTC_USD)", ExpectedExchangeRates: "gdax(BTC_USD)"),
+                (Pair: "DOGE_USD", Expected: "bittrex(DOGE_BTC) * kraken(BTC_USD) * 1.1", ExpectedExchangeRates: "bittrex(DOGE_BTC),kraken(BTC_USD)"),
+                (Pair: "BTC_USD", Expected: "kraken(BTC_USD)", ExpectedExchangeRates: "kraken(BTC_USD)"),
                 (Pair: "BTC_CAD", Expected: "coinbase(BTC_CAD)", ExpectedExchangeRates: "coinbase(BTC_CAD)"),
                 (Pair: "DOGE_CAD", Expected: "bittrex(DOGE_BTC) * coinbase(BTC_CAD) * 1.1", ExpectedExchangeRates: "bittrex(DOGE_BTC),coinbase(BTC_CAD)"),
                 (Pair: "LTC_CAD", Expected: "coinaverage(LTC_CAD) * 1.02", ExpectedExchangeRates: "coinaverage(LTC_CAD)"),

BTCPayServer.Tests/SeleniumTester.cs

@@ -0,0 +1,151 @@
+using System;
+using BTCPayServer;
+using System.Linq;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Text;
+using NBitcoin;
+using OpenQA.Selenium;
+using OpenQA.Selenium.Chrome;
+using Xunit;
+using System.IO;
+using BTCPayServer.Tests.Logging;
+using System.Threading;
+
+namespace BTCPayServer.Tests
+{
+    public class SeleniumTester : IDisposable
+    {
+        public IWebDriver Driver { get; set; }
+        public ServerTester Server { get; set; }
+
+        public static SeleniumTester Create([CallerMemberNameAttribute] string scope = null)
+        {
+            var server = ServerTester.Create(scope);
+            return new SeleniumTester()
+            {
+                Server = server
+            };
+        }
+
+        public void Start()
+        {
+            Server.Start();
+            ChromeOptions options = new ChromeOptions();
+            options.AddArguments("headless"); // Comment to view browser
+            options.AddArguments("window-size=1200x600"); // Comment to view browser
+            options.AddArgument("shm-size=2g");
+            if (Server.PayTester.InContainer)
+            {
+                options.AddArgument("no-sandbox");
+            }
+            Driver = new ChromeDriver(Server.PayTester.InContainer ? "/usr/bin" : Directory.GetCurrentDirectory(), options);
+            Logs.Tester.LogInformation("Selenium: Using chrome driver");
+            Logs.Tester.LogInformation("Selenium: Browsing to " + Server.PayTester.ServerUri);
+            Logs.Tester.LogInformation($"Selenium: Resolution {Driver.Manage().Window.Size}");
+            Driver.Manage().Timeouts().ImplicitWait = TimeSpan.FromSeconds(10);
+            Driver.Navigate().GoToUrl(Server.PayTester.ServerUri);
+            Driver.AssertNoError();
+        }
+
+        public string Link(string relativeLink)
+        {
+            return Server.PayTester.ServerUri.AbsoluteUri.WithoutEndingSlash() + relativeLink.WithStartingSlash();
+        }
+
+        public string RegisterNewUser(bool isAdmin = false)
+        {
+            var usr = RandomUtils.GetUInt256().ToString() + "@a.com";
+            Driver.FindElement(By.Id("Register")).Click();
+            Driver.FindElement(By.Id("Email")).SendKeys(usr);
+            Driver.FindElement(By.Id("Password")).SendKeys("123456");
+            Driver.FindElement(By.Id("ConfirmPassword")).SendKeys("123456");
+            if (isAdmin)
+                Driver.FindElement(By.Id("IsAdmin")).Click();
+            Driver.FindElement(By.Id("RegisterButton")).Click();
+            Driver.AssertNoError();
+            return usr;
+        }
+
+        public string CreateNewStore()
+        {
+            var usr = "Store" + RandomUtils.GetUInt64().ToString();
+            Driver.FindElement(By.Id("Stores")).Click();
+            Driver.FindElement(By.Id("CreateStore")).Click();
+            Driver.FindElement(By.Id("Name")).SendKeys(usr);
+            Driver.FindElement(By.Id("Create")).Click();
+            return usr;
+        }
+
+        public void AddDerivationScheme(string derivationScheme = "xpub661MyMwAqRbcGABgHMUXDzPzH1tU7eZaAaJQXhDXsSxsqyQzQeU6kznNfSuAyqAK9UaWSaZaMFdNiY5BCF4zBPAzSnwfUAwUhwttuAKwfRX-[legacy]")
+        {
+            Driver.FindElement(By.Id("ModifyBTC")).ForceClick();
+            Driver.FindElement(By.ClassName("store-derivation-scheme")).SendKeys(derivationScheme);
+            Driver.FindElement(By.Id("Continue")).ForceClick();
+            Driver.FindElement(By.Id("Confirm")).ForceClick();
+            Driver.FindElement(By.Id("Save")).ForceClick();
+            return;
+        }
+
+        public void ClickOnAllSideMenus()
+        {
+            var links = Driver.FindElements(By.CssSelector(".nav-pills .nav-link")).Select(c => c.GetAttribute("href")).ToList();
+            Driver.AssertNoError();
+            Assert.NotEmpty(links);
+            foreach (var l in links)
+            {
+                Driver.Navigate().GoToUrl(l);
+                Driver.AssertNoError();
+            }
+        }
+
+        public void CreateInvoice(string random)
+        {
+            Driver.FindElement(By.Id("Invoices")).Click();
+            Driver.FindElement(By.Id("CreateNewInvoice")).Click();
+            Driver.FindElement(By.CssSelector("input#Amount.form-control")).SendKeys("100");
+            Driver.FindElement(By.Name("StoreId")).SendKeys("Deriv" + random + Keys.Enter);
+            Driver.FindElement(By.Id("Create")).Click();
+            return;
+        }
+
+
+        public void Dispose()
+        {
+            if (Driver != null)
+            {
+                try
+                {
+                    Driver.Close();
+                }
+                catch { }
+                Driver.Dispose();
+            }
+            if (Server != null)
+                Server.Dispose();
+        }
+
+        internal void AssertNotFound()
+        {
+            Assert.Contains("Status Code: 404; Not Found", Driver.PageSource);
+        }
+
+        public void GoToHome()
+        {
+            Driver.Navigate().GoToUrl(Server.PayTester.ServerUri);
+        }
+
+        public void Logout()
+        {
+            Driver.FindElement(By.Id("Logout")).Click();
+        }
+
+        public void Login(string user, string password)
+        {
+            Driver.FindElement(By.Id("Email")).SendKeys(user);
+            Driver.FindElement(By.Id("Password")).SendKeys(password);
+            Driver.FindElement(By.Id("LoginButton")).Click();
+
+        }
+    }
+}

BTCPayServer.Tests/SeleniumTests.cs

@@ -0,0 +1,372 @@
+using System;
+using Xunit;
+using OpenQA.Selenium;
+using OpenQA.Selenium.Chrome;
+using BTCPayServer.Tests.Logging;
+using Xunit.Abstractions;
+using OpenQA.Selenium.Interactions;
+using System.Linq;
+using NBitcoin;
+
+namespace BTCPayServer.Tests
+{
+    [Trait("Selenium", "Selenium")]
+    public class ChromeTests
+    {
+        public ChromeTests(ITestOutputHelper helper)
+        {
+            Logs.Tester = new XUnitLog(helper) { Name = "Tests" };
+            Logs.LogProvider = new XUnitLogProvider(helper);
+        }
+
+        [Fact]
+        public void CanNavigateServerSettings()
+        {
+            using (var s = SeleniumTester.Create())
+            {
+                s.Start();
+                s.RegisterNewUser(true);
+                s.Driver.FindElement(By.Id("ServerSettings")).Click();
+                s.Driver.AssertNoError();
+                s.ClickOnAllSideMenus();
+                s.Driver.Quit();
+            }
+        }
+
+        [Fact]
+        public void NewUserLogin()
+        {
+            using (var s = SeleniumTester.Create())
+            {
+                s.Start();
+                //Register & Log Out
+                var email = s.RegisterNewUser();
+                s.Driver.FindElement(By.Id("Logout")).Click();
+                s.Driver.AssertNoError();
+                s.Driver.FindElement(By.Id("Login")).Click();
+                s.Driver.AssertNoError();
+
+                s.Driver.Navigate().GoToUrl(s.Link("/invoices"));
+                Assert.Contains("ReturnUrl=%2Finvoices", s.Driver.Url);
+
+                // We should be redirected to login
+                //Same User Can Log Back In
+                s.Driver.FindElement(By.Id("Email")).SendKeys(email);
+                s.Driver.FindElement(By.Id("Password")).SendKeys("123456");
+                s.Driver.FindElement(By.Id("LoginButton")).Click();
+
+                // We should be redirected to invoice
+                Assert.EndsWith("/invoices", s.Driver.Url);
+
+                // Should not be able to reach server settings
+                s.Driver.Navigate().GoToUrl(s.Link("/server/users"));
+                Assert.Contains("ReturnUrl=%2Fserver%2Fusers", s.Driver.Url);
+
+                //Change Password & Log Out
+                s.Driver.FindElement(By.Id("MySettings")).Click();
+                s.Driver.FindElement(By.Id("ChangePassword")).Click();
+                s.Driver.FindElement(By.Id("OldPassword")).SendKeys("123456");
+                s.Driver.FindElement(By.Id("NewPassword")).SendKeys("abc???");
+                s.Driver.FindElement(By.Id("ConfirmPassword")).SendKeys("abc???");
+                s.Driver.FindElement(By.Id("UpdatePassword")).Click();
+                s.Driver.FindElement(By.Id("Logout")).Click();
+                s.Driver.AssertNoError();
+
+                //Log In With New Password
+                s.Driver.FindElement(By.Id("Login")).Click();
+                s.Driver.FindElement(By.Id("Email")).SendKeys(email);
+                s.Driver.FindElement(By.Id("Password")).SendKeys("abc???");
+                s.Driver.FindElement(By.Id("LoginButton")).Click();
+                Assert.True(s.Driver.PageSource.Contains("Stores"), "Can't Access Stores");
+
+                s.Driver.FindElement(By.Id("MySettings")).Click();
+                s.ClickOnAllSideMenus();
+
+                s.Driver.Quit();
+            }
+        }
+
+        static void LogIn(SeleniumTester s, string email)
+        {
+            s.Driver.FindElement(By.Id("Login")).Click();
+            s.Driver.FindElement(By.Id("Email")).SendKeys(email);
+            s.Driver.FindElement(By.Id("Password")).SendKeys("123456");
+            s.Driver.FindElement(By.Id("LoginButton")).Click();
+            s.Driver.AssertNoError();
+        }
+        [Fact]
+        public void CanUseDynamicDns()
+        {
+            using (var s = SeleniumTester.Create())
+            {
+                s.Start();
+                var alice = s.RegisterNewUser(isAdmin: true);
+                s.Driver.Navigate().GoToUrl(s.Link("/server/services"));
+                Assert.Contains("Dynamic DNS", s.Driver.PageSource);
+
+                s.Driver.Navigate().GoToUrl(s.Link("/server/services/dynamic-dns"));
+                s.Driver.AssertNoError();
+                if (s.Driver.PageSource.Contains("pouet.hello.com"))
+                {
+                    // Cleanup old test run
+                    s.Driver.Navigate().GoToUrl(s.Link("/server/services/dynamic-dns/pouet.hello.com/delete"));
+                    s.Driver.FindElement(By.Id("continue")).Click();
+                }
+                s.Driver.FindElement(By.Id("AddDynamicDNS")).Click();
+                s.Driver.AssertNoError();
+                // We will just cheat for test purposes by only querying the server
+                s.Driver.FindElement(By.Id("ServiceUrl")).SendKeys(s.Link("/"));
+                s.Driver.FindElement(By.Id("Settings_Hostname")).SendKeys("pouet.hello.com");
+                s.Driver.FindElement(By.Id("Settings_Login")).SendKeys("MyLog");
+                s.Driver.FindElement(By.Id("Settings_Password")).SendKeys("MyLog" + Keys.Enter);
+                s.Driver.AssertNoError();
+                Assert.Contains("The Dynamic DNS has been successfully queried", s.Driver.PageSource);
+                Assert.EndsWith("/server/services/dynamic-dns", s.Driver.Url);
+
+                // Try to do the same thing should fail (hostname already exists)
+                s.Driver.FindElement(By.Id("AddDynamicDNS")).Click();
+                s.Driver.AssertNoError();
+                s.Driver.FindElement(By.Id("ServiceUrl")).SendKeys(s.Link("/"));
+                s.Driver.FindElement(By.Id("Settings_Hostname")).SendKeys("pouet.hello.com");
+                s.Driver.FindElement(By.Id("Settings_Login")).SendKeys("MyLog");
+                s.Driver.FindElement(By.Id("Settings_Password")).SendKeys("MyLog" + Keys.Enter);
+                s.Driver.AssertNoError();
+                Assert.Contains("This hostname already exists", s.Driver.PageSource);
+
+                // Delete it
+                s.Driver.Navigate().GoToUrl(s.Link("/server/services/dynamic-dns"));
+                Assert.Contains("/server/services/dynamic-dns/pouet.hello.com/delete", s.Driver.PageSource);
+                s.Driver.Navigate().GoToUrl(s.Link("/server/services/dynamic-dns/pouet.hello.com/delete"));
+                s.Driver.FindElement(By.Id("continue")).Click();
+                s.Driver.AssertNoError();
+
+                Assert.DoesNotContain("/server/services/dynamic-dns/pouet.hello.com/delete", s.Driver.PageSource);
+            }
+        }
+
+        [Fact]
+        public void CanCreateStores()
+        {
+            using (var s = SeleniumTester.Create())
+            {
+                s.Start();
+                var alice = s.RegisterNewUser();
+                var store = s.CreateNewStore();
+                s.AddDerivationScheme();
+                s.Driver.AssertNoError();
+                Assert.Contains(store, s.Driver.PageSource);
+                var storeUrl = s.Driver.Url;
+                s.ClickOnAllSideMenus();
+
+                CreateInvoice(s, store);
+                s.Driver.FindElement(By.ClassName("invoice-details-link")).Click();
+                var invoiceUrl = s.Driver.Url;
+
+                // When logout we should not be able to access store and invoice details
+                s.Driver.FindElement(By.Id("Logout")).Click();
+                s.Driver.Navigate().GoToUrl(storeUrl);
+                Assert.Contains("ReturnUrl", s.Driver.Url);
+                s.Driver.Navigate().GoToUrl(invoiceUrl);
+                Assert.Contains("ReturnUrl", s.Driver.Url);
+
+                // When logged we should not be able to access store and invoice details
+                var bob = s.RegisterNewUser();
+                s.Driver.Navigate().GoToUrl(storeUrl);
+                Assert.Contains("ReturnUrl", s.Driver.Url);
+                s.Driver.Navigate().GoToUrl(invoiceUrl);
+                s.AssertNotFound();
+                s.GoToHome();
+                s.Logout();
+
+                // Let's add Bob as a guest to alice's store
+                LogIn(s, alice);
+                s.Driver.Navigate().GoToUrl(storeUrl + "/users");
+                s.Driver.FindElement(By.Id("Email")).SendKeys(bob + Keys.Enter);
+                Assert.Contains("User added successfully", s.Driver.PageSource);
+                s.Logout();
+
+                // Bob should not have access to store, but should have access to invoice
+                LogIn(s, bob);
+                s.Driver.Navigate().GoToUrl(storeUrl);
+                Assert.Contains("ReturnUrl", s.Driver.Url);
+                s.Driver.Navigate().GoToUrl(invoiceUrl);
+                s.Driver.AssertNoError();
+            }
+        }
+
+        [Fact]
+        public void CanCreateInvoice()
+        {
+            using (var s = SeleniumTester.Create())
+            {
+                s.Start();
+                s.RegisterNewUser();
+                var store = s.CreateNewStore();
+                s.AddDerivationScheme();
+
+                CreateInvoice(s, store);
+
+                s.Driver.FindElement(By.ClassName("invoice-details-link")).Click();
+                s.Driver.AssertNoError();
+                s.Driver.Navigate().Back();
+                s.Driver.FindElement(By.ClassName("invoice-checkout-link")).Click();
+                Assert.NotEmpty(s.Driver.FindElements(By.Id("checkoutCtrl")));
+                s.Driver.Quit();
+            }
+        }
+
+        static void CreateInvoice(SeleniumTester s, string store)
+        {
+            s.Driver.FindElement(By.Id("Invoices")).Click();
+            s.Driver.FindElement(By.Id("CreateNewInvoice")).Click();
+            s.Driver.FindElement(By.CssSelector("input#Amount.form-control")).SendKeys("100");
+            s.Driver.FindElement(By.Name("StoreId")).SendKeys(store + Keys.Enter);
+            s.Driver.FindElement(By.Id("Create")).Click();
+            Assert.True(s.Driver.PageSource.Contains("just created!"), "Unable to create Invoice");
+        }
+
+        [Fact]
+        public void CanCreateAppPoS()
+        {
+            using (var s = SeleniumTester.Create())
+            {
+                s.Start();
+                s.RegisterNewUser();
+                var store = s.CreateNewStore();
+
+                s.Driver.FindElement(By.Id("Apps")).Click();
+                s.Driver.FindElement(By.Id("CreateNewApp")).Click();
+                s.Driver.FindElement(By.Name("Name")).SendKeys("PoS" + store);
+                s.Driver.FindElement(By.CssSelector("select#SelectedAppType.form-control")).SendKeys("PointOfSale" + Keys.Enter);
+                s.Driver.FindElement(By.CssSelector("select#SelectedStore.form-control")).SendKeys(store + Keys.Enter);
+                s.Driver.FindElement(By.Id("Create")).Click();
+                s.Driver.FindElement(By.CssSelector("input#EnableShoppingCart.form-check")).Click();
+                s.Driver.FindElement(By.Id("SaveSettings")).ForceClick();
+                Assert.True(s.Driver.PageSource.Contains("App updated"), "Unable to create PoS");
+                s.Driver.Quit();
+            }
+        }
+
+        [Fact]
+        public void CanCreateAppCF()
+        {
+            using (var s = SeleniumTester.Create())
+            {
+                s.Start();
+                s.RegisterNewUser();
+                var store = s.CreateNewStore();
+                s.AddDerivationScheme();
+
+                s.Driver.FindElement(By.Id("Apps")).Click();
+                s.Driver.FindElement(By.Id("CreateNewApp")).Click();
+                s.Driver.FindElement(By.Name("Name")).SendKeys("CF" + store);
+                s.Driver.FindElement(By.CssSelector("select#SelectedAppType.form-control")).SendKeys("Crowdfund" + Keys.Enter);
+                s.Driver.FindElement(By.CssSelector("select#SelectedStore.form-control")).SendKeys(store + Keys.Enter);
+                s.Driver.FindElement(By.Id("Create")).Click();
+                s.Driver.FindElement(By.Id("Title")).SendKeys("Kukkstarter");
+                s.Driver.FindElement(By.CssSelector("div.note-editable.card-block")).SendKeys("1BTC = 1BTC");
+                s.Driver.FindElement(By.Id("TargetCurrency")).SendKeys("JPY");
+                s.Driver.FindElement(By.Id("TargetAmount")).SendKeys("700");
+                s.Driver.FindElement(By.Id("SaveSettings")).Submit();
+                s.Driver.FindElement(By.Id("ViewApp")).ForceClick();
+                s.Driver.SwitchTo().Window(s.Driver.WindowHandles.Last());
+                Assert.True(s.Driver.PageSource.Contains("Currently Active!"), "Unable to create CF");
+                s.Driver.Quit();
+            } 
+        }
+
+        [Fact]
+        public void CanCreatePayRequest()
+        {
+            using (var s = SeleniumTester.Create())
+            {
+                s.Start();
+                s.RegisterNewUser();
+                s.CreateNewStore();
+                s.AddDerivationScheme();
+
+                s.Driver.FindElement(By.Id("PaymentRequests")).Click();
+                s.Driver.FindElement(By.Id("CreatePaymentRequest")).Click();
+                s.Driver.FindElement(By.Id("Title")).SendKeys("Pay123");
+                s.Driver.FindElement(By.Id("Amount")).SendKeys("700");
+                s.Driver.FindElement(By.Id("Currency")).SendKeys("BTC");
+                s.Driver.FindElement(By.Id("SaveButton")).Submit();
+                s.Driver.FindElement(By.Name("ViewAppButton")).SendKeys(Keys.Return);
+                s.Driver.SwitchTo().Window(s.Driver.WindowHandles.Last());
+                Assert.True(s.Driver.PageSource.Contains("Amount due"), "Unable to create Payment Request");
+                s.Driver.Quit();
+            }
+        }
+
+        [Fact]
+        public void CanManageWallet()
+        {
+            using (var s = SeleniumTester.Create())
+            {
+                s.Start();
+                s.RegisterNewUser();
+                s.CreateNewStore();
+
+                // In this test, we try to spend from a manual seed. We import the xpub 49'/0'/0', then try to use the seed 
+                // to sign the transaction
+                var mnemonic = "usage fever hen zero slide mammal silent heavy donate budget pulse say brain thank sausage brand craft about save attract muffin advance illegal cabbage";
+                var root = new Mnemonic(mnemonic).DeriveExtKey();
+                s.AddDerivationScheme("ypub6WWc2gWwHbdnAAyJDnR4SPL1phRh7REqrPBfZeizaQ1EmTshieRXJC3Z5YoU4wkcdKHEjQGkh6AYEzCQC1Kz3DNaWSwdc1pc8416hAjzqyD");
+                var tx = s.Server.ExplorerNode.SendToAddress(BitcoinAddress.Create("bcrt1qmxg8fgnmkp354vhe78j6sr4ut64tyz2xyejel4", Network.RegTest), Money.Coins(3.0m));
+                s.Server.ExplorerNode.Generate(1);
+
+                s.Driver.FindElement(By.Id("Wallets")).Click();
+                s.Driver.FindElement(By.LinkText("Manage")).Click();
+
+                s.ClickOnAllSideMenus();
+
+                // We setup the fingerprint and the account key path
+                s.Driver.FindElement(By.Id("WalletSettings")).ForceClick();
+                s.Driver.FindElement(By.Id("AccountKeys_0__MasterFingerprint")).SendKeys("8bafd160");
+                s.Driver.FindElement(By.Id("AccountKeys_0__AccountKeyPath")).SendKeys("m/49'/0'/0'" + Keys.Enter);
+
+                // Check the tx sent earlier arrived
+                s.Driver.FindElement(By.Id("WalletTransactions")).ForceClick();
+                var walletTransactionLink = s.Driver.Url;
+                Assert.Contains(tx.ToString(), s.Driver.PageSource);
+
+                
+                void SignWith(string signingSource)
+                {
+                    // Send to bob
+                    s.Driver.FindElement(By.Id("WalletSend")).Click();
+                    var bob = new Key().PubKey.Hash.GetAddress(Network.RegTest);
+                    SetTransactionOutput(0, bob, 1);
+                    s.Driver.ScrollTo(By.Id("SendMenu"));
+                    s.Driver.FindElement(By.Id("SendMenu")).ForceClick();
+                    s.Driver.FindElement(By.CssSelector("button[value=seed]")).Click();
+
+                    // Input the seed
+                    s.Driver.FindElement(By.Id("SeedOrKey")).SendKeys(signingSource + Keys.Enter);
+
+                    // Broadcast
+                    Assert.Contains(bob.ToString(), s.Driver.PageSource);
+                    Assert.Contains("1.00000000", s.Driver.PageSource);
+                    s.Driver.FindElement(By.CssSelector("button[value=broadcast]")).ForceClick();
+                    Assert.Equal(walletTransactionLink, s.Driver.Url);
+                }
+
+                void SetTransactionOutput(int index, BitcoinAddress dest, decimal amount, bool subtract = false)
+                {
+                    s.Driver.FindElement(By.Id($"Outputs_{index}__DestinationAddress")).SendKeys(dest.ToString());
+                    var amountElement = s.Driver.FindElement(By.Id($"Outputs_{index}__Amount"));
+                    amountElement.Clear();
+                    amountElement.SendKeys(amount.ToString());
+                    var checkboxElement = s.Driver.FindElement(By.Id($"Outputs_{index}__SubtractFeesFromOutput"));
+                    if (checkboxElement.Selected != subtract)
+                    {
+                        checkboxElement.Click();
+                    }
+                }
+                SignWith(mnemonic);
+                var accountKey = root.Derive(new KeyPath("m/49'/0'/0'")).GetWif(Network.RegTest).ToString();
+                SignWith(accountKey);
+            }
+        }
+    }
+}

BTCPayServer.Tests/ServerTester.cs

@@ -44,14 +44,14 @@ namespace BTCPayServer.Tests
                 Directory.CreateDirectory(_Directory);
 
             NetworkProvider = new BTCPayNetworkProvider(NetworkType.Regtest);
-            ExplorerNode = new RPCClient(RPCCredentialString.Parse(GetEnvironment("TESTS_BTCRPCCONNECTION", "server=http://127.0.0.1:43782;ceiwHEbqWI83:DwubwWsoo3")), NetworkProvider.GetNetwork("BTC").NBitcoinNetwork);
+            ExplorerNode = new RPCClient(RPCCredentialString.Parse(GetEnvironment("TESTS_BTCRPCCONNECTION", "server=http://127.0.0.1:43782;ceiwHEbqWI83:DwubwWsoo3")), NetworkProvider.GetNetwork<BTCPayNetwork>("BTC").NBitcoinNetwork);
             ExplorerNode.ScanRPCCapabilities();
-            LTCExplorerNode = new RPCClient(RPCCredentialString.Parse(GetEnvironment("TESTS_LTCRPCCONNECTION", "server=http://127.0.0.1:43783;ceiwHEbqWI83:DwubwWsoo3")), NetworkProvider.GetNetwork("LTC").NBitcoinNetwork);
+            LTCExplorerNode = new RPCClient(RPCCredentialString.Parse(GetEnvironment("TESTS_LTCRPCCONNECTION", "server=http://127.0.0.1:43783;ceiwHEbqWI83:DwubwWsoo3")), NetworkProvider.GetNetwork<BTCPayNetwork>("LTC").NBitcoinNetwork);
 
-            ExplorerClient = new ExplorerClient(NetworkProvider.GetNetwork("BTC").NBXplorerNetwork, new Uri(GetEnvironment("TESTS_BTCNBXPLORERURL", "http://127.0.0.1:32838/")));
-            LTCExplorerClient = new ExplorerClient(NetworkProvider.GetNetwork("LTC").NBXplorerNetwork, new Uri(GetEnvironment("TESTS_LTCNBXPLORERURL", "http://127.0.0.1:32838/")));
+            ExplorerClient = new ExplorerClient(NetworkProvider.GetNetwork<BTCPayNetwork>("BTC").NBXplorerNetwork, new Uri(GetEnvironment("TESTS_BTCNBXPLORERURL", "http://127.0.0.1:32838/")));
+            LTCExplorerClient = new ExplorerClient(NetworkProvider.GetNetwork<BTCPayNetwork>("LTC").NBXplorerNetwork, new Uri(GetEnvironment("TESTS_LTCNBXPLORERURL", "http://127.0.0.1:32838/")));
 
-            var btc = NetworkProvider.GetNetwork("BTC").NBitcoinNetwork;
+            var btc = NetworkProvider.GetNetwork<BTCPayNetwork>("BTC").NBitcoinNetwork;
             CustomerLightningD = LightningClientFactory.CreateClient(GetEnvironment("TEST_CUSTOMERLIGHTNINGD", "type=clightning;server=tcp://127.0.0.1:30992/"), btc);
             MerchantLightningD = LightningClientFactory.CreateClient(GetEnvironment("TEST_MERCHANTLIGHTNINGD", "type=clightning;server=tcp://127.0.0.1:30993/"), btc);
 

BTCPayServer.Tests/StorageTests.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Threading.Tasks;
 using BTCPayServer.Controllers;
@@ -9,6 +10,7 @@ using BTCPayServer.Storage.Services.Providers.AzureBlobStorage.Configuration;
 using BTCPayServer.Storage.Services.Providers.FileSystemStorage.Configuration;
 using BTCPayServer.Storage.ViewModels;
 using BTCPayServer.Tests.Logging;
+using DBriize.Utils;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Http.Internal;
 using Microsoft.AspNetCore.Mvc;
@@ -38,15 +40,6 @@ namespace BTCPayServer.Tests
                 user.GrantAccess();
                 var controller = tester.PayTester.GetController<ServerController>(user.UserId, user.StoreId);
 
-//                //For some reason, the tests cache something on circleci and this is set by default
-//                //Initially, there is no configuration, make sure we display the choices available to configure
-//                Assert.IsType<StorageSettings>(Assert.IsType<ViewResult>(await controller.Storage()).Model);
-//
-//                //the file list should tell us it's not configured:
-//                var viewFilesViewModelInitial =
-//                    Assert.IsType<ViewFilesViewModel>(Assert.IsType<ViewResult>(await controller.Files()).Model);
-//                Assert.False(viewFilesViewModelInitial.StorageConfigured);
-
 
                 //Once we select a provider, redirect to its view
                 var localResult = Assert
@@ -190,25 +183,13 @@ namespace BTCPayServer.Tests
         
         private async Task CanUploadRemoveFiles(ServerController controller)
         {
-            var filename = "uploadtestfile.txt";
             var fileContent = "content";
-            File.WriteAllText(filename, fileContent);
-
-            var fileInfo = new FileInfo(filename);
-            var formFile = new FormFile(
-                new FileStream(filename, FileMode.OpenOrCreate),
-                0,
-                fileInfo.Length, fileInfo.Name, fileInfo.Name)
-            {
-                Headers = new HeaderDictionary()
-            };
-            formFile.ContentType = "text/plain";
-            formFile.ContentDisposition = $"form-data; name=\"file\"; filename=\"{fileInfo.Name}\"";
-            var uploadFormFileResult = Assert.IsType<RedirectToActionResult>(await controller.CreateFile(formFile));
+            var uploadFormFileResult = Assert.IsType<RedirectToActionResult>(await controller.CreateFile(TestUtils.GetFormFile("uploadtestfile.txt", fileContent)));
             Assert.True(uploadFormFileResult.RouteValues.ContainsKey("fileId"));
             var fileId = uploadFormFileResult.RouteValues["fileId"].ToString();
             Assert.Equal("Files", uploadFormFileResult.ActionName);
 
+            //check if file was uploaded and saved in db
             var viewFilesViewModel =
                 Assert.IsType<ViewFilesViewModel>(Assert.IsType<ViewResult>(await controller.Files(fileId)).Model);
 
@@ -216,21 +197,48 @@ namespace BTCPayServer.Tests
             Assert.Equal(fileId, viewFilesViewModel.SelectedFileId);
             Assert.NotEmpty(viewFilesViewModel.DirectFileUrl);
 
-
+            
+            //verify file is available and the same
             var net = new System.Net.WebClient();
             var data = await net.DownloadStringTaskAsync(new Uri(viewFilesViewModel.DirectFileUrl));
             Assert.Equal(fileContent, data);
-
+            
+            //create a temporary link to file
+            var tmpLinkGenerate = Assert.IsType<RedirectToActionResult>(await controller.CreateTemporaryFileUrl(fileId,
+                new ServerController.CreateTemporaryFileUrlViewModel()
+                {
+                    IsDownload = true,
+                    TimeAmount = 1,
+                    TimeType = ServerController.CreateTemporaryFileUrlViewModel.TmpFileTimeType.Minutes
+                }));
+            Assert.True(tmpLinkGenerate.RouteValues.ContainsKey("StatusMessage"));
+            var statusMessageModel = new StatusMessageModel(tmpLinkGenerate.RouteValues["StatusMessage"].ToString());
+            Assert.Equal(StatusMessageModel.StatusSeverity.Success, statusMessageModel.Severity);
+            var index = statusMessageModel.Html.IndexOf("target='_blank'>");
+            var url = statusMessageModel.Html.Substring(index).ReplaceMultiple(new Dictionary<string, string>()
+            {
+                {"</a>", string.Empty}, {"target='_blank'>", string.Empty}
+            });
+            //verify tmpfile is available and the same
+            data = await net.DownloadStringTaskAsync(new Uri(url));
+            Assert.Equal(fileContent, data);
+            
+            
+            //delete file
             Assert.Equal(StatusMessageModel.StatusSeverity.Success, new StatusMessageModel(Assert
                 .IsType<RedirectToActionResult>(await controller.DeleteFile(fileId))
                 .RouteValues["statusMessage"].ToString()).Severity);
-
+            
+            //attempt to fetch deleted file
             viewFilesViewModel =
                 Assert.IsType<ViewFilesViewModel>(Assert.IsType<ViewResult>(await controller.Files(fileId)).Model);
 
             Assert.Null(viewFilesViewModel.DirectFileUrl);
             Assert.Null(viewFilesViewModel.SelectedFileId);
         }
+        
+        
+        
 
       
 

BTCPayServer.Tests/TestAccount.cs

@@ -10,6 +10,7 @@ using System;
 using System.Collections.Generic;
 using System.Text;
 using System.Threading.Tasks;
+using BTCPayServer.Authentication.OpenId.Models;
 using Xunit;
 using NBXplorer.DerivationStrategy;
 using BTCPayServer.Payments;
@@ -18,6 +19,8 @@ using BTCPayServer.Tests.Logging;
 using BTCPayServer.Lightning;
 using BTCPayServer.Lightning.CLightning;
 using BTCPayServer.Data;
+using OpenIddict.Abstractions;
+using OpenIddict.Core;
 
 namespace BTCPayServer.Tests
 {
@@ -95,7 +98,7 @@ namespace BTCPayServer.Tests
         }
         public async Task<WalletId> RegisterDerivationSchemeAsync(string cryptoCode, bool segwit = false)
         {
-            SupportedNetwork = parent.NetworkProvider.GetNetwork(cryptoCode);
+            SupportedNetwork = parent.NetworkProvider.GetNetwork<BTCPayNetwork>(cryptoCode);
             var store = parent.PayTester.GetController<StoresController>(UserId, StoreId);
             ExtKey = new ExtKey().GetWif(SupportedNetwork.NBitcoinNetwork);
             DerivationScheme = new DerivationStrategyFactory(SupportedNetwork.NBitcoinNetwork).Parse(ExtKey.Neuter().ToString() + (segwit ? "" : "-[legacy]"));
@@ -166,5 +169,14 @@ namespace BTCPayServer.Tests
             if (storeController.ModelState.ErrorCount != 0)
                 Assert.False(true, storeController.ModelState.FirstOrDefault().Value.Errors[0].ErrorMessage);
         }
+
+        public async Task<BTCPayOpenIdClient> RegisterOpenIdClient(OpenIddictApplicationDescriptor descriptor, string secret = null)
+        {
+          var openIddictApplicationManager = parent.PayTester.GetService<OpenIddictApplicationManager<BTCPayOpenIdClient>>();
+          var client = new BTCPayOpenIdClient {ApplicationUserId = UserId};
+          await openIddictApplicationManager.PopulateAsync(client, descriptor);
+          await openIddictApplicationManager.CreateAsync(client, secret);
+          return client;
+        }
     }
 }

BTCPayServer.Tests/TestUtils.cs

@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Internal;
+using Xunit.Sdk;
+
+namespace BTCPayServer.Tests
+{
+    public static class TestUtils
+    {
+        public static FormFile GetFormFile(string filename, string content)
+        {
+            File.WriteAllText(filename, content);
+
+            var fileInfo = new FileInfo(filename);
+            FormFile formFile = new FormFile(
+                new FileStream(filename, FileMode.OpenOrCreate),
+                0,
+                fileInfo.Length, fileInfo.Name, fileInfo.Name)
+            {
+                Headers = new HeaderDictionary()
+            };
+            formFile.ContentType = "text/plain";
+            formFile.ContentDisposition = $"form-data; name=\"file\"; filename=\"{fileInfo.Name}\"";
+            return formFile;
+        }
+        public static FormFile GetFormFile(string filename, byte[] content)
+        {
+            File.WriteAllBytes(filename, content);
+
+            var fileInfo = new FileInfo(filename);
+            FormFile formFile = new FormFile(
+                new FileStream(filename, FileMode.OpenOrCreate),
+                0,
+                fileInfo.Length, fileInfo.Name, fileInfo.Name)
+            {
+                Headers = new HeaderDictionary()
+            };
+            formFile.ContentType = "application/octet-stream";
+            formFile.ContentDisposition = $"form-data; name=\"file\"; filename=\"{fileInfo.Name}\"";
+            return formFile;
+        }
+        public static void Eventually(Action act)
+        {
+            CancellationTokenSource cts = new CancellationTokenSource(20000);
+            while (true)
+            {
+                try
+                {
+                    act();
+                    break;
+                }
+                catch (XunitException) when (!cts.Token.IsCancellationRequested)
+                {
+                    cts.Token.WaitHandle.WaitOne(500);
+                }
+            }
+        }
+
+        public static 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/UnitTest1.cs

@@ -58,6 +58,10 @@ using System.Runtime.CompilerServices;
 using System.Net;
 using BTCPayServer.Models.AccountViewModels;
 using BTCPayServer.Services.U2F.Models;
+using Microsoft.AspNetCore.Http.Internal;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.DependencyInjection;
+using NBXplorer.DerivationStrategy;
 
 namespace BTCPayServer.Tests
 {
@@ -95,56 +99,68 @@ namespace BTCPayServer.Tests
         [Trait("Fast", "Fast")]
         public void CanCalculateCryptoDue2()
         {
-            var dummy = new Key().PubKey.GetAddress(Network.RegTest).ToString();
 #pragma warning disable CS0618
+            var dummy = new Key().PubKey.GetAddress(ScriptPubKeyType.Legacy, Network.RegTest).ToString();
+            var networkProvider = new BTCPayNetworkProvider(NetworkType.Regtest);
+            var paymentMethodHandlerDictionary = new PaymentMethodHandlerDictionary(new IPaymentMethodHandler[]
+            {
+                new BitcoinLikePaymentHandler(null, networkProvider, null, null),
+                new LightningLikePaymentHandler(null, null, networkProvider, null),
+            });
             InvoiceEntity invoiceEntity = new InvoiceEntity();
             invoiceEntity.Payments = new System.Collections.Generic.List<PaymentEntity>();
-            invoiceEntity.ProductInformation = new ProductInformation() { Price = 100 };
+            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()
-            {
-                NextNetworkFee = Money.Coins(0.00000100m),
-                DepositAddress = dummy
-            }));
-            paymentMethods.Add(new PaymentMethod()
-            {
-                CryptoCode = "LTC",
-                Rate = 216.79m
-            }.SetPaymentMethodDetails(new BTCPayServer.Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod()
-            {
-                NextNetworkFee = Money.Coins(0.00010000m),
-                DepositAddress = dummy
-            }));
+            paymentMethods.Add(new PaymentMethod() {CryptoCode = "BTC", Rate = 10513.44m,}.SetPaymentMethodDetails(
+                new BTCPayServer.Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod()
+                {
+                    NextNetworkFee = Money.Coins(0.00000100m), DepositAddress = dummy
+                }));
+            paymentMethods.Add(new PaymentMethod() {CryptoCode = "LTC", Rate = 216.79m}.SetPaymentMethodDetails(
+                new BTCPayServer.Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod()
+                {
+                    NextNetworkFee = Money.Coins(0.00010000m), DepositAddress = dummy
+                }));
             invoiceEntity.SetPaymentMethods(paymentMethods);
 
-            var btc = invoiceEntity.GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike), null);
+            var btc = invoiceEntity.GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike));
             var accounting = btc.Calculate();
 
-            invoiceEntity.Payments.Add(new PaymentEntity() { Accounted = true, CryptoCode = "BTC", NetworkFee = 0.00000100m }.SetCryptoPaymentData(new BitcoinLikePaymentData()
-            {
-                Output = new TxOut() { Value = Money.Coins(0.00151263m) }
-            }));
+            invoiceEntity.Payments.Add(
+                new PaymentEntity()
+                    {
+                        Accounted = true,
+                        CryptoCode = "BTC",
+                        NetworkFee = 0.00000100m
+                    }
+                    .SetCryptoPaymentData(new BitcoinLikePaymentData()
+                    {
+                        Output = new TxOut() {Value = Money.Coins(0.00151263m)}
+                    }));
             accounting = btc.Calculate();
-            invoiceEntity.Payments.Add(new PaymentEntity() { Accounted = true, CryptoCode = "BTC", NetworkFee = 0.00000100m }.SetCryptoPaymentData(new BitcoinLikePaymentData()
-            {
-                Output = new TxOut() { Value = accounting.Due }
-            }));
+            invoiceEntity.Payments.Add(
+                new PaymentEntity()
+                    {
+                        Accounted = true,
+                        CryptoCode = "BTC",
+                        NetworkFee = 0.00000100m
+                    }
+                    .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);
+            var ltc = invoiceEntity.GetPaymentMethod(new PaymentMethodId("LTC", PaymentTypes.BTCLike));
             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);
+            var paymentMethod = InvoiceWatcher.GetNearestClearedPayment(paymentMethods, out var accounting2);
             Assert.Equal(btc.CryptoCode, paymentMethod.CryptoCode);
 #pragma warning restore CS0618
         }
@@ -192,70 +208,108 @@ namespace BTCPayServer.Tests
         [Trait("Fast", "Fast")]
         public void CanCalculateCryptoDue()
         {
+            var networkProvider = new BTCPayNetworkProvider(NetworkType.Regtest);
+            var paymentMethodHandlerDictionary = new PaymentMethodHandlerDictionary(new IPaymentMethodHandler[]
+            {
+                new BitcoinLikePaymentHandler(null, networkProvider, null, null),
+                new LightningLikePaymentHandler(null, null, networkProvider, null),
+            });
             var entity = new InvoiceEntity();
 #pragma warning disable CS0618
             entity.Payments = new System.Collections.Generic.List<PaymentEntity>();
-            entity.SetPaymentMethod(new PaymentMethod() { CryptoCode = "BTC", Rate = 5000, NextNetworkFee = Money.Coins(0.1m) });
-            entity.ProductInformation = new ProductInformation() { Price = 5000 };
+            entity.SetPaymentMethod(new PaymentMethod()
+            {
+                CryptoCode = "BTC", Rate = 5000, NextNetworkFee = Money.Coins(0.1m)
+            });
+            entity.ProductInformation = new ProductInformation() {Price = 5000};
 
-            var paymentMethod = entity.GetPaymentMethods(null).TryGet("BTC", PaymentTypes.BTCLike);
+            var paymentMethod = entity.GetPaymentMethods().TryGet("BTC", PaymentTypes.BTCLike);
             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, NetworkFee = 0.1m });
+            entity.Payments.Add(new PaymentEntity()
+            {
+                Output = new TxOut(Money.Coins(0.5m), new Key()),
+                Accounted = true,
+                NetworkFee = 0.1m
+            });
 
             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, NetworkFee = 0.1m });
+            entity.Payments.Add(new PaymentEntity()
+            {
+                Output = new TxOut(Money.Coins(0.2m), new Key()),
+                Accounted = true,
+                NetworkFee = 0.1m
+            });
 
             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, NetworkFee = 0.1m });
+            entity.Payments.Add(new PaymentEntity()
+            {
+                Output = new TxOut(Money.Coins(0.6m), new Key()),
+                Accounted = true,
+                NetworkFee = 0.1m
+            });
 
             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 });
+            entity.Payments.Add(
+                new PaymentEntity()
+                {
+                    Output = new TxOut(Money.Coins(0.2m), new Key()), 
+                    Accounted = true
+                });
 
             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.ProductInformation = new ProductInformation() {Price = 5000};
             PaymentMethodDictionary paymentMethods = new PaymentMethodDictionary();
-            paymentMethods.Add(new PaymentMethod()
-            {
-                CryptoCode = "BTC",
-                Rate = 1000,
-                NextNetworkFee = Money.Coins(0.1m)
-            });
-            paymentMethods.Add(new PaymentMethod()
-            {
-                CryptoCode = "LTC",
-                Rate = 500,
-                NextNetworkFee = Money.Coins(0.01m)
-            });
+            paymentMethods.Add(
+                new PaymentMethod()
+                {
+                    CryptoCode = "BTC", 
+                    Rate = 1000, 
+                    NextNetworkFee = Money.Coins(0.1m)
+                });
+            paymentMethods.Add(
+                new PaymentMethod()
+                {
+                    CryptoCode = "LTC", 
+                    Rate = 500, 
+                    NextNetworkFee = Money.Coins(0.01m)
+                });
             entity.SetPaymentMethods(paymentMethods);
             entity.Payments = new List<PaymentEntity>();
-            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike), null);
+            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike));
             accounting = paymentMethod.Calculate();
             Assert.Equal(Money.Coins(5.1m), accounting.Due);
 
-            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("LTC", PaymentTypes.BTCLike), null);
+            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("LTC", PaymentTypes.BTCLike));
             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, NetworkFee = 0.1m });
+            entity.Payments.Add(new PaymentEntity()
+            {
+                CryptoCode = "BTC",
+                Output = new TxOut(Money.Coins(1.0m), new Key()),
+                Accounted = true,
+                NetworkFee = 0.1m
+            });
 
-            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike), null);
+            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike));
             accounting = paymentMethod.Calculate();
             Assert.Equal(Money.Coins(4.2m), accounting.Due);
             Assert.Equal(Money.Coins(1.0m), accounting.CryptoPaid);
@@ -263,17 +317,22 @@ namespace BTCPayServer.Tests
             Assert.Equal(Money.Coins(5.2m), accounting.TotalDue);
             Assert.Equal(2, accounting.TxRequired);
 
-            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("LTC", PaymentTypes.BTCLike), null);
+            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("LTC", PaymentTypes.BTCLike));
             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);
             Assert.Equal(Money.Coins(10.01m + 0.1m * 2), accounting.TotalDue);
 
-            entity.Payments.Add(new PaymentEntity() { CryptoCode = "LTC", Output = new TxOut(Money.Coins(1.0m), new Key()), Accounted = true, NetworkFee = 0.01m });
+            entity.Payments.Add(new PaymentEntity()
+            {
+                CryptoCode = "LTC",
+                Output = new TxOut(Money.Coins(1.0m), new Key()),
+                Accounted = true,
+                NetworkFee = 0.01m
+            });
 
-
-            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike), null);
+            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike));
             accounting = paymentMethod.Calculate();
             Assert.Equal(Money.Coins(4.2m - 0.5m + 0.01m / 2), accounting.Due);
             Assert.Equal(Money.Coins(1.0m), accounting.CryptoPaid);
@@ -281,7 +340,7 @@ namespace BTCPayServer.Tests
             Assert.Equal(Money.Coins(5.2m + 0.01m / 2), accounting.TotalDue); // The fee for LTC added
             Assert.Equal(2, accounting.TxRequired);
 
-            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("LTC", PaymentTypes.BTCLike), null);
+            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("LTC", PaymentTypes.BTCLike));
             accounting = paymentMethod.Calculate();
             Assert.Equal(Money.Coins(8.21m - 1.0m + 0.01m), accounting.Due);
             Assert.Equal(Money.Coins(1.0m), accounting.CryptoPaid);
@@ -290,9 +349,15 @@ namespace BTCPayServer.Tests
             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, NetworkFee = 0.1m });
+            entity.Payments.Add(new PaymentEntity()
+            {
+                CryptoCode = "BTC",
+                Output = new TxOut(remaining, new Key()),
+                Accounted = true,
+                NetworkFee = 0.1m
+            });
 
-            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike), null);
+            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("BTC", PaymentTypes.BTCLike));
             accounting = paymentMethod.Calculate();
             Assert.Equal(Money.Zero, accounting.Due);
             Assert.Equal(Money.Coins(1.0m) + remaining, accounting.CryptoPaid);
@@ -301,13 +366,14 @@ namespace BTCPayServer.Tests
             Assert.Equal(accounting.Paid, accounting.TotalDue);
             Assert.Equal(2, accounting.TxRequired);
 
-            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("LTC", PaymentTypes.BTCLike), null);
+            paymentMethod = entity.GetPaymentMethod(new PaymentMethodId("LTC", PaymentTypes.BTCLike));
             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(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.TxRequired);
             Assert.Equal(accounting.Paid, accounting.TotalDue);
 #pragma warning restore CS0618
@@ -315,29 +381,50 @@ namespace BTCPayServer.Tests
 
         [Fact]
         [Trait("Integration", "Integration")]
+        public async Task CanUseTestWebsiteUI()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var response = await tester.PayTester.HttpClient.GetAsync("");
+                Assert.True(response.IsSuccessStatusCode);
+            }
+        }
+
+        [Fact]
+        [Trait("Fast", "Fast")]
         public void CanAcceptInvoiceWithTolerance()
         {
+            var networkProvider = new BTCPayNetworkProvider(NetworkType.Regtest);
+            var paymentMethodHandlerDictionary = new PaymentMethodHandlerDictionary(new IPaymentMethodHandler[]
+            {
+                new BitcoinLikePaymentHandler(null, networkProvider, null, null),
+                new LightningLikePaymentHandler(null, null, networkProvider, null),
+            });
             var entity = new InvoiceEntity();
 #pragma warning disable CS0618
             entity.Payments = new List<PaymentEntity>();
-            entity.SetPaymentMethod(new PaymentMethod() { CryptoCode = "BTC", Rate = 5000, NextNetworkFee = Money.Coins(0.1m) });
-            entity.ProductInformation = new ProductInformation() { Price = 5000 };
+            entity.SetPaymentMethod(new PaymentMethod()
+            {
+                CryptoCode = "BTC", Rate = 5000, NextNetworkFee = Money.Coins(0.1m)
+            });
+            entity.ProductInformation = new ProductInformation() {Price = 5000};
             entity.PaymentTolerance = 0;
 
 
-            var paymentMethod = entity.GetPaymentMethods(null).TryGet("BTC", PaymentTypes.BTCLike);
+            var paymentMethod = entity.GetPaymentMethods().TryGet("BTC", PaymentTypes.BTCLike);
             var accounting = paymentMethod.Calculate();
             Assert.Equal(Money.Coins(1.1m), accounting.Due);
             Assert.Equal(Money.Coins(1.1m), accounting.TotalDue);
             Assert.Equal(Money.Coins(1.1m), accounting.MinimumTotalDue);
 
-            entity.PaymentTolerance = 10;
-            accounting = paymentMethod.Calculate();
-            Assert.Equal(Money.Coins(0.99m), accounting.MinimumTotalDue);
+                entity.PaymentTolerance = 10;
+                accounting = paymentMethod.Calculate();
+                Assert.Equal(Money.Coins(0.99m), accounting.MinimumTotalDue);
 
-            entity.PaymentTolerance = 100;
-            accounting = paymentMethod.Calculate();
-            Assert.Equal(Money.Satoshis(1), accounting.MinimumTotalDue);
+                entity.PaymentTolerance = 100;
+                accounting = paymentMethod.Calculate();
+                Assert.Equal(Money.Satoshis(1), accounting.MinimumTotalDue);
 
         }
 
@@ -1457,59 +1544,70 @@ namespace BTCPayServer.Tests
         [Trait("Fast", "Fast")]
         public void CanParseDerivationScheme()
         {
-            var parser = new DerivationSchemeParser(Network.TestNet);
+            var  testnetNetworkProvider = new BTCPayNetworkProvider(NetworkType.Testnet);
+            var regtestNetworkProvider = new BTCPayNetworkProvider(NetworkType.Regtest);
+            var mainnetNetworkProvider = new BTCPayNetworkProvider(NetworkType.Mainnet);
+            var testnetParser = new DerivationSchemeParser(testnetNetworkProvider.GetNetwork<BTCPayNetwork>("BTC"));
+            var mainnetParser = new DerivationSchemeParser(mainnetNetworkProvider.GetNetwork<BTCPayNetwork>("BTC"));
             NBXplorer.DerivationStrategy.DerivationStrategyBase result;
             //  Passing electrum stuff
-            // Native
-            result = parser.Parse("zpub6nL6PUGurpU3DfPDSZaRS6WshpbNc9ctCFFzrCn54cssnheM31SZJZUcFHKtjJJNhAueMbh6ptFMfy1aeiMQJr3RJ4DDt1hAPx7sMTKV48t");
+            // Passing a native segwit from mainnet to a testnet parser, means the testnet parser will try to convert it into segwit
+            result = testnetParser.Parse("zpub6nL6PUGurpU3DfPDSZaRS6WshpbNc9ctCFFzrCn54cssnheM31SZJZUcFHKtjJJNhAueMbh6ptFMfy1aeiMQJr3RJ4DDt1hAPx7sMTKV48t");
             Assert.Equal("tpubD93CJNkmGjLXnsBqE2zGDqfEh1Q8iJ8wueordy3SeWt1RngbbuxXCsqASuVWFywmfoCwUE1rSfNJbaH4cBNcbp8WcyZgPiiRSTazLGL8U9w", result.ToString());
+            result = mainnetParser.Parse("zpub6nL6PUGurpU3DfPDSZaRS6WshpbNc9ctCFFzrCn54cssnheM31SZJZUcFHKtjJJNhAueMbh6ptFMfy1aeiMQJr3RJ4DDt1hAPx7sMTKV48t");
+            Assert.Equal("xpub68fZn8w5ZTP5X4zymr1B1vKsMtJUiudtN2DZHQzJJc87gW1tXh7S4SALCsQijUzXstg2reVyuZYFuPnTDKXNiNgDZNpNiC4BrVzaaGEaRHj", result.ToString());
             // P2SH
-            result = parser.Parse("ypub6QqdH2c5z79681jUgdxjGJzGW9zpL4ryPCuhtZE4GpvrJoZqM823XQN6iSQeVbbbp2uCRQ9UgpeMcwiyV6qjvxTWVcxDn2XEAnioMUwsrQ5");
+            result = testnetParser.Parse("upub57Wa4MvRPNyAipy1MCpERxcFpHR2ZatyikppkyeWkoRL6QJvLVMo39jYdcaJVxyvBURyRVmErBEA5oGicKBgk1j72GAXSPFH5tUDoGZ8nEu");
             Assert.Equal("tpubD6NzVbkrYhZ4YWjDJUACG9E8fJx2NqNY1iynTiPKEjJrzzRKAgha3nNnwGXr2BtvCJKJHW4nmG7rRqc2AGGy2AECgt16seMyV2FZivUmaJg-[p2sh]", result.ToString());
-            result = parser.Parse("xpub661MyMwAqRbcGeVGU5e5KBcau1HHEUGf9Wr7k4FyLa8yRPNQrrVa7Ndrgg8Afbe2UYXMSL6tJBFd2JewwWASsePPLjkcJFL1tTVEs3UQ23X");
-            Assert.Equal("tpubD6NzVbkrYhZ4YSg7vGdAX6wxE8NwDrmih9SR6cK7gUtsAg37w5LfFpJgviCxC6bGGT4G3uckqH5fiV9ZLN1gm5qgQLVuymzFUR5ed7U7ksu-[legacy]", result.ToString());
+
+            result = mainnetParser.Parse("ypub6QqdH2c5z79681jUgdxjGJzGW9zpL4ryPCuhtZE4GpvrJoZqM823XQN6iSQeVbbbp2uCRQ9UgpeMcwiyV6qjvxTWVcxDn2XEAnioMUwsrQ5");
+            Assert.Equal("xpub661MyMwAqRbcGiYMrHB74DtmLBrNPSsUU6PV7ALAtpYyFhkc6TrUuLhxhET4VgwgQPnPfvYvEAHojf7QmQRj8imudHFoC7hju4f9xxri8wR-[p2sh]", result.ToString());
+
+            // if prefix not recognize, assume it is segwit
+            result = testnetParser.Parse("xpub661MyMwAqRbcGeVGU5e5KBcau1HHEUGf9Wr7k4FyLa8yRPNQrrVa7Ndrgg8Afbe2UYXMSL6tJBFd2JewwWASsePPLjkcJFL1tTVEs3UQ23X");
+            Assert.Equal("tpubD6NzVbkrYhZ4YSg7vGdAX6wxE8NwDrmih9SR6cK7gUtsAg37w5LfFpJgviCxC6bGGT4G3uckqH5fiV9ZLN1gm5qgQLVuymzFUR5ed7U7ksu", result.ToString());
             ////////////////
 
             var tpub = "tpubD6NzVbkrYhZ4Wc65tjhmcKdWFauAo7bGLRTxvggygkNyp6SMGutJp7iociwsinU33jyNBp1J9j2hJH5yQsayfiS3LEU2ZqXodAcnaygra8o";
 
-            result = parser.Parse(tpub);
+            result = testnetParser.Parse(tpub);
             Assert.Equal(tpub, result.ToString());
-            parser.HintScriptPubKey = BitcoinAddress.Create("tb1q4s33amqm8l7a07zdxcunqnn3gcsjcfz3xc573l", parser.Network).ScriptPubKey;
-            result = parser.Parse(tpub);
+            testnetParser.HintScriptPubKey = BitcoinAddress.Create("tb1q4s33amqm8l7a07zdxcunqnn3gcsjcfz3xc573l", testnetParser.Network).ScriptPubKey;
+            result = testnetParser.Parse(tpub);
             Assert.Equal(tpub, result.ToString());
 
-            parser.HintScriptPubKey = BitcoinAddress.Create("2N2humNio3YTApSfY6VztQ9hQwDnhDvaqFQ", parser.Network).ScriptPubKey;
-            result = parser.Parse(tpub);
+            testnetParser.HintScriptPubKey = BitcoinAddress.Create("2N2humNio3YTApSfY6VztQ9hQwDnhDvaqFQ", testnetParser.Network).ScriptPubKey;
+            result = testnetParser.Parse(tpub);
             Assert.Equal($"{tpub}-[p2sh]", result.ToString());
 
-            parser.HintScriptPubKey = BitcoinAddress.Create("mwD8bHS65cdgUf6rZUUSoVhi3wNQFu1Nfi", parser.Network).ScriptPubKey;
-            result = parser.Parse(tpub);
+            testnetParser.HintScriptPubKey = BitcoinAddress.Create("mwD8bHS65cdgUf6rZUUSoVhi3wNQFu1Nfi", testnetParser.Network).ScriptPubKey;
+            result = testnetParser.Parse(tpub);
             Assert.Equal($"{tpub}-[legacy]", result.ToString());
 
-            parser.HintScriptPubKey = BitcoinAddress.Create("2N2humNio3YTApSfY6VztQ9hQwDnhDvaqFQ", parser.Network).ScriptPubKey;
-            result = parser.Parse($"{tpub}-[legacy]");
+            testnetParser.HintScriptPubKey = BitcoinAddress.Create("2N2humNio3YTApSfY6VztQ9hQwDnhDvaqFQ", testnetParser.Network).ScriptPubKey;
+            result = testnetParser.Parse($"{tpub}-[legacy]");
             Assert.Equal($"{tpub}-[p2sh]", result.ToString());
 
-            result = parser.Parse(tpub);
+            result = testnetParser.Parse(tpub);
             Assert.Equal($"{tpub}-[p2sh]", result.ToString());
 
-            parser = new DerivationSchemeParser(Network.RegTest);
-            var parsed = parser.Parse("xpub6DG1rMYXiQtCc6CfdLFD9CtxqhzzRh7j6Sq6EdE9abgYy3cfDRrniLLv2AdwqHL1exiLnnKR5XXcaoiiexf3Y9R6J6rxkJtqJHzNzMW9QMZ-[p2sh]");
+            var regtestParser = new DerivationSchemeParser(regtestNetworkProvider.GetNetwork<BTCPayNetwork>("BTC"));
+            var parsed = regtestParser.Parse("xpub6DG1rMYXiQtCc6CfdLFD9CtxqhzzRh7j6Sq6EdE9abgYy3cfDRrniLLv2AdwqHL1exiLnnKR5XXcaoiiexf3Y9R6J6rxkJtqJHzNzMW9QMZ-[p2sh]");
             Assert.Equal("tpubDDdeNbNDRgqestPX5XEJM8ELAq6eR5cne5RPbBHHvWSSiLHNHehsrn1kGCijMnHFSsFFQMqHcdMfGzDL3pWHRasPMhcGRqZ4tFankQ3i4ok-[p2sh]", parsed.ToString());
 
             // Let's make sure we can't generate segwit with dogecoin
-            parser = new DerivationSchemeParser(NBitcoin.Altcoins.Dogecoin.Instance.Regtest);
-            parsed = parser.Parse("xpub6DG1rMYXiQtCc6CfdLFD9CtxqhzzRh7j6Sq6EdE9abgYy3cfDRrniLLv2AdwqHL1exiLnnKR5XXcaoiiexf3Y9R6J6rxkJtqJHzNzMW9QMZ-[p2sh]");
+            regtestParser = new DerivationSchemeParser(regtestNetworkProvider.GetNetwork<BTCPayNetwork>("DOGE"));
+            parsed = regtestParser.Parse("xpub6DG1rMYXiQtCc6CfdLFD9CtxqhzzRh7j6Sq6EdE9abgYy3cfDRrniLLv2AdwqHL1exiLnnKR5XXcaoiiexf3Y9R6J6rxkJtqJHzNzMW9QMZ-[p2sh]");
             Assert.Equal("tpubDDdeNbNDRgqestPX5XEJM8ELAq6eR5cne5RPbBHHvWSSiLHNHehsrn1kGCijMnHFSsFFQMqHcdMfGzDL3pWHRasPMhcGRqZ4tFankQ3i4ok-[legacy]", parsed.ToString());
 
-            parser = new DerivationSchemeParser(NBitcoin.Altcoins.Dogecoin.Instance.Regtest);
-            parsed = parser.Parse("tpubDDdeNbNDRgqestPX5XEJM8ELAq6eR5cne5RPbBHHvWSSiLHNHehsrn1kGCijMnHFSsFFQMqHcdMfGzDL3pWHRasPMhcGRqZ4tFankQ3i4ok-[p2sh]");
+            regtestParser = new DerivationSchemeParser(regtestNetworkProvider.GetNetwork<BTCPayNetwork>("DOGE"));
+            parsed = regtestParser.Parse("tpubDDdeNbNDRgqestPX5XEJM8ELAq6eR5cne5RPbBHHvWSSiLHNHehsrn1kGCijMnHFSsFFQMqHcdMfGzDL3pWHRasPMhcGRqZ4tFankQ3i4ok-[p2sh]");
             Assert.Equal("tpubDDdeNbNDRgqestPX5XEJM8ELAq6eR5cne5RPbBHHvWSSiLHNHehsrn1kGCijMnHFSsFFQMqHcdMfGzDL3pWHRasPMhcGRqZ4tFankQ3i4ok-[legacy]", parsed.ToString());
         }
 
         [Fact]
         [Trait("Integration", "Integration")]
-        public void CanDisablePaymentMethods()
+        public void CanAddDerivationSchemes()
         {
             using (var tester = ServerTester.Create())
             {
@@ -1519,7 +1617,7 @@ namespace BTCPayServer.Tests
                 user.RegisterDerivationScheme("BTC");
                 user.RegisterDerivationScheme("LTC");
                 user.RegisterLightningNode("BTC", LightningConnectionType.CLightning);
-
+                var btcNetwork = tester.PayTester.Networks.GetNetwork<BTCPayNetwork>("BTC");
                 var invoice = user.BitPay.CreateInvoice(new Invoice()
                 {
                     Price = 1.5m,
@@ -1540,16 +1638,18 @@ namespace BTCPayServer.Tests
                 lightningVM = (LightningNodeViewModel)Assert.IsType<ViewResult>(controller.AddLightningNode(user.StoreId, "BTC")).Model;
                 Assert.False(lightningVM.Enabled);
 
+                // Only Enabling/Disabling the payment method must redirect to store page
                 var derivationVM = (DerivationSchemeViewModel)Assert.IsType<ViewResult>(controller.AddDerivationScheme(user.StoreId, "BTC")).Model;
                 Assert.True(derivationVM.Enabled);
                 derivationVM.Enabled = false;
                 Assert.IsType<RedirectToActionResult>(controller.AddDerivationScheme(user.StoreId, derivationVM, "BTC").GetAwaiter().GetResult());
                 derivationVM = (DerivationSchemeViewModel)Assert.IsType<ViewResult>(controller.AddDerivationScheme(user.StoreId, "BTC")).Model;
-                // Confirmation
-                controller.AddDerivationScheme(user.StoreId, derivationVM, "BTC").GetAwaiter().GetResult();
                 Assert.False(derivationVM.Enabled);
+
+                // Clicking next without changing anything should send to the confirmation screen
                 derivationVM = (DerivationSchemeViewModel)Assert.IsType<ViewResult>(controller.AddDerivationScheme(user.StoreId, "BTC")).Model;
-                Assert.False(derivationVM.Enabled);
+                derivationVM = (DerivationSchemeViewModel)Assert.IsType<ViewResult>(controller.AddDerivationScheme(user.StoreId, derivationVM, "BTC").GetAwaiter().GetResult()).Model;
+                Assert.True(derivationVM.Confirmation);
 
                 invoice = user.BitPay.CreateInvoice(new Invoice()
                 {
@@ -1563,6 +1663,85 @@ namespace BTCPayServer.Tests
 
                 Assert.Single(invoice.CryptoInfo);
                 Assert.Equal("LTC", invoice.CryptoInfo[0].CryptoCode);
+
+                // Removing the derivation scheme, should redirect to store page
+                var oldScheme = derivationVM.DerivationScheme;
+                derivationVM = (DerivationSchemeViewModel)Assert.IsType<ViewResult>(controller.AddDerivationScheme(user.StoreId, "BTC")).Model;
+                derivationVM.DerivationScheme = null;
+                Assert.IsType<RedirectToActionResult>(controller.AddDerivationScheme(user.StoreId, derivationVM, "BTC").GetAwaiter().GetResult());
+
+                // Setting it again should redirect to the confirmation page
+                derivationVM = (DerivationSchemeViewModel)Assert.IsType<ViewResult>(controller.AddDerivationScheme(user.StoreId, "BTC")).Model;
+                derivationVM.DerivationScheme = oldScheme;
+                derivationVM = (DerivationSchemeViewModel)Assert.IsType<ViewResult>(controller.AddDerivationScheme(user.StoreId, derivationVM, "BTC").GetAwaiter().GetResult()).Model;
+                Assert.True(derivationVM.Confirmation);
+
+                // Can we upload coldcard settings? (Should fail, we are giving a mainnet file to a testnet network)
+                derivationVM = (DerivationSchemeViewModel)Assert.IsType<ViewResult>(controller.AddDerivationScheme(user.StoreId, "BTC")).Model;
+                string content = "{\"keystore\": {\"ckcc_xpub\": \"xpub661MyMwAqRbcGVBsTGeNZN6QGVHmMHLdSA4FteGsRrEriu4pnVZMZWnruFFFXkMnyoBjyHndD3Qwcfz4MPzBUxjSevweNFQx7SAYZATtcDw\", \"xpub\": \"ypub6WWc2gWwHbdnAAyJDnR4SPL1phRh7REqrPBfZeizaQ1EmTshieRXJC3Z5YoU4wkcdKHEjQGkh6AYEzCQC1Kz3DNaWSwdc1pc8416hAjzqyD\", \"label\": \"Coldcard Import 0x60d1af8b\", \"ckcc_xfp\": 1624354699, \"type\": \"hardware\", \"hw_type\": \"coldcard\", \"derivation\": \"m/49'/0'/0'\"}, \"wallet_type\": \"standard\", \"use_encryption\": false, \"seed_version\": 17}";
+                derivationVM.ColdcardPublicFile = TestUtils.GetFormFile("wallet.json", content);
+                derivationVM = (DerivationSchemeViewModel)Assert.IsType<ViewResult>(controller.AddDerivationScheme(user.StoreId, derivationVM, "BTC").GetAwaiter().GetResult()).Model;
+                Assert.False(derivationVM.Confirmation); // Should fail, we are giving a mainnet file to a testnet network 
+
+                // And with a good file? (upub)
+                content = "{\"keystore\": {\"ckcc_xpub\": \"tpubD6NzVbkrYhZ4YHNiuTdTmHRmbcPRLfqgyneZFCL1mkzkUBjXriQShxTh9HL34FK2mhieasJVk9EzJrUfkFqRNQBjiXgx3n5BhPkxKBoFmaS\", \"xpub\": \"upub5DBYp1qGgsTrkzCptMGZc2x18pquLwGrBw6nS59T4NViZ4cni1mGowQzziy85K8vzkp1jVtWrSkLhqk9KDfvrGeB369wGNYf39kX8rQfiLn\", \"label\": \"Coldcard Import 0x60d1af8b\", \"ckcc_xfp\": 1624354699, \"type\": \"hardware\", \"hw_type\": \"coldcard\", \"derivation\": \"m/49'/0'/0'\"}, \"wallet_type\": \"standard\", \"use_encryption\": false, \"seed_version\": 17}";
+                derivationVM = (DerivationSchemeViewModel)Assert.IsType<ViewResult>(controller.AddDerivationScheme(user.StoreId, "BTC")).Model;
+                derivationVM.ColdcardPublicFile = TestUtils.GetFormFile("wallet2.json", content);
+                derivationVM.Enabled = true;
+                derivationVM = (DerivationSchemeViewModel)Assert.IsType<ViewResult>(controller.AddDerivationScheme(user.StoreId, derivationVM, "BTC").GetAwaiter().GetResult()).Model;
+                Assert.True(derivationVM.Confirmation);
+                Assert.IsType<RedirectToActionResult>(controller.AddDerivationScheme(user.StoreId, derivationVM, "BTC").GetAwaiter().GetResult());
+
+                // Now let's check that no data has been lost in the process
+                var store = tester.PayTester.StoreRepository.FindStore(user.StoreId).GetAwaiter().GetResult();
+                var onchainBTC = store.GetSupportedPaymentMethods(tester.PayTester.Networks).OfType<DerivationSchemeSettings>().First(o => o.PaymentId.IsBTCOnChain);
+                DerivationSchemeSettings.TryParseFromColdcard(content, onchainBTC.Network, out var expected);
+                Assert.Equal(expected.ToJson(), onchainBTC.ToJson());
+
+                // Let's check that the root hdkey and account key path are taken into account when making a PSBT
+                invoice = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Price = 1.5m,
+                    Currency = "USD",
+                    PosData = "posData",
+                    OrderId = "orderId",
+                    ItemDesc = "Some description",
+                    FullNotifications = true
+                }, Facade.Merchant);
+
+                tester.ExplorerNode.Generate(1);
+                var invoiceAddress = BitcoinAddress.Create(invoice.CryptoInfo.First(c => c.CryptoCode == "BTC").Address, tester.ExplorerNode.Network);
+                tester.ExplorerNode.SendToAddress(invoiceAddress, Money.Coins(1m));
+                TestUtils.Eventually(() =>
+                {
+                    invoice = user.BitPay.GetInvoice(invoice.Id);
+                    Assert.Equal("paid", invoice.Status);
+                });
+                var wallet = tester.PayTester.GetController<WalletsController>();
+                var psbt = wallet.CreatePSBT(btcNetwork, onchainBTC, new WalletSendModel()
+                {
+                   Outputs = new List<WalletSendModel.TransactionOutput>()
+                   {
+                       new WalletSendModel.TransactionOutput()
+                       {
+                           Amount = 0.5m,
+                           DestinationAddress = new Key().PubKey.GetAddress(btcNetwork.NBitcoinNetwork).ToString(),
+                       }
+                   },
+                    FeeSatoshiPerByte = 1
+                }, default).GetAwaiter().GetResult();
+
+                Assert.NotNull(psbt);
+
+                var root = new Mnemonic("usage fever hen zero slide mammal silent heavy donate budget pulse say brain thank sausage brand craft about save attract muffin advance illegal cabbage").DeriveExtKey().AsHDKeyCache();
+                var account = root.Derive(new KeyPath("m/49'/0'/0'"));
+                Assert.All(psbt.PSBT.Inputs, input =>
+                {
+                    var keyPath = input.HDKeyPaths.Single();
+                    Assert.False(keyPath.Value.KeyPath.IsHardened);
+                    Assert.Equal(account.Derive(keyPath.Value.KeyPath).GetPublicKey(), keyPath.Key);
+                    Assert.Equal(keyPath.Value.MasterFingerprint, onchainBTC.AccountKeySettings[0].AccountKey.GetPublicKey().GetHDFingerPrint());
+                });
             }
         }
 
@@ -1992,8 +2171,8 @@ donation:
                     var firstPayment = productPartDue - missingMoney;
                     cashCow.SendToAddress(invoiceAddress, Money.Coins(firstPayment));
 
-                    TestUtils.Eventually(() =>
-                    {
+                        TestUtils.Eventually(() =>
+                        {
                         invoice = user.BitPay.GetInvoice(invoice.Id);
                         // Check that for the second payment, network fee are included
                         due = Money.Parse(invoice.CryptoInfo[0].Due);
@@ -2051,14 +2230,13 @@ donation:
                 var invoiceAddress = BitcoinAddress.Create(invoice.CryptoInfo[0].Address, cashCow.Network);
                 var firstPayment = invoice.CryptoInfo[0].TotalDue - Money.Coins(0.001m);
                 cashCow.SendToAddress(invoiceAddress, firstPayment);
-
                 TestUtils.Eventually(() =>
                 {
                     var exportResultPaid = user.GetController<InvoiceController>().Export("csv").GetAwaiter().GetResult();
                     var paidresult = Assert.IsType<ContentResult>(exportResultPaid);
                     Assert.Equal("application/csv", paidresult.ContentType);
                     Assert.Contains($",\"orderId\",\"{invoice.Id}\",", paidresult.Content);
-                    Assert.Contains($",\"OnChain\",\"BTC\",\"0.0991\",\"0.0001\",\"5000.0\"", paidresult.Content);
+                    Assert.Contains($",\"On-Chain\",\"BTC\",\"0.0991\",\"0.0001\",\"5000.0\"", paidresult.Content);
                     Assert.Contains($",\"USD\",\"5.00", paidresult.Content); // Seems hacky but some plateform does not render this decimal the same
                     Assert.Contains($"0\",\"500.0\",\"\",\"Some ``, description\",\"new (paidPartial)\"", paidresult.Content);
                 });
@@ -2466,27 +2644,28 @@ donation:
         {
             var unusedUri = new Uri("https://toto.com");
             Assert.True(ExternalConnectionString.TryParse("server=/test", out var connStr, out var error));
-            var expanded = await connStr.Expand(new Uri("https://toto.com"), ExternalServiceTypes.Charge);
+            var expanded = await connStr.Expand(new Uri("https://toto.com"), ExternalServiceTypes.Charge, NetworkType.Mainnet);
             Assert.Equal(new Uri("https://toto.com/test"), expanded.Server);
-            expanded = await connStr.Expand(new Uri("http://toto.onion"), ExternalServiceTypes.Charge);
+            expanded = await connStr.Expand(new Uri("http://toto.onion"), ExternalServiceTypes.Charge, NetworkType.Mainnet);
             Assert.Equal(new Uri("http://toto.onion/test"), expanded.Server);
-            await Assert.ThrowsAsync<SecurityException>(() => connStr.Expand(new Uri("http://toto.com"), ExternalServiceTypes.Charge));
+            await Assert.ThrowsAsync<SecurityException>(() => connStr.Expand(new Uri("http://toto.com"), ExternalServiceTypes.Charge, NetworkType.Mainnet));
+            await connStr.Expand(new Uri("http://toto.com"), ExternalServiceTypes.Charge, NetworkType.Testnet);
 
             // Make sure absolute paths are not expanded
             Assert.True(ExternalConnectionString.TryParse("server=https://tow/test", out connStr, out error));
-            expanded = await connStr.Expand(new Uri("https://toto.com"), ExternalServiceTypes.Charge);
+            expanded = await connStr.Expand(new Uri("https://toto.com"), ExternalServiceTypes.Charge, NetworkType.Mainnet);
             Assert.Equal(new Uri("https://tow/test"), expanded.Server);
 
             // Error if directory not exists
             Assert.True(ExternalConnectionString.TryParse($"server={unusedUri};macaroondirectorypath=pouet", out connStr, out error));
-            await Assert.ThrowsAsync<DirectoryNotFoundException>(() => connStr.Expand(unusedUri, ExternalServiceTypes.LNDGRPC));
-            await Assert.ThrowsAsync<DirectoryNotFoundException>(() => connStr.Expand(unusedUri, ExternalServiceTypes.LNDRest));
-            await connStr.Expand(unusedUri, ExternalServiceTypes.Charge);
+            await Assert.ThrowsAsync<DirectoryNotFoundException>(() => connStr.Expand(unusedUri, ExternalServiceTypes.LNDGRPC, NetworkType.Mainnet));
+            await Assert.ThrowsAsync<DirectoryNotFoundException>(() => connStr.Expand(unusedUri, ExternalServiceTypes.LNDRest, NetworkType.Mainnet));
+            await connStr.Expand(unusedUri, ExternalServiceTypes.Charge, NetworkType.Mainnet);
 
             var macaroonDirectory = CreateDirectory();
             Assert.True(ExternalConnectionString.TryParse($"server={unusedUri};macaroondirectorypath={macaroonDirectory}", out connStr, out error));
-            await connStr.Expand(unusedUri, ExternalServiceTypes.LNDGRPC);
-            expanded = await connStr.Expand(unusedUri, ExternalServiceTypes.LNDRest);
+            await connStr.Expand(unusedUri, ExternalServiceTypes.LNDGRPC, NetworkType.Mainnet);
+            expanded = await connStr.Expand(unusedUri, ExternalServiceTypes.LNDRest, NetworkType.Mainnet);
             Assert.NotNull(expanded.Macaroons);
             Assert.Null(expanded.MacaroonFilePath);
             Assert.Null(expanded.Macaroons.AdminMacaroon);
@@ -2496,7 +2675,7 @@ donation:
             File.WriteAllBytes($"{macaroonDirectory}/admin.macaroon", new byte[] { 0xaa });
             File.WriteAllBytes($"{macaroonDirectory}/invoice.macaroon", new byte[] { 0xab });
             File.WriteAllBytes($"{macaroonDirectory}/readonly.macaroon", new byte[] { 0xac });
-            expanded = await connStr.Expand(unusedUri, ExternalServiceTypes.LNDRest);
+            expanded = await connStr.Expand(unusedUri, ExternalServiceTypes.LNDRest, NetworkType.Mainnet);
             Assert.NotNull(expanded.Macaroons.AdminMacaroon);
             Assert.NotNull(expanded.Macaroons.InvoiceMacaroon);
             Assert.Equal("ab", expanded.Macaroons.InvoiceMacaroon.Hex);
@@ -2505,7 +2684,7 @@ donation:
 
             Assert.True(ExternalConnectionString.TryParse($"server={unusedUri};cookiefilepath={macaroonDirectory}/charge.cookie", out connStr, out error));
             File.WriteAllText($"{macaroonDirectory}/charge.cookie", "apitoken");
-            expanded = await connStr.Expand(unusedUri, ExternalServiceTypes.Charge);
+            expanded = await connStr.Expand(unusedUri, ExternalServiceTypes.Charge, NetworkType.Mainnet);
             Assert.Equal("apitoken", expanded.APIToken);
         }
 
@@ -2574,6 +2753,35 @@ donation:
             Assert.Throws<InvalidOperationException>(() => fetch.GetRatesAsync(default).GetAwaiter().GetResult());
         }
 
+        [Fact]
+        [Trait("Fast", "Fast")]
+        public void ParseDerivationSchemeSettings()
+        {
+            var mainnet = new BTCPayNetworkProvider(NetworkType.Mainnet).GetNetwork<BTCPayNetwork>("BTC");
+            var root = new Mnemonic("usage fever hen zero slide mammal silent heavy donate budget pulse say brain thank sausage brand craft about save attract muffin advance illegal cabbage").DeriveExtKey();
+            Assert.True(DerivationSchemeSettings.TryParseFromColdcard("{\"keystore\": {\"ckcc_xpub\": \"xpub661MyMwAqRbcGVBsTGeNZN6QGVHmMHLdSA4FteGsRrEriu4pnVZMZWnruFFFXkMnyoBjyHndD3Qwcfz4MPzBUxjSevweNFQx7SAYZATtcDw\", \"xpub\": \"ypub6WWc2gWwHbdnAAyJDnR4SPL1phRh7REqrPBfZeizaQ1EmTshieRXJC3Z5YoU4wkcdKHEjQGkh6AYEzCQC1Kz3DNaWSwdc1pc8416hAjzqyD\", \"label\": \"Coldcard Import 0x60d1af8b\", \"ckcc_xfp\": 1624354699, \"type\": \"hardware\", \"hw_type\": \"coldcard\", \"derivation\": \"m/49'/0'/0'\"}, \"wallet_type\": \"standard\", \"use_encryption\": false, \"seed_version\": 17}", mainnet, out var settings));
+            Assert.Equal(root.GetPublicKey().GetHDFingerPrint(), settings.AccountKeySettings[0].RootFingerprint);
+            Assert.Equal(settings.AccountKeySettings[0].RootFingerprint, HDFingerprint.TryParse("8bafd160", out var hd) ? hd : default);
+            Assert.Equal("Coldcard Import 0x60d1af8b", settings.Label);
+            Assert.Equal("49'/0'/0'", settings.AccountKeySettings[0].AccountKeyPath.ToString());
+            Assert.Equal("ypub6WWc2gWwHbdnAAyJDnR4SPL1phRh7REqrPBfZeizaQ1EmTshieRXJC3Z5YoU4wkcdKHEjQGkh6AYEzCQC1Kz3DNaWSwdc1pc8416hAjzqyD", settings.AccountOriginal);
+            Assert.Equal(root.Derive(new KeyPath("m/49'/0'/0'")).Neuter().PubKey.WitHash.ScriptPubKey.Hash.ScriptPubKey, settings.AccountDerivation.Derive(new KeyPath()).ScriptPubKey);
+
+            var testnet = new BTCPayNetworkProvider(NetworkType.Testnet).GetNetwork<BTCPayNetwork>("BTC");
+
+            // Should be legacy
+            Assert.True(DerivationSchemeSettings.TryParseFromColdcard("{\"keystore\": {\"ckcc_xpub\": \"tpubD6NzVbkrYhZ4YHNiuTdTmHRmbcPRLfqgyneZFCL1mkzkUBjXriQShxTh9HL34FK2mhieasJVk9EzJrUfkFqRNQBjiXgx3n5BhPkxKBoFmaS\", \"xpub\": \"tpubDDWYqT3P24znfsaGX7kZcQhNc5LAjnQiKQvUCHF2jS6dsgJBRtymopEU5uGpMaR5YChjuiExZG1X2aTbqXkp82KqH5qnqwWHp6EWis9ZvKr\", \"label\": \"Coldcard Import 0x60d1af8b\", \"ckcc_xfp\": 1624354699, \"type\": \"hardware\", \"hw_type\": \"coldcard\", \"derivation\": \"m/44'/1'/0'\"}, \"wallet_type\": \"standard\", \"use_encryption\": false, \"seed_version\": 17}", testnet, out settings));
+            Assert.True(settings.AccountDerivation is DirectDerivationStrategy s && !s.Segwit);
+
+            // Should be segwit p2sh
+            Assert.True(DerivationSchemeSettings.TryParseFromColdcard("{\"keystore\": {\"ckcc_xpub\": \"tpubD6NzVbkrYhZ4YHNiuTdTmHRmbcPRLfqgyneZFCL1mkzkUBjXriQShxTh9HL34FK2mhieasJVk9EzJrUfkFqRNQBjiXgx3n5BhPkxKBoFmaS\", \"xpub\": \"upub5DSddA9NoRUyJrQ4p86nsCiTSY7kLHrSxx3joEJXjHd4HPARhdXUATuk585FdWPVC2GdjsMePHb6BMDmf7c6KG4K4RPX6LVqBLtDcWpQJmh\", \"label\": \"Coldcard Import 0x60d1af8b\", \"ckcc_xfp\": 1624354699, \"type\": \"hardware\", \"hw_type\": \"coldcard\", \"derivation\": \"m/49'/1'/0'\"}, \"wallet_type\": \"standard\", \"use_encryption\": false, \"seed_version\": 17}", testnet, out settings));
+            Assert.True(settings.AccountDerivation is P2SHDerivationStrategy p && p.Inner is DirectDerivationStrategy s2 && s2.Segwit);
+
+            // Should be segwit
+            Assert.True(DerivationSchemeSettings.TryParseFromColdcard("{\"keystore\": {\"ckcc_xpub\": \"tpubD6NzVbkrYhZ4YHNiuTdTmHRmbcPRLfqgyneZFCL1mkzkUBjXriQShxTh9HL34FK2mhieasJVk9EzJrUfkFqRNQBjiXgx3n5BhPkxKBoFmaS\", \"xpub\": \"vpub5YjYxTemJ39tFRnuAhwduyxG2tKGjoEpmvqVQRPqdYrqa6YGoeSzBtHXaJUYB19zDbXs3JjbEcVWERjQBPf9bEfUUMZNMv1QnMyHV8JPqyf\", \"label\": \"Coldcard Import 0x60d1af8b\", \"ckcc_xfp\": 1624354699, \"type\": \"hardware\", \"hw_type\": \"coldcard\", \"derivation\": \"m/84'/1'/0'\"}, \"wallet_type\": \"standard\", \"use_encryption\": false, \"seed_version\": 17}", testnet, out settings));
+            Assert.True(settings.AccountDerivation is DirectDerivationStrategy s3 && s3.Segwit);
+        }
+
         [Fact]
         [Trait("Fast", "Fast")]
         public void CheckParseStatusMessageModel()
@@ -2721,42 +2929,5 @@ donation:
             var h = BitcoinAddress.Create(invoice.BitcoinAddress, Network.RegTest).ScriptPubKey.Hash.ToString();
             return ctx.AddressInvoices.FirstOrDefault(i => i.InvoiceDataId == invoice.Id && i.GetAddress() == h) != null;
         }
-
-        public static class TestUtils
-        {
-            public static void Eventually(Action act)
-            {
-                CancellationTokenSource cts = new CancellationTokenSource(20000);
-                while (true)
-                {
-                    try
-                    {
-                        act();
-                        break;
-                    }
-                    catch (XunitException) when (!cts.Token.IsCancellationRequested)
-                    {
-                        cts.Token.WaitHandle.WaitOne(500);
-                    }
-                }
-            }
-
-            public static 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/UtilitiesTests.cs

@@ -9,6 +9,7 @@ using NBitcoin.DataEncoders;
 using Newtonsoft.Json.Linq;
 using Xunit;
 using System.IO;
+using BTCPayServer.Services.Rates;
 
 namespace BTCPayServer.Tests
 {

BTCPayServer.Tests/docker-bitcoin-generate.ps1

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

BTCPayServer.Tests/docker-compose.yml

@@ -67,11 +67,8 @@ services:
       - mysql
       - customer_lnd
       - merchant_lnd
-
-
-
   nbxplorer:
-    image: nicolasdorier/nbxplorer:2.0.0.38
+    image: nicolasdorier/nbxplorer:2.0.0.55
     restart: unless-stopped
     ports:
       - "32838:32838"
@@ -134,6 +131,7 @@ services:
         bind-addr=0.0.0.0
         announce-addr=customer_lightningd
         log-level=debug
+        funding-confirms=1
         dev-broadcast-interval=1000
         dev-bitcoind-poll=1
     ports:
@@ -177,6 +175,7 @@ services:
         bitcoin-rpcconnect=bitcoind
         bind-addr=0.0.0.0
         announce-addr=merchant_lightningd
+        funding-confirms=1
         network=regtest
         log-level=debug
         dev-broadcast-interval=1000
@@ -225,7 +224,7 @@ services:
       - MYSQL_ALLOW_EMPTY_PASSWORD=yes
 
   merchant_lnd:
-    image: btcpayserver/lnd:v0.6-beta
+    image: btcpayserver/lnd:v0.7.0-beta
     restart: unless-stopped
     environment:
       LND_CHAIN: "btc"
@@ -240,6 +239,7 @@ services:
         bitcoind.zmqpubrawblock=tcp://bitcoind:28332
         bitcoind.zmqpubrawtx=tcp://bitcoind:28333
         externalip=merchant_lnd:9735
+        bitcoin.defaultchanconfs=1
         no-macaroons=1
         debuglevel=debug
         noseedbackup=1
@@ -255,7 +255,7 @@ services:
       - bitcoind
 
   customer_lnd:
-    image: btcpayserver/lnd:v0.6-beta
+    image: btcpayserver/lnd:v0.7.0-beta
     restart: unless-stopped
     environment:
       LND_CHAIN: "btc"
@@ -270,6 +270,7 @@ services:
         bitcoind.zmqpubrawblock=tcp://bitcoind:28332
         bitcoind.zmqpubrawtx=tcp://bitcoind:28333
         externalip=customer_lnd:10009
+        bitcoin.defaultchanconfs=1
         no-macaroons=1
         debuglevel=debug
         noseedbackup=1

BTCPayServer.Tests/docker-entrypoint.sh

@@ -1,8 +1,9 @@
 #!/bin/sh
 set -e
 
-dotnet test --filter Fast=Fast --no-build
-dotnet test --filter Integration=Integration --no-build -v n
-if [[ "$TESTS_RUN_EXTERNAL_INTEGRATION" == "true" ]]; then
-    dotnet test --filter ExternalIntegration=ExternalIntegration --no-build -v n
+FILTERS=" "
+if [[ "$TEST_FILTERS" ]]; then
+FILTERS="--filter $TEST_FILTERS"
 fi
+
+dotnet test $FILTERS --no-build -v n

BTCPayServer/Authentication/OpenId/AuthorizationCodeGrantTypeEventHandler.cs

@@ -0,0 +1,21 @@
+using AspNet.Security.OpenIdConnect.Primitives;
+using BTCPayServer.Models;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.Extensions.Options;
+
+namespace BTCPayServer.Authentication.OpenId
+{
+    public class AuthorizationCodeGrantTypeEventHandler : OpenIdGrantHandlerCheckCanSignIn
+    {
+        public AuthorizationCodeGrantTypeEventHandler(SignInManager<ApplicationUser> signInManager,
+            IOptions<IdentityOptions> identityOptions, UserManager<ApplicationUser> userManager) : base(signInManager,
+            identityOptions, userManager)
+        {
+        }
+
+        protected override bool IsValid(OpenIdConnectRequest request)
+        {
+            return request.IsAuthorizationCodeGrantType();
+        }
+    }
+}

BTCPayServer/Authentication/OpenId/AuthorizationEventHandler.cs

@@ -0,0 +1,78 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using AspNet.Security.OpenIdConnect.Primitives;
+using BTCPayServer.Models;
+using BTCPayServer.Security;
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Authentication.Cookies;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.Extensions.Options;
+using OpenIddict.Abstractions;
+using OpenIddict.Server;
+
+namespace BTCPayServer.Authentication.OpenId
+{
+    public class AuthorizationEventHandler : BaseOpenIdGrantHandler<OpenIddictServerEvents.HandleAuthorizationRequest>
+    {
+        private readonly UserManager<ApplicationUser> _userManager;
+
+        public override async Task<OpenIddictServerEventState> HandleAsync(
+            OpenIddictServerEvents.HandleAuthorizationRequest notification)
+        {
+            if (!notification.Context.Request.IsAuthorizationRequest())
+            {
+                return OpenIddictServerEventState.Unhandled;
+            }
+
+            var auth = await notification.Context.HttpContext.AuthenticateAsync();
+            if (!auth.Succeeded)
+            {
+                // If the client application request promptless authentication,
+                // return an error indicating that the user is not logged in.
+                if (notification.Context.Request.HasPrompt(OpenIdConnectConstants.Prompts.None))
+                {
+                    var properties = new AuthenticationProperties(new Dictionary<string, string>
+                    {
+                        [OpenIdConnectConstants.Properties.Error] = OpenIdConnectConstants.Errors.LoginRequired,
+                        [OpenIdConnectConstants.Properties.ErrorDescription] = "The user is not logged in."
+                    });
+
+
+                    // Ask OpenIddict to return a login_required error to the client application.
+                    await notification.Context.HttpContext.ForbidAsync(properties);
+                    notification.Context.HandleResponse();
+                    return OpenIddictServerEventState.Handled;
+                }
+
+                await notification.Context.HttpContext.ChallengeAsync();
+                notification.Context.HandleResponse();
+                return OpenIddictServerEventState.Handled;
+            }
+
+            // Retrieve the profile of the logged in user.
+            var user = await _userManager.GetUserAsync(auth.Principal);
+            if (user == null)
+            {
+                notification.Context.Reject(
+                    error: OpenIddictConstants.Errors.InvalidGrant,
+                    description: "An internal error has occurred");
+
+                return OpenIddictServerEventState.Handled;
+            }
+
+            // Create a new authentication ticket.
+            var ticket = await CreateTicketAsync(notification.Context.Request, user);
+
+            // Returning a SignInResult will ask OpenIddict to issue the appropriate access/identity tokens.
+            notification.Context.Validate(ticket);
+            return OpenIddictServerEventState.Handled;
+        }
+
+        public AuthorizationEventHandler(
+            UserManager<ApplicationUser> userManager, SignInManager<ApplicationUser> signInManager,
+            IOptions<IdentityOptions> identityOptions) : base(signInManager, identityOptions)
+        {
+            _userManager = userManager;
+        }
+    }
+}

BTCPayServer/Authentication/OpenId/BaseOpenIdGrantHandler.cs

@@ -0,0 +1,104 @@
+using System.Collections.Generic;
+using System.Security.Claims;
+using System.Threading.Tasks;
+using AspNet.Security.OpenIdConnect.Extensions;
+using AspNet.Security.OpenIdConnect.Primitives;
+using BTCPayServer.Models;
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.Extensions.Options;
+using OpenIddict.Abstractions;
+using OpenIddict.Server;
+
+namespace BTCPayServer.Authentication.OpenId
+{
+    public abstract class BaseOpenIdGrantHandler<T> : IOpenIddictServerEventHandler<T>
+        where T : class, IOpenIddictServerEvent
+    {
+        protected readonly SignInManager<ApplicationUser> _signInManager;
+        protected readonly IOptions<IdentityOptions> _identityOptions;
+
+        protected BaseOpenIdGrantHandler(SignInManager<ApplicationUser> signInManager,
+            IOptions<IdentityOptions> identityOptions)
+        {
+            _signInManager = signInManager;
+            _identityOptions = identityOptions;
+        }
+
+        protected async Task<AuthenticationTicket> CreateTicketAsync(
+            OpenIdConnectRequest request, ApplicationUser user,
+            AuthenticationProperties properties = null)
+        {
+            // Create a new ClaimsPrincipal containing the claims that
+            // will be used to create an id_token, a token or a code.
+            var principal = await _signInManager.CreateUserPrincipalAsync(user);
+
+            // Create a new authentication ticket holding the user identity.
+            var ticket = new AuthenticationTicket(principal, properties,
+                OpenIddictServerDefaults.AuthenticationScheme);
+
+            if (!request.IsAuthorizationCodeGrantType() && !request.IsRefreshTokenGrantType())
+            {
+                // Note: in this sample, the granted scopes match the requested scope
+                // but you may want to allow the user to uncheck specific scopes.
+                // For that, simply restrict the list of scopes before calling SetScopes.
+                ticket.SetScopes(request.GetScopes());
+            }
+
+            foreach (var claim in ticket.Principal.Claims)
+            {
+                claim.SetDestinations(GetDestinations(claim, ticket));
+            }
+
+            return ticket;
+        }
+
+        private IEnumerable<string> GetDestinations(Claim claim, AuthenticationTicket ticket)
+        {
+            // Note: by default, claims are NOT automatically included in the access and identity tokens.
+            // To allow OpenIddict to serialize them, you must attach them a destination, that specifies
+            // whether they should be included in access tokens, in identity tokens or in both.
+
+
+            switch (claim.Type)
+            {
+                case OpenIddictConstants.Claims.Name:
+                    yield return OpenIddictConstants.Destinations.AccessToken;
+
+                    if (ticket.HasScope(OpenIddictConstants.Scopes.Profile))
+                        yield return OpenIddictConstants.Destinations.IdentityToken;
+
+                    yield break;
+
+                case OpenIddictConstants.Claims.Email:
+                    yield return OpenIddictConstants.Destinations.AccessToken;
+
+                    if (ticket.HasScope(OpenIddictConstants.Scopes.Email))
+                        yield return OpenIddictConstants.Destinations.IdentityToken;
+
+                    yield break;
+
+                case OpenIddictConstants.Claims.Role:
+                    yield return OpenIddictConstants.Destinations.AccessToken;
+
+                    if (ticket.HasScope(OpenIddictConstants.Scopes.Roles))
+                        yield return OpenIddictConstants.Destinations.IdentityToken;
+
+                    yield break;
+                default:
+                    if (claim.Type == _identityOptions.Value.ClaimsIdentity.SecurityStampClaimType)
+                    {
+                        // Never include the security stamp in the access and identity tokens, as it's a secret value.
+                        yield break;
+                    }
+                    else
+                    {
+                        yield return OpenIddictConstants.Destinations.AccessToken;
+                        yield break;
+                    }
+            }
+        }
+
+        public abstract Task<OpenIddictServerEventState> HandleAsync(T notification);
+    }
+}

BTCPayServer/Authentication/OpenId/ClientCredentialsGrantTypeEventHandler.cs

@@ -0,0 +1,61 @@
+using System.Security.Claims;
+using System.Threading.Tasks;
+using AspNet.Security.OpenIdConnect.Extensions;
+using AspNet.Security.OpenIdConnect.Primitives;
+using BTCPayServer.Authentication.OpenId.Models;
+using BTCPayServer.Models;
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.Extensions.Options;
+using OpenIddict.Abstractions;
+using OpenIddict.Core;
+using OpenIddict.EntityFrameworkCore.Models;
+using OpenIddict.Server;
+
+namespace BTCPayServer.Authentication.OpenId
+{
+    public class
+        ClientCredentialsGrantTypeEventHandler : BaseOpenIdGrantHandler<OpenIddictServerEvents.HandleTokenRequest>
+    {
+        private readonly OpenIddictApplicationManager<BTCPayOpenIdClient> _applicationManager;
+
+        private readonly UserManager<ApplicationUser> _userManager;
+
+        public ClientCredentialsGrantTypeEventHandler(SignInManager<ApplicationUser> signInManager,
+            OpenIddictApplicationManager<BTCPayOpenIdClient> applicationManager,
+            IOptions<IdentityOptions> identityOptions, UserManager<ApplicationUser> userManager) : base(signInManager,
+            identityOptions)
+        {
+            _applicationManager = applicationManager;
+            _userManager = userManager;
+        }
+
+        public override async Task<OpenIddictServerEventState> HandleAsync(
+            OpenIddictServerEvents.HandleTokenRequest notification)
+        {
+            var request = notification.Context.Request;
+            if (!request.IsClientCredentialsGrantType())
+            {
+                // Allow other handlers to process the event.
+                return OpenIddictServerEventState.Unhandled;
+            }
+
+            var application = await _applicationManager.FindByClientIdAsync(request.ClientId,
+                notification.Context.HttpContext.RequestAborted);
+            if (application == null)
+            {
+                notification.Context.Reject(
+                    error: OpenIddictConstants.Errors.InvalidClient,
+                    description: "The client application was not found in the database.");
+                // Don't allow other handlers to process the event.
+                return OpenIddictServerEventState.Handled;
+            }
+
+            var user = await _userManager.FindByIdAsync(application.ApplicationUserId);
+
+            notification.Context.Validate(await CreateTicketAsync(request, user));
+            // Don't allow other handlers to process the event.
+            return OpenIddictServerEventState.Handled;
+        }
+    }
+}

BTCPayServer/Authentication/OpenId/LogoutEventHandler.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Threading.Tasks;
+using BTCPayServer.Models;
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.Extensions.Options;
+using OpenIddict.Server;
+
+namespace BTCPayServer.Authentication.OpenId
+{
+
+    public class LogoutEventHandler: BaseOpenIdGrantHandler<OpenIddictServerEvents.HandleLogoutRequest>
+    {
+        public LogoutEventHandler(SignInManager<ApplicationUser> signInManager, IOptions<IdentityOptions> identityOptions) : base(signInManager, identityOptions)
+        {
+        }
+
+        public override async Task<OpenIddictServerEventState> HandleAsync(OpenIddictServerEvents.HandleLogoutRequest notification)
+        {
+            // Ask ASP.NET Core Identity to delete the local and external cookies created
+            // when the user agent is redirected from the external identity provider
+            // after a successful authentication flow (e.g Google or Facebook).
+            await _signInManager.SignOutAsync();
+
+            // Returning a SignOutResult will ask OpenIddict to redirect the user agent
+            // to the post_logout_redirect_uri specified by the client application.
+            await notification.Context.HttpContext.SignOutAsync(OpenIddictServerDefaults.AuthenticationScheme);
+            notification.Context.HandleResponse();
+            return OpenIddictServerEventState.Handled;
+        }
+    }
+}

BTCPayServer/Authentication/OpenId/Models/BTCPayOpenIdAuthorization.cs

@@ -0,0 +1,6 @@
+using OpenIddict.EntityFrameworkCore.Models;
+
+namespace BTCPayServer.Authentication.OpenId.Models
+{
+    public class BTCPayOpenIdAuthorization : OpenIddictAuthorization<string, BTCPayOpenIdClient, BTCPayOpenIdToken> { }
+}

BTCPayServer/Authentication/OpenId/Models/BTCPayOpenIdClient.cs

@@ -0,0 +1,11 @@
+using BTCPayServer.Models;
+using OpenIddict.EntityFrameworkCore.Models;
+
+namespace BTCPayServer.Authentication.OpenId.Models
+{
+    public class BTCPayOpenIdClient: OpenIddictApplication<string, BTCPayOpenIdAuthorization, BTCPayOpenIdToken>
+    {
+        public string ApplicationUserId { get; set; }
+        public ApplicationUser ApplicationUser { get; set; }
+    }
+}

BTCPayServer/Authentication/OpenId/Models/BTCPayOpenIdToken.cs

@@ -0,0 +1,6 @@
+using OpenIddict.EntityFrameworkCore.Models;
+
+namespace BTCPayServer.Authentication.OpenId.Models
+{
+    public class BTCPayOpenIdToken : OpenIddictToken<string, BTCPayOpenIdClient, BTCPayOpenIdAuthorization> { }
+}

BTCPayServer/Authentication/OpenId/OpenIdGrantHandlerCheckCanSignIn.cs

@@ -0,0 +1,65 @@
+using System.Threading.Tasks;
+using AspNet.Security.OpenIdConnect.Primitives;
+using BTCPayServer.Models;
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.Extensions.Options;
+using OpenIddict.Abstractions;
+using OpenIddict.Server;
+
+namespace BTCPayServer.Authentication.OpenId
+{
+    public abstract class
+        OpenIdGrantHandlerCheckCanSignIn : BaseOpenIdGrantHandler<OpenIddictServerEvents.HandleTokenRequest>
+    {
+        private readonly UserManager<ApplicationUser> _userManager;
+
+        protected OpenIdGrantHandlerCheckCanSignIn(SignInManager<ApplicationUser> signInManager,
+            IOptions<IdentityOptions> identityOptions, UserManager<ApplicationUser> userManager) : base(signInManager,
+            identityOptions)
+        {
+            _userManager = userManager;
+        }
+
+        protected abstract bool IsValid(OpenIdConnectRequest request);
+
+        public override async Task<OpenIddictServerEventState> HandleAsync(
+            OpenIddictServerEvents.HandleTokenRequest notification)
+        {
+            var request = notification.Context.Request;
+            if (!IsValid(request))
+            {
+                // Allow other handlers to process the event.
+                return OpenIddictServerEventState.Unhandled;
+            }
+
+            var scheme = notification.Context.Scheme.Name;
+            var authenticateResult = (await notification.Context.HttpContext.AuthenticateAsync(scheme));
+
+
+            var user = await _userManager.GetUserAsync(authenticateResult.Principal);
+            if (user == null)
+            {
+                notification.Context.Reject(
+                    error: OpenIddictConstants.Errors.InvalidGrant,
+                    description: "The token is no longer valid.");
+                // Don't allow other handlers to process the event.
+                return OpenIddictServerEventState.Handled;
+            }
+
+            // Ensure the user is still allowed to sign in.
+            if (!await _signInManager.CanSignInAsync(user))
+            {
+                notification.Context.Reject(
+                    error: OpenIddictConstants.Errors.InvalidGrant,
+                    description: "The user is no longer allowed to sign in.");
+                // Don't allow other handlers to process the event.
+                return OpenIddictServerEventState.Handled;
+            }
+
+            notification.Context.Validate(await CreateTicketAsync(request, user));
+            // Don't allow other handlers to process the event.
+            return OpenIddictServerEventState.Handled;
+        }
+    }
+}

BTCPayServer/Authentication/OpenId/PasswordGrantTypeEventHandler.cs

@@ -0,0 +1,57 @@
+using System.Threading.Tasks;
+using AspNet.Security.OpenIdConnect.Primitives;
+using BTCPayServer.Models;
+using BTCPayServer.Services.U2F;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.Extensions.Options;
+using OpenIddict.Abstractions;
+using OpenIddict.Server;
+
+namespace BTCPayServer.Authentication.OpenId
+{
+    public class PasswordGrantTypeEventHandler : BaseOpenIdGrantHandler<OpenIddictServerEvents.HandleTokenRequest>
+    {
+        private readonly UserManager<ApplicationUser> _userManager;
+        private readonly U2FService _u2FService;
+
+        public PasswordGrantTypeEventHandler(SignInManager<ApplicationUser> signInManager,
+            UserManager<ApplicationUser> userManager,
+            IOptions<IdentityOptions> identityOptions, U2FService u2FService) : base(signInManager, identityOptions)
+        {
+            _userManager = userManager;
+            _u2FService = u2FService;
+        }
+
+        public override async Task<OpenIddictServerEventState> HandleAsync(
+            OpenIddictServerEvents.HandleTokenRequest notification)
+        {
+            var request = notification.Context.Request;
+            if (!request.IsPasswordGrantType())
+            {
+                // Allow other handlers to process the event.
+                return OpenIddictServerEventState.Unhandled;
+            }
+
+            // Validate the user credentials.
+            // Note: to mitigate brute force attacks, you SHOULD strongly consider
+            // applying a key derivation function like PBKDF2 to slow down
+            // the password validation process. You SHOULD also consider
+            // using a time-constant comparer to prevent timing attacks.
+            var user = await _userManager.FindByNameAsync(request.Username);
+            if (user == null || await _u2FService.HasDevices(user.Id) ||
+                !(await _signInManager.CheckPasswordSignInAsync(user, request.Password, lockoutOnFailure: true))
+                    .Succeeded)
+            {
+                notification.Context.Reject(
+                    error: OpenIddictConstants.Errors.InvalidGrant,
+                    description: "The specified credentials are invalid.");
+                // Don't allow other handlers to process the event.
+                return OpenIddictServerEventState.Handled;
+            }
+
+            notification.Context.Validate(await CreateTicketAsync(request, user));
+            // Don't allow other handlers to process the event.
+            return OpenIddictServerEventState.Handled;
+        }
+    }
+}

BTCPayServer/Authentication/OpenId/RefreshTokenGrantTypeEventHandler.cs

@@ -0,0 +1,21 @@
+using AspNet.Security.OpenIdConnect.Primitives;
+using BTCPayServer.Models;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.Extensions.Options;
+
+namespace BTCPayServer.Authentication.OpenId
+{
+    public class RefreshTokenGrantTypeEventHandler : OpenIdGrantHandlerCheckCanSignIn
+    {
+        public RefreshTokenGrantTypeEventHandler(SignInManager<ApplicationUser> signInManager,
+            IOptions<IdentityOptions> identityOptions, UserManager<ApplicationUser> userManager) : base(signInManager,
+            identityOptions, userManager)
+        {
+        }
+
+        protected override bool IsValid(OpenIdConnectRequest request)
+        {
+            return request.IsRefreshTokenGrantType();
+        }
+    }
+}

BTCPayServer/BTCPayServer.csproj

@@ -1,12 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
+  <Import Project="../Build/Version.csproj" Condition="Exists('../Build/Version.csproj')" />
+  <Import Project="../Build/Common.csproj" />
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp2.1</TargetFramework>
-		<Version>1.0.3.95</Version>
-    <NoWarn>NU1701,CA1816,CA1308,CA1810,CA2208</NoWarn>
-  </PropertyGroup>
-  <PropertyGroup>
-    <LangVersion>7.3</LangVersion>
   </PropertyGroup>
   <ItemGroup>
     <Compile Remove="Build\dockerfiles\**" />
@@ -34,11 +30,10 @@
     <EmbeddedResource Include="Currencies.txt" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="BTCPayServer.Lightning.All" Version="1.1.0.18" />
+    <PackageReference Include="BTCPayServer.Lightning.All" Version="1.1.0.23" />
     <PackageReference Include="BuildBundlerMinifier" Version="2.9.406" />
     <PackageReference Include="BundlerMinifier.Core" Version="2.9.406" />
     <PackageReference Include="BundlerMinifier.TagHelpers" Version="2.9.406" />
-    <PackageReference Include="DigitalRuby.ExchangeSharp" Version="0.5.3" />
     <PackageReference Include="HtmlSanitizer" Version="4.0.207" />
     <PackageReference Include="LedgerWallet" Version="2.0.0.3" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
@@ -47,15 +42,16 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="NBitcoin" Version="4.1.2.14" />
     <PackageReference Include="NBitpayClient" Version="1.0.0.34" />	  
     <PackageReference Include="DBriize" Version="1.0.0.4" />
-    <PackageReference Include="NBXplorer.Client" Version="2.0.0.11" />
+    <PackageReference Include="Newtonsoft.Json" Version="12.0.2" />
     <PackageReference Include="NicolasDorier.CommandLine" Version="1.0.0.2" />
     <PackageReference Include="NicolasDorier.CommandLine.Configuration" Version="1.0.0.3" />
-    <PackageReference Include="NicolasDorier.RateLimits" Version="1.0.0.3" />
+    <PackageReference Include="NicolasDorier.RateLimits" Version="1.0.0.7" />
     <PackageReference Include="NicolasDorier.StandardConfiguration" Version="1.0.0.18" />
     <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="2.1.2" />
+    <PackageReference Include="OpenIddict" Version="2.0.0" />
+    <PackageReference Include="OpenIddict.EntityFrameworkCore" Version="2.0.0" />
     <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="2.1.2" />
     <PackageReference Include="Serilog" Version="2.7.1" />
     <PackageReference Include="Serilog.AspNetCore" Version="2.1.1" />
@@ -69,12 +65,12 @@
 
 	<ItemGroup>
     <PackageReference Include="Microsoft.AspNetCore.App" Version="2.1.9" />
-    <PackageReference Include="TwentyTwenty.Storage" Version="2.10.1" />
-    <PackageReference Include="TwentyTwenty.Storage.Amazon" Version="2.10.1" />
-    <PackageReference Include="TwentyTwenty.Storage.Azure" Version="2.10.1" />
-    <PackageReference Include="TwentyTwenty.Storage.Google" Version="2.10.1" />
-    <PackageReference Include="TwentyTwenty.Storage.Local" Version="2.10.1" />
-    <PackageReference Include="U2F.Core" Version="2.0.1" />
+    <PackageReference Include="TwentyTwenty.Storage" Version="2.11.2" />
+    <PackageReference Include="TwentyTwenty.Storage.Amazon" Version="2.11.2" />
+    <PackageReference Include="TwentyTwenty.Storage.Azure" Version="2.11.2" />
+    <PackageReference Include="TwentyTwenty.Storage.Google" Version="2.11.2" />
+    <PackageReference Include="TwentyTwenty.Storage.Local" Version="2.11.2" />
+    <PackageReference Include="U2F.Core" Version="1.0.4" />
 		<PackageReference Include="YamlDotNet" Version="5.2.1" />
 	</ItemGroup>
 
@@ -137,6 +133,11 @@
 	  <Folder Include="wwwroot\vendor\u2f" />
 	</ItemGroup>
 
+	<ItemGroup>
+	  <ProjectReference Include="..\BTCPayServer.Rating\BTCPayServer.Rating.csproj" />
+	  <ProjectReference Include="..\BTCPayServer.Common\BTCPayServer.Common.csproj" />
+	</ItemGroup>
+
 	<ItemGroup>
     <Content Update="Views\Apps\_ViewImports.cshtml">
       <CopyToPublishDirectory>PreserveNewest</CopyToPublishDirectory>
@@ -145,6 +146,9 @@
     <Content Update="Views\Home\BitpayTranslator.cshtml">
       <Pack>$(IncludeRazorContentInPack)</Pack>
     </Content>
+    <Content Update="Views\Server\DynamicDnsServices.cshtml">
+      <Pack>$(IncludeRazorContentInPack)</Pack>
+    </Content>
     <Content Update="Views\Server\LightningChargeServices.cshtml">
       <Pack>$(IncludeRazorContentInPack)</Pack>
     </Content>
@@ -154,6 +158,9 @@
     <Content Update="Views\Server\P2PService.cshtml">
       <Pack>$(IncludeRazorContentInPack)</Pack>
     </Content>
+    <Content Update="Views\Server\DynamicDnsService.cshtml">
+      <Pack>$(IncludeRazorContentInPack)</Pack>
+    </Content>
     <Content Update="Views\Server\SSHService.cshtml">
       <Pack>$(IncludeRazorContentInPack)</Pack>
     </Content>
@@ -181,6 +188,15 @@
 	  <Content Update="Views\Wallets\ListWallets.cshtml">
 	    <Pack>$(IncludeRazorContentInPack)</Pack>
 	  </Content>
+	  <Content Update="Views\Wallets\WalletPSBTCombine.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
+	  <Content Update="Views\Wallets\WalletPSBTReady.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
+	  <Content Update="Views\Wallets\WalletPSBT.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
 	  <Content Update="Views\Wallets\WalletRescan.cshtml">
 	    <Pack>$(IncludeRazorContentInPack)</Pack>
 	  </Content>

BTCPayServer/Configuration/BTCPayServerOptions.cs

@@ -6,13 +6,7 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Net;
-using System.Text;
-using StandardConfiguration;
 using Microsoft.Extensions.Configuration;
-using NBXplorer;
-using BTCPayServer.Payments.Lightning;
-using Renci.SshNet;
-using NBitcoin.DataEncoders;
 using BTCPayServer.SSH;
 using BTCPayServer.Lightning;
 using Serilog.Events;
@@ -49,7 +43,7 @@ namespace BTCPayServer.Configuration
             private set;
         }
         public EndPoint SocksEndpoint { get; set; }
-
+        
         public List<NBXplorerConnectionSetting> NBXplorerConnectionSettings
         {
             get;
@@ -75,22 +69,24 @@ namespace BTCPayServer.Configuration
         public void LoadArgs(IConfiguration conf)
         {
             NetworkType = DefaultConfiguration.GetNetworkType(conf);
-            var defaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType);
-            DataDir = conf.GetOrDefault<string>("datadir", defaultSettings.DefaultDataDirectory);
+            DataDir = conf.GetDataDir(NetworkType);
             Logs.Configuration.LogInformation("Network: " + NetworkType.ToString());
 
+            if (conf.GetOrDefault<bool>("launchsettings", false) && NetworkType != NetworkType.Regtest)
+                throw new ConfigException($"You need to run BTCPayServer with the run.sh or run.ps1 script");
+
             var supportedChains = conf.GetOrDefault<string>("chains", "btc")
                                       .Split(',', StringSplitOptions.RemoveEmptyEntries)
                                       .Select(t => t.ToUpperInvariant());
             NetworkProvider = new BTCPayNetworkProvider(NetworkType).Filter(supportedChains.ToArray());
             foreach (var chain in supportedChains)
             {
-                if (NetworkProvider.GetNetwork(chain) == null)
+                if (NetworkProvider.GetNetwork<BTCPayNetworkBase>(chain) == null)
                     throw new ConfigException($"Invalid chains \"{chain}\"");
             }
 
             var validChains = new List<string>();
-            foreach (var net in NetworkProvider.GetAll())
+            foreach (var net in NetworkProvider.GetAll().OfType<BTCPayNetwork>())
             {
                 NBXplorerConnectionSetting setting = new NBXplorerConnectionSetting();
                 setting.CryptoCode = net.CryptoCode;
@@ -109,6 +105,8 @@ namespace BTCPayServer.Configuration
                                 $"If you have a lightning charge server: 'type=charge;server=https://charge.example.com;api-token=yourapitoken'" + Environment.NewLine +
                                 $"If you have a lnd server: 'type=lnd-rest;server=https://lnd:lnd@lnd.example.com;macaroon=abf239...;certthumbprint=2abdf302...'" + Environment.NewLine +
                                 $"              lnd server: 'type=lnd-rest;server=https://lnd:lnd@lnd.example.com;macaroonfilepath=/root/.lnd/admin.macaroon;certthumbprint=2abdf302...'" + Environment.NewLine +
+                                $"If you have an eclair server: 'type=eclair;server=http://eclair.com:4570;password=eclairpassword;bitcoin-host=bitcoind:37393;bitcoin-auth=bitcoinrpcuser:bitcoinrpcpassword" + Environment.NewLine +
+                                $"               eclair server: 'type=eclair;server=http://eclair.com:4570;password=eclairpassword;bitcoin-host=bitcoind:37393" + Environment.NewLine +
                                 $"Error: {error}" + Environment.NewLine +
                                 "This service will not be exposed through BTCPay Server");
                         }
@@ -145,6 +143,7 @@ namespace BTCPayServer.Configuration
             PostgresConnectionString = conf.GetOrDefault<string>("postgres", null);
             MySQLConnectionString = conf.GetOrDefault<string>("mysql", null);
             BundleJsCss = conf.GetOrDefault<bool>("bundlejscss", true);
+            AllowAdminRegistration = conf.GetOrDefault<bool>("allow-admin-registration", false);
             TorrcFile = conf.GetOrDefault<string>("torrcfile", null);
 
             var socksEndpointString = conf.GetOrDefault<string>("socksendpoint", null);
@@ -273,6 +272,7 @@ namespace BTCPayServer.Configuration
             get;
             set;
         }
+        public bool AllowAdminRegistration { get; set; }
         public List<SSHFingerprint> TrustedFingerprints { get; set; } = new List<SSHFingerprint>();
         public SSHSettings SSHSettings
         {

BTCPayServer/Configuration/ConfigurationExtensions.cs

@@ -58,5 +58,17 @@ namespace BTCPayServer.Configuration
                 throw new NotSupportedException("Configuration value does not support time " + typeof(T).Name);
             }
         }
+        
+        public static string GetDataDir(this IConfiguration configuration)
+        {
+            var networkType = DefaultConfiguration.GetNetworkType(configuration);
+            return GetDataDir(configuration, networkType);
+        }
+
+        public static string GetDataDir(this IConfiguration configuration, NetworkType networkType)
+        {
+            var defaultSettings = BTCPayDefaultSettings.GetDefaultSettings(networkType);
+            return configuration.GetOrDefault("datadir", defaultSettings.DefaultDataDirectory);
+        }
     }
 }

BTCPayServer/Configuration/DefaultConfiguration.cs

@@ -29,6 +29,7 @@ namespace BTCPayServer.Configuration
             app.Option("-n | --network", $"Set the network among (mainnet,testnet,regtest) (default: mainnet)", CommandOptionType.SingleValue);
             app.Option("--testnet | -testnet", $"Use testnet (deprecated, use --network instead)", CommandOptionType.BoolValue);
             app.Option("--regtest | -regtest", $"Use regtest (deprecated, use --network instead)", CommandOptionType.BoolValue);
+            app.Option("--allow-admin-registration", $"For debug only, will show a checkbox when a new user register to add himself as admin. (default: false)", CommandOptionType.BoolValue);
             app.Option("--chains | -c", $"Chains to support as a comma separated (default: btc; available: {chains})", CommandOptionType.SingleValue);
             app.Option("--postgres", $"Connection string to a PostgreSQL database (default: SQLite)", CommandOptionType.SingleValue);
             app.Option("--mysql", $"Connection string to a MySQL database (default: SQLite)", CommandOptionType.SingleValue);
@@ -45,13 +46,15 @@ namespace BTCPayServer.Configuration
             app.Option("--debuglog", "A rolling log file for debug messages.", CommandOptionType.SingleValue);
             app.Option("--debugloglevel", "The severity you log (default:information)", CommandOptionType.SingleValue);
             app.Option("--disable-registration", "Disables new user registrations (default:true)", CommandOptionType.SingleValue);
-            foreach (var network in provider.GetAll())
+            foreach (var network in provider.GetAll().OfType<BTCPayNetwork>())
             {
                 var crypto = network.CryptoCode.ToLowerInvariant();
                 app.Option($"--{crypto}explorerurl", $"URL of the NBXplorer for {network.CryptoCode} (default: {network.NBXplorerNetwork.DefaultSettings.DefaultUrl})", CommandOptionType.SingleValue);
                 app.Option($"--{crypto}explorercookiefile", $"Path to the cookie file (default: {network.NBXplorerNetwork.DefaultSettings.DefaultCookieFile})", CommandOptionType.SingleValue);
                 app.Option($"--{crypto}lightning", $"Easy configuration of lightning for the server administrator: Must be a UNIX socket of c-lightning (lightning-rpc) or URL to a charge server (default: empty)", CommandOptionType.SingleValue);
-                app.Option($"--{crypto}externallndgrpc", $"The LND gRPC configuration BTCPay will expose to easily connect to the internal lnd wallet from Zap wallet (default: empty)", CommandOptionType.SingleValue);
+                app.Option($"--{crypto}externallndgrpc", $"The LND gRPC configuration BTCPay will expose to easily connect to the internal lnd wallet from an external wallet (default: empty)", CommandOptionType.SingleValue);
+                app.Option($"--{crypto}externallndrest", $"The LND REST configuration BTCPay will expose to easily connect to the internal lnd wallet from an external wallet (default: empty)", CommandOptionType.SingleValue);
+                app.Option($"--{crypto}externalrtl", $"The Ride the Lightning configuration so BTCPay will expose to easily open it in server settings (default: empty)", CommandOptionType.SingleValue);
                 app.Option($"--{crypto}externalspark", $"Show spark information in Server settings / Server. The connection string to spark server (default: empty)", CommandOptionType.SingleValue);
                 app.Option($"--{crypto}externalcharge", $"Show lightning charge information in Server settings/Server. The connection string to charge server (default: empty)", CommandOptionType.SingleValue);
             }
@@ -120,7 +123,7 @@ namespace BTCPayServer.Configuration
             builder.AppendLine("#mysql=User ID=root;Password=myPassword;Host=localhost;Port=3306;Database=myDataBase;");
             builder.AppendLine();
             builder.AppendLine("### NBXplorer settings ###");
-            foreach (var n in new BTCPayNetworkProvider(networkType).GetAll())
+            foreach (var n in new BTCPayNetworkProvider(networkType).GetAll().OfType<BTCPayNetwork>())
             {
                 builder.AppendLine($"#{n.CryptoCode}.explorer.url={n.NBXplorerNetwork.DefaultSettings.DefaultUrl}");
                 builder.AppendLine($"#{n.CryptoCode}.explorer.cookiefile={ n.NBXplorerNetwork.DefaultSettings.DefaultCookieFile}");

BTCPayServer/Configuration/ExternalConnectionString.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using BTCPayServer.Controllers;
+using NBitcoin;
 
 namespace BTCPayServer.Configuration
 {
@@ -30,13 +31,16 @@ namespace BTCPayServer.Configuration
         /// Return a connectionString which does not depends on external resources or information like relative path or file path
         /// </summary>
         /// <returns></returns>
-        public async Task<ExternalConnectionString> Expand(Uri absoluteUrlBase, ExternalServiceTypes serviceType)
+        public async Task<ExternalConnectionString> Expand(Uri absoluteUrlBase, ExternalServiceTypes serviceType, NetworkType network)
         {
             var connectionString = this.Clone();
             // Transform relative URI into absolute URI
             var serviceUri = connectionString.Server.IsAbsoluteUri ? connectionString.Server : ToRelative(absoluteUrlBase, connectionString.Server.ToString());
-            if (!serviceUri.Scheme.Equals("https", StringComparison.OrdinalIgnoreCase) &&
-               !serviceUri.DnsSafeHost.EndsWith(".onion", StringComparison.OrdinalIgnoreCase))
+            var isSecure = network != NetworkType.Mainnet ||
+                       serviceUri.Scheme == "https" ||
+                       serviceUri.DnsSafeHost.EndsWith(".onion", StringComparison.OrdinalIgnoreCase) ||
+                       Extensions.IsLocalNetwork(serviceUri.DnsSafeHost);
+            if (!isSecure)
             {
                 throw new System.Security.SecurityException($"Insecure transport protocol to access this service, please use HTTPS or TOR");
             }

BTCPayServer/Controllers/AccountController.cs

@@ -73,6 +73,8 @@ namespace BTCPayServer.Controllers
         [AllowAnonymous]
         public async Task<IActionResult> Login(string returnUrl = null)
         {
+            if (User.Identity.IsAuthenticated && string.IsNullOrEmpty(returnUrl))
+                return RedirectToLocal();
             // Clear the existing external cookie to ensure a clean login process
             await HttpContext.SignOutAsync(IdentityConstants.ExternalScheme);
 
@@ -100,6 +102,11 @@ namespace BTCPayServer.Controllers
                         return View(model);
                     }
                 }
+                else
+                {
+                    ModelState.AddModelError(string.Empty, "Invalid login attempt.");
+                    return View(model);
+                }
 
                 if (!await _userManager.IsLockedOutAsync(user) && await _u2FService.HasDevices(user.Id))
                 {
@@ -363,6 +370,7 @@ namespace BTCPayServer.Controllers
                 return RedirectToAction(nameof(HomeController.Index), "Home");
             ViewData["ReturnUrl"] = returnUrl;
             ViewData["Logon"] = logon.ToString(CultureInfo.InvariantCulture).ToLowerInvariant();
+            ViewData["AllowIsAdmin"] = _Options.AllowAdminRegistration;
             return View();
         }
 
@@ -373,6 +381,7 @@ namespace BTCPayServer.Controllers
         {
             ViewData["ReturnUrl"] = returnUrl;
             ViewData["Logon"] = logon.ToString(CultureInfo.InvariantCulture).ToLowerInvariant();
+            ViewData["AllowIsAdmin"] = _Options.AllowAdminRegistration;
             var policies = await _SettingsRepository.GetSettingAsync<PoliciesSettings>() ?? new PoliciesSettings();
             if (policies.LockSubscription && !User.IsInRole(Roles.ServerAdmin))
                 return RedirectToAction(nameof(HomeController.Index), "Home");
@@ -384,7 +393,7 @@ namespace BTCPayServer.Controllers
                 {
                     var admin = await _userManager.GetUsersInRoleAsync(Roles.ServerAdmin);
                     Logs.PayServer.LogInformation($"A new user just registered {user.Email} {(admin.Count == 0 ? "(admin)" : "")}");
-                    if (admin.Count == 0)
+                    if (admin.Count == 0 || (model.IsAdmin && _Options.AllowAdminRegistration))
                     {
                         await _RoleManager.CreateAsync(new IdentityRole(Roles.ServerAdmin));
                         await _userManager.AddToRoleAsync(user, Roles.ServerAdmin);
@@ -638,9 +647,9 @@ namespace BTCPayServer.Controllers
             }
         }
 
-        private IActionResult RedirectToLocal(string returnUrl)
+        private IActionResult RedirectToLocal(string returnUrl = null)
         {
-            if (Url.IsLocalUrl(returnUrl))
+            if (!string.IsNullOrEmpty(returnUrl) && Url.IsLocalUrl(returnUrl))
             {
                 return Redirect(returnUrl);
             }

BTCPayServer/Controllers/AppsController.Crowdfund.cs

@@ -36,6 +36,7 @@ namespace BTCPayServer.Controllers
             {
                 NotificationEmailWarning = !await IsEmailConfigured(app.StoreDataId),
                 Title = settings.Title,
+                StoreId = app.StoreDataId,
                 Enabled = settings.Enabled,
                 EnforceTargetAmount = settings.EnforceTargetAmount,
                 StartDate = settings.StartDate,
@@ -129,10 +130,10 @@ namespace BTCPayServer.Controllers
                 Title = vm.Title,
                 Enabled = vm.Enabled,
                 EnforceTargetAmount = vm.EnforceTargetAmount,
-                StartDate = vm.StartDate,
+                StartDate = vm.StartDate?.ToUniversalTime(),
                 TargetCurrency = vm.TargetCurrency,
                 Description = _htmlSanitizer.Sanitize( vm.Description),
-                EndDate = vm.EndDate,
+                EndDate = vm.EndDate?.ToUniversalTime(),
                 TargetAmount = vm.TargetAmount,
                 CustomCSSLink = vm.CustomCSSLink,
                 MainImageUrl = vm.MainImageUrl,

BTCPayServer/Controllers/AppsController.PointOfSale.cs

@@ -96,6 +96,7 @@ namespace BTCPayServer.Controllers
             {
                 NotificationEmailWarning = !await IsEmailConfigured(app.StoreDataId),
                 Id = appId,
+                StoreId = app.StoreDataId,
                 Title = settings.Title,
                 EnableShoppingCart = settings.EnableShoppingCart,
                 ShowCustomAmount = settings.ShowCustomAmount,

BTCPayServer/Controllers/AppsPublicController.cs

@@ -91,6 +91,77 @@ namespace BTCPayServer.Controllers
             });
         }
 
+        [HttpPost]
+        [Route("/apps/{appId}/pos")]
+        [XFrameOptionsAttribute(XFrameOptionsAttribute.XFrameOptions.AllowAll)]
+        [IgnoreAntiforgeryToken]
+        [EnableCors(CorsPolicies.All)]
+        public async Task<IActionResult> ViewPointOfSale(string appId,
+                                                        [ModelBinder(typeof(InvariantDecimalModelBinder))] decimal amount,
+                                                        string email,
+                                                        string orderId,
+                                                        string notificationUrl,
+                                                        string redirectUrl,
+                                                        string choiceKey,
+                                                        string posData = null, CancellationToken cancellationToken = default)
+        {
+            var app = await _AppService.GetApp(appId, AppType.PointOfSale);
+            if (string.IsNullOrEmpty(choiceKey) && amount <= 0)
+            {
+                return RedirectToAction(nameof(ViewPointOfSale), new { appId = appId });
+            }
+            if (app == null)
+                return NotFound();
+            var settings = app.GetSettings<PointOfSaleSettings>();
+            if (string.IsNullOrEmpty(choiceKey) && !settings.ShowCustomAmount && !settings.EnableShoppingCart)
+            {
+                return RedirectToAction(nameof(ViewPointOfSale), new { appId = appId });
+            }
+            string title = null;
+            var price = 0.0m;
+            ViewPointOfSaleViewModel.Item choice = null;
+            if (!string.IsNullOrEmpty(choiceKey))
+            {
+                var choices = _AppService.Parse(settings.Template, settings.Currency);
+                choice = choices.FirstOrDefault(c => c.Id == choiceKey);
+                if (choice == null)
+                    return NotFound();
+                title = choice.Title;
+                price = choice.Price.Value;
+                if (amount > price)
+                    price = amount;
+            }
+            else
+            {
+                if (!settings.ShowCustomAmount && !settings.EnableShoppingCart)
+                    return NotFound();
+                price = amount;
+                title = settings.Title;
+            }
+            var store = await _AppService.GetStore(app);
+            store.AdditionalClaims.Add(new Claim(Policies.CanCreateInvoice.Key, store.Id));
+            var invoice = await _InvoiceController.CreateInvoiceCore(new CreateInvoiceRequest()
+            {
+                ItemCode = choice?.Id,
+                ItemDesc = title,
+                Currency = settings.Currency,
+                Price = price,
+                BuyerEmail = email,
+                OrderId = orderId,
+                NotificationURL =
+                        string.IsNullOrEmpty(notificationUrl) ? settings.NotificationUrl : notificationUrl,
+                NotificationEmail = settings.NotificationEmail,
+                RedirectURL = redirectUrl ?? Request.GetDisplayUrl(),
+                FullNotifications = true,
+                ExtendedNotifications = true,
+                PosData = string.IsNullOrEmpty(posData) ? null : posData,
+                RedirectAutomatically = settings.RedirectAutomatically,
+            }, store, HttpContext.Request.GetAbsoluteRoot(),
+                new List<string>() { AppService.GetAppInternalTag(appId) },
+                cancellationToken);
+            return RedirectToAction(nameof(InvoiceController.Checkout), "Invoice", new { invoiceId = invoice.Data.Id });
+        }
+
 
         [HttpGet]
         [Route("/apps/{appId}/crowdfund")]
@@ -215,77 +286,6 @@ namespace BTCPayServer.Controllers
 
         }
 
-        [HttpPost]
-        [Route("/apps/{appId}/pos")]
-        [XFrameOptionsAttribute(XFrameOptionsAttribute.XFrameOptions.AllowAll)]
-        [IgnoreAntiforgeryToken]
-        [EnableCors(CorsPolicies.All)]
-        public async Task<IActionResult> ViewPointOfSale(string appId,
-                                                        [ModelBinder(typeof(InvariantDecimalModelBinder))] decimal amount,
-                                                        string email,
-                                                        string orderId,
-                                                        string notificationUrl,
-                                                        string redirectUrl,
-                                                        string choiceKey,
-                                                        string posData = null, CancellationToken cancellationToken = default)
-        {
-            var app = await _AppService.GetApp(appId, AppType.PointOfSale);
-            if (string.IsNullOrEmpty(choiceKey) && amount <= 0)
-            {
-                return RedirectToAction(nameof(ViewPointOfSale), new { appId = appId });
-            }
-            if (app == null)
-                return NotFound();
-            var settings = app.GetSettings<PointOfSaleSettings>();
-            if (string.IsNullOrEmpty(choiceKey) && !settings.ShowCustomAmount && !settings.EnableShoppingCart)
-            {
-                return RedirectToAction(nameof(ViewPointOfSale), new { appId = appId });
-            }
-            string title = null;
-            var price = 0.0m;
-            ViewPointOfSaleViewModel.Item choice = null;
-            if (!string.IsNullOrEmpty(choiceKey))
-            {
-                var choices = _AppService.Parse(settings.Template, settings.Currency);
-                choice = choices.FirstOrDefault(c => c.Id == choiceKey);
-                if (choice == null)
-                    return NotFound();
-                title = choice.Title;
-                price = choice.Price.Value;
-                if (amount > price)
-                    price = amount;
-            }
-            else
-            {
-                if (!settings.ShowCustomAmount && !settings.EnableShoppingCart)
-                    return NotFound();
-                price = amount;
-                title = settings.Title;
-            }
-            var store = await _AppService.GetStore(app);
-            store.AdditionalClaims.Add(new Claim(Policies.CanCreateInvoice.Key, store.Id));
-            var invoice = await _InvoiceController.CreateInvoiceCore(new CreateInvoiceRequest()
-            {
-                ItemCode = choice?.Id,
-                ItemDesc = title,
-                Currency = settings.Currency,
-                Price = price,
-                BuyerEmail = email,
-                OrderId = orderId,
-                NotificationURL =
-                        string.IsNullOrEmpty(notificationUrl) ? settings.NotificationUrl : notificationUrl,
-                NotificationEmail = settings.NotificationEmail,
-                RedirectURL = redirectUrl ?? Request.GetDisplayUrl(),
-                FullNotifications = true,
-                ExtendedNotifications = true,
-                PosData = string.IsNullOrEmpty(posData) ? null : posData,
-                RedirectAutomatically = settings.RedirectAutomatically,
-            }, store, HttpContext.Request.GetAbsoluteRoot(),
-                new List<string>() { AppService.GetAppInternalTag(appId) },
-                cancellationToken);
-            return RedirectToAction(nameof(InvoiceController.Checkout), "Invoice", new { invoiceId = invoice.Data.Id });
-        }
-
 
         private string GetUserId()
         {

BTCPayServer/Controllers/HomeController.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Diagnostics;
+using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Mvc;
 using BTCPayServer.Models;
@@ -10,6 +11,7 @@ using NBitcoin;
 using Newtonsoft.Json;
 using BTCPayServer.Services;
 using BTCPayServer.HostedServices;
+using BTCPayServer.Services.Apps;
 
 namespace BTCPayServer.Controllers
 {
@@ -24,24 +26,59 @@ namespace BTCPayServer.Controllers
             HttpClientFactory = httpClientFactory;
             _cachedServerSettings = cachedServerSettings;
         }
-        
-        public async Task<IActionResult> Index()
+
+        private async Task<ViewResult> GoToApp(string appId, AppType? appType)
         {
-            if (_cachedServerSettings.RootAppType is Services.Apps.AppType.Crowdfund)
+            if (appType.HasValue && !string.IsNullOrEmpty(appId))
             {
-                var serviceProvider = HttpContext.RequestServices;
-                var controller = (AppsPublicController)serviceProvider.GetService(typeof(AppsPublicController));
-                controller.Url = Url;
-                controller.ControllerContext = ControllerContext;
-                var res = await controller.ViewCrowdfund(_cachedServerSettings.RootAppId, null) as ViewResult;
-                if (res != null)
+                switch (appType.Value)
                 {
-                    res.ViewName = "/Views/AppsPublic/ViewCrowdfund.cshtml";
-                    return res; // return 
+                    case AppType.Crowdfund:
+                    {
+                        var serviceProvider = HttpContext.RequestServices;
+                        var controller = (AppsPublicController)serviceProvider.GetService(typeof(AppsPublicController));
+                        controller.Url = Url;
+                        controller.ControllerContext = ControllerContext;
+                        var res = await controller.ViewCrowdfund(appId, null) as ViewResult;
+                        if (res != null)
+                        {
+                            res.ViewName = "/Views/AppsPublic/ViewCrowdfund.cshtml";
+                            return res; // return 
+                        }
+
+                        break;
+                    }
+
+                    case AppType.PointOfSale:
+                    {
+                        var serviceProvider = HttpContext.RequestServices;
+                        var controller = (AppsPublicController)serviceProvider.GetService(typeof(AppsPublicController));
+                        controller.Url = Url;
+                        controller.ControllerContext = ControllerContext;
+                        var res = await controller.ViewPointOfSale(appId) as ViewResult;
+                        if (res != null)
+                        {
+                            res.ViewName = "/Views/AppsPublic/ViewPointOfSale.cshtml";
+                            return res; // return 
+                        }
+
+                        break;
+                    }
                 }
             }
+            return null;
+        }
 
-            return View("Home");
+        public async Task<IActionResult> Index()
+        {
+            var matchedDomainMapping = _cachedServerSettings.DomainToAppMapping.FirstOrDefault(item =>
+                item.Domain.Equals(Request.Host.Host, StringComparison.InvariantCultureIgnoreCase));
+            if (matchedDomainMapping != null)
+            {
+                return await GoToApp(matchedDomainMapping.AppId, matchedDomainMapping.AppType) ?? View("Home"); 
+            }
+
+            return await GoToApp(_cachedServerSettings.RootAppId, _cachedServerSettings.RootAppType) ?? View("Home"); 
         }
 
         [Route("translate")]
@@ -102,20 +139,6 @@ namespace BTCPayServer.Controllers
             return View(vm);
         }
 
-        public IActionResult About()
-        {
-            ViewData["Message"] = "Your application description page.";
-
-            return View();
-        }
-
-        public IActionResult Contact()
-        {
-            ViewData["Message"] = "Your contact page.";
-
-            return View();
-        }
-
         public IActionResult Error()
         {
             return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });

BTCPayServer/Controllers/InvoiceController.API.cs

@@ -7,9 +7,7 @@ using BTCPayServer.Models;
 using BTCPayServer.Security;
 using BTCPayServer.Services.Invoices;
 using Microsoft.AspNetCore.Authorization;
-using Microsoft.AspNetCore.Cors;
 using Microsoft.AspNetCore.Mvc;
-using NBitpayClient;
 
 namespace BTCPayServer.Controllers
 {
@@ -19,15 +17,12 @@ namespace BTCPayServer.Controllers
     {
         private InvoiceController _InvoiceController;
         private InvoiceRepository _InvoiceRepository;
-        private BTCPayNetworkProvider _NetworkProvider;
 
         public InvoiceControllerAPI(InvoiceController invoiceController,
-                                    InvoiceRepository invoceRepository,
-                                    BTCPayNetworkProvider networkProvider)
+                                    InvoiceRepository invoceRepository)
         {
-            this._InvoiceController = invoiceController;
-            this._InvoiceRepository = invoceRepository;
-            this._NetworkProvider = networkProvider;
+            _InvoiceController = invoiceController;
+            _InvoiceRepository = invoceRepository;
         }
 
         [HttpPost]
@@ -51,8 +46,7 @@ namespace BTCPayServer.Controllers
             })).FirstOrDefault();
             if (invoice == null)
                 throw new BitpayHttpException(404, "Object not found");
-            var resp = invoice.EntityToDTO(_NetworkProvider);
-            return new DataWrapper<InvoiceResponse>(resp);
+            return new DataWrapper<InvoiceResponse>(invoice.EntityToDTO());
         }
         [HttpGet]
         [Route("invoices")]
@@ -82,7 +76,7 @@ namespace BTCPayServer.Controllers
             };
 
             var entities = (await _InvoiceRepository.GetInvoices(query))
-                            .Select((o) => o.EntityToDTO(_NetworkProvider)).ToArray();
+                            .Select((o) => o.EntityToDTO()).ToArray();
 
             return DataWrapper.Create(entities);
         }

BTCPayServer/Controllers/InvoiceController.UI.cs

@@ -19,10 +19,8 @@ using BTCPayServer.Security;
 using BTCPayServer.Services.Invoices;
 using BTCPayServer.Services.Invoices.Export;
 using Microsoft.AspNetCore.Authorization;
-using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Rendering;
-using Microsoft.EntityFrameworkCore.Internal;
 using NBitcoin;
 using NBitpayClient;
 using NBXplorer;
@@ -77,126 +75,77 @@ namespace BTCPayServer.Controllers
                 StatusMessage = StatusMessage
             };
 
-            model.Addresses = invoice.HistoricalAddresses.Select(h => new InvoiceDetailsModel.AddressModel
-            {
-                Destination = h.GetAddress(),
-                PaymentMethod = ToString(h.GetPaymentMethodId()),
-                Current = !h.UnAssigned.HasValue
-            }).ToArray();
-
-            var updateConfirmationCountIfNeeded = invoice
-                .GetPayments()
-                .Select<PaymentEntity, Task>(async payment =>
+            model.Addresses = invoice.HistoricalAddresses.Select(h =>
+                new InvoiceDetailsModel.AddressModel
                 {
-                    var paymentNetwork = _NetworkProvider.GetNetwork(payment.GetCryptoCode());
-                    var paymentData = payment.GetCryptoPaymentData();
-                    if (paymentData is Payments.Bitcoin.BitcoinLikePaymentData onChainPaymentData)
-                    {
-                        int confirmationCount = 0;
-                        if ((onChainPaymentData.ConfirmationCount < paymentNetwork.MaxTrackedConfirmation && payment.Accounted)
-                             && (onChainPaymentData.Legacy || invoice.MonitoringExpiration < DateTimeOffset.UtcNow))
-                        // The confirmation count in the paymentData is not up to date
-                        {
-                            confirmationCount = (await ((ExplorerClientProvider)_ServiceProvider.GetService(typeof(ExplorerClientProvider))).GetExplorerClient(payment.GetCryptoCode())?.GetTransactionAsync(onChainPaymentData.Outpoint.Hash))?.Confirmations ?? 0;
-                            onChainPaymentData.ConfirmationCount = confirmationCount;
-                            payment.SetCryptoPaymentData(onChainPaymentData);
-                            await _InvoiceRepository.UpdatePayments(new List<PaymentEntity> { payment });
-                        }
-                    }
-                })
-                .ToArray();
-            await Task.WhenAll(updateConfirmationCountIfNeeded);
+                    Destination = h.GetAddress(),
+                    PaymentMethod = h.GetPaymentMethodId().ToPrettyString(),
+                    Current = !h.UnAssigned.HasValue
+                }).ToArray();
 
-            var details = await InvoicePopulatePayments(invoice);
+            var details = InvoicePopulatePayments(invoice);
             model.CryptoPayments = details.CryptoPayments;
             model.OnChainPayments = details.OnChainPayments;
             model.OffChainPayments = details.OffChainPayments;
 
             return View(model);
         }
-
-        private async Task<InvoiceDetailsModel> InvoicePopulatePayments(InvoiceEntity invoice)
+        private InvoiceDetailsModel InvoicePopulatePayments(InvoiceEntity invoice)
         {
             var model = new InvoiceDetailsModel();
 
-            foreach (var data in invoice.GetPaymentMethods(null))
+            foreach (var data in invoice.GetPaymentMethods())
             {
                 var accounting = data.Calculate();
                 var paymentMethodId = data.GetId();
                 var cryptoPayment = new InvoiceDetailsModel.CryptoPayment();
-                cryptoPayment.PaymentMethod = ToString(paymentMethodId);
+                cryptoPayment.PaymentMethod = paymentMethodId.ToPrettyString();
                 cryptoPayment.Due = _CurrencyNameTable.DisplayFormatCurrency(accounting.Due.ToDecimal(MoneyUnit.BTC), paymentMethodId.CryptoCode);
                 cryptoPayment.Paid = _CurrencyNameTable.DisplayFormatCurrency(accounting.CryptoPaid.ToDecimal(MoneyUnit.BTC), paymentMethodId.CryptoCode);
                 cryptoPayment.Overpaid = _CurrencyNameTable.DisplayFormatCurrency(accounting.OverpaidHelper.ToDecimal(MoneyUnit.BTC), paymentMethodId.CryptoCode);
-
-                var onchainMethod = data.GetPaymentMethodDetails() as Payments.Bitcoin.BitcoinLikeOnChainPaymentMethod;
-                if (onchainMethod != null)
-                {
-                    cryptoPayment.Address = onchainMethod.DepositAddress;
-                }
+                var paymentMethodDetails = data.GetPaymentMethodDetails();
+                cryptoPayment.Address = paymentMethodDetails.GetPaymentDestination();
                 cryptoPayment.Rate = ExchangeRate(data);
                 model.CryptoPayments.Add(cryptoPayment);
             }
 
-            var onChainPayments = invoice
-                .GetPayments()
-                .Select<PaymentEntity, Task<object>>(async payment =>
+            foreach (var payment in invoice.GetPayments())
+            {
+                var paymentData = payment.GetCryptoPaymentData();
+                //TODO: abstract
+                if (paymentData is Payments.Bitcoin.BitcoinLikePaymentData onChainPaymentData)
                 {
-                    var paymentNetwork = _NetworkProvider.GetNetwork(payment.GetCryptoCode());
-                    var paymentData = payment.GetCryptoPaymentData();
-                    if (paymentData is Payments.Bitcoin.BitcoinLikePaymentData onChainPaymentData)
+                    var m = new InvoiceDetailsModel.Payment();
+                    m.Crypto = payment.GetPaymentMethodId().CryptoCode;
+                    m.DepositAddress = onChainPaymentData.GetDestination();
+
+                    int confirmationCount = onChainPaymentData.ConfirmationCount;
+                    if (confirmationCount >= payment.Network.MaxTrackedConfirmation)
                     {
-                        var m = new InvoiceDetailsModel.Payment();
-                        m.Crypto = payment.GetPaymentMethodId().CryptoCode;
-                        m.DepositAddress = onChainPaymentData.GetDestination(paymentNetwork);
-
-                        int confirmationCount = onChainPaymentData.ConfirmationCount;
-                        if (confirmationCount >= paymentNetwork.MaxTrackedConfirmation)
-                        {
-                            m.Confirmations = "At least " + (paymentNetwork.MaxTrackedConfirmation);
-                        }
-                        else
-                        {
-                            m.Confirmations = confirmationCount.ToString(CultureInfo.InvariantCulture);
-                        }
-
-                        m.TransactionId = onChainPaymentData.Outpoint.Hash.ToString();
-                        m.ReceivedTime = payment.ReceivedTime;
-                        m.TransactionLink = string.Format(CultureInfo.InvariantCulture, paymentNetwork.BlockExplorerLink, m.TransactionId);
-                        m.Replaced = !payment.Accounted;
-                        return m;
+                        m.Confirmations = "At least " + (payment.Network.MaxTrackedConfirmation);
                     }
                     else
                     {
-                        var lightningPaymentData = (LightningLikePaymentData)paymentData;
-                        return new InvoiceDetailsModel.OffChainPayment()
-                        {
-                            Crypto = paymentNetwork.CryptoCode,
-                            BOLT11 = lightningPaymentData.BOLT11
-                        };
+                        m.Confirmations = confirmationCount.ToString(CultureInfo.InvariantCulture);
                     }
-                })
-                .ToArray();
-            await Task.WhenAll(onChainPayments);
-            model.OnChainPayments = onChainPayments.Select(p => p.GetAwaiter().GetResult()).OfType<InvoiceDetailsModel.Payment>().ToList();
-            model.OffChainPayments = onChainPayments.Select(p => p.GetAwaiter().GetResult()).OfType<InvoiceDetailsModel.OffChainPayment>().ToList();
 
-            return 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;
+                    m.TransactionId = onChainPaymentData.Outpoint.Hash.ToString();
+                    m.ReceivedTime = payment.ReceivedTime;
+                    m.TransactionLink = string.Format(CultureInfo.InvariantCulture, payment.Network.BlockExplorerLink, m.TransactionId);
+                    m.Replaced = !payment.Accounted;
+                    model.OnChainPayments.Add(m);
+                }
+                else
+                {
+                    var lightningPaymentData = (LightningLikePaymentData)paymentData;
+                    model.OffChainPayments.Add(new InvoiceDetailsModel.OffChainPayment()
+                    {
+                        Crypto = payment.Network.CryptoCode,
+                        BOLT11 = lightningPaymentData.BOLT11
+                    });
+                }
             }
-            return $"{paymentMethodId.CryptoCode} ({type})";
+            return model;
         }
 
         [HttpGet]
@@ -253,7 +202,7 @@ namespace BTCPayServer.Controllers
             return View(model);
         }
 
-
+        //TODO: abstract
         private async Task<PaymentModel> GetInvoiceModel(string invoiceId, PaymentMethodId paymentMethodId)
         {
             var invoice = await _InvoiceRepository.GetInvoice(invoiceId);
@@ -266,10 +215,11 @@ namespace BTCPayServer.Controllers
                 paymentMethodId = store.GetDefaultPaymentId(_NetworkProvider);
                 isDefaultPaymentId = true;
             }
-            var network = _NetworkProvider.GetNetwork(paymentMethodId.CryptoCode);
+            BTCPayNetworkBase network = _NetworkProvider.GetNetwork<BTCPayNetwork>(paymentMethodId.CryptoCode);
             if (network == null && isDefaultPaymentId)
             {
-                network = _NetworkProvider.GetAll().FirstOrDefault();
+                //TODO: need to look into a better way for this as it does not scale
+                network = _NetworkProvider.GetAll().OfType<BTCPayNetwork>().FirstOrDefault();
                 paymentMethodId = new PaymentMethodId(network.CryptoCode, PaymentTypes.BTCLike);
             }
             if (invoice == null || network == null)
@@ -278,18 +228,18 @@ namespace BTCPayServer.Controllers
             {
                 if (!isDefaultPaymentId)
                     return null;
-                var paymentMethodTemp = invoice.GetPaymentMethods(_NetworkProvider)
+                var paymentMethodTemp = invoice.GetPaymentMethods()
                                                .Where(c => paymentMethodId.CryptoCode == c.GetId().CryptoCode)
                                                .FirstOrDefault();
                 if (paymentMethodTemp == null)
-                    paymentMethodTemp = invoice.GetPaymentMethods(_NetworkProvider).First();
+                    paymentMethodTemp = invoice.GetPaymentMethods().First();
                 network = paymentMethodTemp.Network;
                 paymentMethodId = paymentMethodTemp.GetId();
             }
 
-            var paymentMethod = invoice.GetPaymentMethod(paymentMethodId, _NetworkProvider);
+            var paymentMethod = invoice.GetPaymentMethod(paymentMethodId);
             var paymentMethodDetails = paymentMethod.GetPaymentMethodDetails();
-            var dto = invoice.EntityToDTO(_NetworkProvider);
+            var dto = invoice.EntityToDTO();
             var cryptoInfo = dto.CryptoInfo.First(o => o.GetpaymentMethodId() == paymentMethodId);
             var storeBlob = store.GetStoreBlob();
             var currency = invoice.ProductInformation.Currency;
@@ -311,20 +261,19 @@ namespace BTCPayServer.Controllers
                    (1m + (changelly.AmountMarkupPercentage / 100m)))
                 : (decimal?)null;
 
+            
+            var paymentMethodHandler = _paymentMethodHandlerDictionary[paymentMethodId];
             var model = new PaymentModel()
             {
                 CryptoCode = network.CryptoCode,
                 RootPath = this.Request.PathBase.Value.WithTrailingSlash(),
-                PaymentMethodId = paymentMethodId.ToString(),
-                PaymentMethodName = GetDisplayName(paymentMethodId, network),
-                CryptoImage = GetImage(paymentMethodId, network),
-                IsLightning = paymentMethodId.PaymentType == PaymentTypes.LightningLike,
                 OrderId = invoice.OrderId,
                 InvoiceId = invoice.Id,
                 DefaultLang = storeBlob.DefaultLang ?? "en",
                 HtmlTitle = storeBlob.HtmlTitle ?? "BTCPay Invoice",
                 CustomCSSLink = storeBlob.CustomCSS?.AbsoluteUri,
                 CustomLogoLink = storeBlob.CustomLogo?.AbsoluteUri,
+                CryptoImage = Request.GetRelativePathOrAbsolute(paymentMethodHandler.GetCryptoImage(paymentMethodId)),
                 LightningAmountInSatoshi = storeBlob.LightningAmountInSatoshi,
                 BtcAddress = paymentMethodDetails.GetPaymentDestination(),
                 BtcDue = accounting.Due.ToString(),
@@ -340,13 +289,7 @@ namespace BTCPayServer.Controllers
                 MerchantRefLink = invoice.RedirectURL ?? "/",
                 RedirectAutomatically = invoice.RedirectAutomatically,
                 StoreName = store.StoreName,
-                InvoiceBitcoinUrl = paymentMethodId.PaymentType == PaymentTypes.BTCLike ? cryptoInfo.PaymentUrls.BIP21 :
-                                    paymentMethodId.PaymentType == PaymentTypes.LightningLike ? cryptoInfo.PaymentUrls.BOLT11 :
-                                    throw new NotSupportedException(),
                 PeerInfo = (paymentMethodDetails as LightningLikePaymentMethodDetails)?.NodeInfo,
-                InvoiceBitcoinUrlQR = paymentMethodId.PaymentType == PaymentTypes.BTCLike ? cryptoInfo.PaymentUrls.BIP21 :
-                                    paymentMethodId.PaymentType == PaymentTypes.LightningLike ? cryptoInfo.PaymentUrls.BOLT11.ToUpperInvariant() :
-                                    throw new NotSupportedException(),
                 TxCount = accounting.TxRequired,
                 BtcPaid = accounting.Paid.ToString(),
 #pragma warning disable CS0618 // Type or member is obsolete
@@ -362,38 +305,39 @@ namespace BTCPayServer.Controllers
                 CoinSwitchMerchantId = coinswitch?.MerchantId,
                 CoinSwitchMode = coinswitch?.Mode,
                 StoreId = store.Id,
-                AvailableCryptos = invoice.GetPaymentMethods(_NetworkProvider)
+                AvailableCryptos = invoice.GetPaymentMethods()
                                           .Where(i => i.Network != null)
-                                          .Select(kv => new PaymentModel.AvailableCrypto()
+                                          .Select(kv =>
                                           {
-                                              PaymentMethodId = kv.GetId().ToString(),
-                                              CryptoCode = kv.GetId().CryptoCode,
-                                              PaymentMethodName = GetDisplayName(kv.GetId(), kv.Network),
-                                              IsLightning = kv.GetId().PaymentType == PaymentTypes.LightningLike,
-                                              CryptoImage = GetImage(kv.GetId(), kv.Network),
-                                              Link = Url.Action(nameof(Checkout), new { invoiceId = invoiceId, paymentMethodId = kv.GetId().ToString() })
+                                              var availableCryptoPaymentMethodId = kv.GetId();
+                                              var availableCryptoHandler = _paymentMethodHandlerDictionary[availableCryptoPaymentMethodId];
+                                              return new PaymentModel.AvailableCrypto()
+                                              {
+                                                  PaymentMethodId = kv.GetId().ToString(),
+                                                  CryptoCode = kv.GetId().CryptoCode,
+                                                  PaymentMethodName = availableCryptoHandler.GetPaymentMethodName(availableCryptoPaymentMethodId),
+                                                  IsLightning =
+                                                      kv.GetId().PaymentType == PaymentTypes.LightningLike,
+                                                  CryptoImage = Request.GetRelativePathOrAbsolute(availableCryptoHandler.GetCryptoImage(availableCryptoPaymentMethodId)),
+                                                  Link = Url.Action(nameof(Checkout),
+                                                      new
+                                                      {
+                                                          invoiceId = invoiceId,
+                                                          paymentMethodId = kv.GetId().ToString()
+                                                      })
+                                              };
                                           }).Where(c => c.CryptoImage != "/")
                                           .OrderByDescending(a => a.CryptoCode == "BTC").ThenBy(a => a.PaymentMethodName).ThenBy(a => a.IsLightning ? 1 : 0)
                                           .ToList()
             };
 
+            paymentMethodHandler.PreparePaymentModel(model, dto);
+            model.PaymentMethodId = paymentMethodId.ToString();
             var expiration = TimeSpan.FromSeconds(model.ExpirationSeconds);
             model.TimeLeft = expiration.PrettyPrint();
             return model;
         }
 
-        private string GetDisplayName(PaymentMethodId paymentMethodId, BTCPayNetwork network)
-        {
-            return paymentMethodId.PaymentType == PaymentTypes.BTCLike ?
-                network.DisplayName : network.DisplayName + " (Lightning)";
-        }
-
-        private string GetImage(PaymentMethodId paymentMethodId, BTCPayNetwork network)
-        {
-            return paymentMethodId.PaymentType == PaymentTypes.BTCLike ?
-                this.Request.GetRelativePathOrAbsolute(network.CryptoImagePath) : this.Request.GetRelativePathOrAbsolute(network.LightningImagePath);
-        }
-
         private string OrderAmountFromInvoice(string cryptoCode, ProductInformation productInformation)
         {
             // if invoice source currency is the same as currently display currency, no need for "order amount from invoice"
@@ -519,7 +463,7 @@ namespace BTCPayServer.Controllers
                     AmountCurrency = _CurrencyNameTable.DisplayFormatCurrency(invoice.ProductInformation.Price, invoice.ProductInformation.Currency),
                     CanMarkInvalid = state.CanMarkInvalid(),
                     CanMarkComplete = state.CanMarkComplete(),
-                    Details = await InvoicePopulatePayments(invoice)
+                    Details = InvoicePopulatePayments(invoice)
                 });
             }
             model.Total = await counting;
@@ -550,7 +494,7 @@ namespace BTCPayServer.Controllers
         [BitpayAPIConstraint(false)]
         public async Task<IActionResult> Export(string format, string searchTerm = null, int timezoneOffset = 0)
         {
-            var model = new InvoiceExport(_NetworkProvider, _CurrencyNameTable);
+            var model = new InvoiceExport(_CurrencyNameTable);
 
             InvoiceQuery invoiceQuery = GetInvoiceQuery(searchTerm, timezoneOffset);
             invoiceQuery.Skip = 0;
@@ -569,6 +513,14 @@ namespace BTCPayServer.Controllers
         }
 
 
+        private SelectList GetPaymentMethodsSelectList()
+        {
+            return new SelectList(_paymentMethodHandlerDictionary.Distinct().SelectMany(handler =>
+                    handler.GetSupportedPaymentMethods()
+                        .Select(id => new SelectListItem(id.ToPrettyString(), id.ToString()))),
+                nameof(SelectListItem.Value),
+                nameof(SelectListItem.Text));
+        }
 
         [HttpGet]
         [Route("invoices/create")]
@@ -583,15 +535,7 @@ namespace BTCPayServer.Controllers
                 return RedirectToAction(nameof(UserStoresController.ListStores), "UserStores");
             }
 
-            var paymentMethods = new SelectList(_NetworkProvider.GetAll().SelectMany(network => new[]
-                                                         {
-                                                             new PaymentMethodId(network.CryptoCode, PaymentTypes.BTCLike),
-                                                             new PaymentMethodId(network.CryptoCode, PaymentTypes.LightningLike)
-                                                         }).Select(id => new SelectListItem(id.ToString(true), id.ToString(false))),
-                                                             nameof(SelectListItem.Value),
-                                                             nameof(SelectListItem.Text));
-
-            return View(new CreateInvoiceModel() { Stores = stores, AvailablePaymentMethods = paymentMethods });
+            return View(new CreateInvoiceModel() { Stores = stores, AvailablePaymentMethods = GetPaymentMethodsSelectList() });
         }
 
         [HttpPost]
@@ -603,14 +547,7 @@ namespace BTCPayServer.Controllers
             var stores = await _StoreRepository.GetStoresByUserId(GetUserId());
             model.Stores = new SelectList(stores, nameof(StoreData.Id), nameof(StoreData.StoreName), model.StoreId);
 
-            var paymentMethods = new SelectList(_NetworkProvider.GetAll().SelectMany(network => new[]
-                {
-                    new PaymentMethodId(network.CryptoCode, PaymentTypes.BTCLike),
-                    new PaymentMethodId(network.CryptoCode, PaymentTypes.LightningLike)
-                }).Select(id => new SelectListItem(id.ToString(true), id.ToString(false))),
-                nameof(SelectListItem.Value),
-                nameof(SelectListItem.Text));
-            model.AvailablePaymentMethods = paymentMethods;
+            model.AvailablePaymentMethods = GetPaymentMethodsSelectList();
 
             var store = stores.FirstOrDefault(s => s.Id == model.StoreId);
             if (store == null)

BTCPayServer/Controllers/InvoiceController.cs

@@ -36,7 +36,7 @@ namespace BTCPayServer.Controllers
         private CurrencyNameTable _CurrencyNameTable;
         EventAggregator _EventAggregator;
         BTCPayNetworkProvider _NetworkProvider;
-        private readonly BTCPayWalletProvider _WalletProvider;
+        private readonly PaymentMethodHandlerDictionary _paymentMethodHandlerDictionary;
         IServiceProvider _ServiceProvider;
         public InvoiceController(
             IServiceProvider serviceProvider,
@@ -46,9 +46,9 @@ namespace BTCPayServer.Controllers
             RateFetcher rateProvider,
             StoreRepository storeRepository,
             EventAggregator eventAggregator,
-            BTCPayWalletProvider walletProvider,
             ContentSecurityPolicies csp,
-            BTCPayNetworkProvider networkProvider)
+            BTCPayNetworkProvider networkProvider,
+            PaymentMethodHandlerDictionary paymentMethodHandlerDictionary)
         {
             _ServiceProvider = serviceProvider;
             _CurrencyNameTable = currencyNameTable ?? throw new ArgumentNullException(nameof(currencyNameTable));
@@ -58,7 +58,7 @@ namespace BTCPayServer.Controllers
             _UserManager = userManager;
             _EventAggregator = eventAggregator;
             _NetworkProvider = networkProvider;
-            _WalletProvider = walletProvider;
+            _paymentMethodHandlerDictionary = paymentMethodHandlerDictionary;
             _CSP = csp;
         }
 
@@ -67,13 +67,10 @@ namespace BTCPayServer.Controllers
         {
             if (!store.HasClaim(Policies.CanCreateInvoice.Key))
                 throw new UnauthorizedAccessException();
+            invoice.Currency = invoice.Currency?.ToUpperInvariant() ?? "USD";
             InvoiceLogs logs = new InvoiceLogs();
             logs.Write("Creation of invoice starting");
-            var entity = new InvoiceEntity
-            {
-                Version = InvoiceEntity.Lastest_Version,
-                InvoiceTime = DateTimeOffset.UtcNow
-            };
+            var entity = _InvoiceRepository.CreateNewInvoice();
 
             var getAppsTaggingStore = _InvoiceRepository.GetAppsTaggingStore(store.Id);
             var storeBlob = store.GetStoreBlob();
@@ -148,7 +145,7 @@ namespace BTCPayServer.Controllers
 
             foreach (var network in store.GetSupportedPaymentMethods(_NetworkProvider)
                                                 .Where(s => !excludeFilter.Match(s.PaymentId))
-                                                .Select(c => _NetworkProvider.GetNetwork(c.PaymentId.CryptoCode))
+                                                .Select(c => _NetworkProvider.GetNetwork<BTCPayNetworkBase>(c.PaymentId.CryptoCode))
                                                 .Where(c => c != null))
             {
                 currencyPairsToFetch.Add(new CurrencyPair(network.CryptoCode, invoice.Currency));
@@ -162,11 +159,11 @@ namespace BTCPayServer.Controllers
             var fetchingByCurrencyPair = _RateProvider.FetchRates(currencyPairsToFetch, rateRules, cancellationToken);
             var fetchingAll = WhenAllFetched(logs, fetchingByCurrencyPair);
             var supportedPaymentMethods = store.GetSupportedPaymentMethods(_NetworkProvider)
-                                               .Where(s => !excludeFilter.Match(s.PaymentId))
+                                               .Where(s => !excludeFilter.Match(s.PaymentId) && _paymentMethodHandlerDictionary.Support(s.PaymentId))
                                                .Select(c =>
-                                                (Handler: (IPaymentMethodHandler)_ServiceProvider.GetService(typeof(IPaymentMethodHandler<>).MakeGenericType(c.GetType())),
+                                                (Handler: _paymentMethodHandlerDictionary[c.PaymentId],
                                                 SupportedPaymentMethod: c,
-                                                Network: _NetworkProvider.GetNetwork(c.PaymentId.CryptoCode)))
+                                                Network: _NetworkProvider.GetNetwork<BTCPayNetworkBase>(c.PaymentId.CryptoCode)))
                                                 .Where(c => c.Network != null)
                                                 .Select(o =>
                                                     (SupportedPaymentMethod: o.SupportedPaymentMethod,
@@ -205,7 +202,7 @@ namespace BTCPayServer.Controllers
 
             using (logs.Measure("Saving invoice"))
             {
-                entity = await _InvoiceRepository.CreateInvoiceAsync(store.Id, entity, _NetworkProvider);
+                entity = await _InvoiceRepository.CreateInvoiceAsync(store.Id, entity);
             }
             _ = Task.Run(async () =>
             {
@@ -220,7 +217,7 @@ namespace BTCPayServer.Controllers
                 await _InvoiceRepository.AddInvoiceLogs(entity.Id, logs);
             });
             _EventAggregator.Publish(new Events.InvoiceEvent(entity, 1001, InvoiceEvent.Created));
-            var resp = entity.EntityToDTO(_NetworkProvider);
+            var resp = entity.EntityToDTO();
             return new DataWrapper<InvoiceResponse>(resp) { Facade = "pos/invoice" };
         }
 
@@ -243,11 +240,11 @@ namespace BTCPayServer.Controllers
             }).ToArray());
         }
 
-        private async Task<PaymentMethod> CreatePaymentMethodAsync(Dictionary<CurrencyPair, Task<RateResult>> fetchingByCurrencyPair, IPaymentMethodHandler handler, ISupportedPaymentMethod supportedPaymentMethod, BTCPayNetwork network, InvoiceEntity entity, StoreData store, InvoiceLogs logs)
+        private async Task<PaymentMethod> CreatePaymentMethodAsync(Dictionary<CurrencyPair, Task<RateResult>> fetchingByCurrencyPair, IPaymentMethodHandler handler, ISupportedPaymentMethod supportedPaymentMethod, BTCPayNetworkBase network, InvoiceEntity entity, StoreData store, InvoiceLogs logs)
         {
             try
             {
-                var logPrefix = $"{supportedPaymentMethod.PaymentId.ToString(true)}:";
+                var logPrefix = $"{supportedPaymentMethod.PaymentId.ToPrettyString()}:";
                 var storeBlob = store.GetStoreBlob();
                 var preparePayment = handler.PreparePayment(supportedPaymentMethod, store, network);
                 var rate = await fetchingByCurrencyPair[new CurrencyPair(network.CryptoCode, entity.ProductInformation.Currency)];
@@ -260,7 +257,7 @@ namespace BTCPayServer.Controllers
                 paymentMethod.Network = network;
                 paymentMethod.SetId(supportedPaymentMethod.PaymentId);
                 paymentMethod.Rate = rate.BidAsk.Bid;
-                paymentMethod.PreferOnion = this.Request.IsOnion();
+                paymentMethod.PreferOnion = Uri.TryCreate(entity.ServerUrl, UriKind.Absolute, out var u) && u.DnsSafeHost.EndsWith(".onion", StringComparison.OrdinalIgnoreCase);
 
                 using (logs.Measure($"{logPrefix} Payment method details creation"))
                 {
@@ -268,38 +265,15 @@ namespace BTCPayServer.Controllers
                     paymentMethod.SetPaymentMethodDetails(paymentDetails);
                 }
 
-                Func<Money, Money, bool> compare = null;
-                CurrencyValue limitValue = null;
-                string errorMessage = null;
-                if (supportedPaymentMethod.PaymentId.PaymentType == PaymentTypes.LightningLike &&
-                   storeBlob.LightningMaxValue != null)
+                var errorMessage = await
+                    handler
+                        .IsPaymentMethodAllowedBasedOnInvoiceAmount(storeBlob, fetchingByCurrencyPair,
+                            paymentMethod.Calculate().Due, supportedPaymentMethod.PaymentId);
+                if (errorMessage != null)
                 {
-                    compare = (a, b) => a > b;
-                    limitValue = storeBlob.LightningMaxValue;
-                    errorMessage = "The amount of the invoice is too high to be paid with lightning";
+                    logs.Write($"{logPrefix} {errorMessage}");
+                    return null;
                 }
-                else if (supportedPaymentMethod.PaymentId.PaymentType == PaymentTypes.BTCLike &&
-                   storeBlob.OnChainMinValue != null)
-                {
-                    compare = (a, b) => a < b;
-                    limitValue = storeBlob.OnChainMinValue;
-                    errorMessage = "The amount of the invoice is too low to be paid on chain";
-                }
-
-                if (compare != null)
-                {
-                    var limitValueRate = await fetchingByCurrencyPair[new CurrencyPair(network.CryptoCode, limitValue.Currency)];
-                    if (limitValueRate.BidAsk != null)
-                    {
-                        var limitValueCrypto = Money.Coins(limitValue.Value / limitValueRate.BidAsk.Bid);
-                        if (compare(paymentMethod.Calculate().Due, limitValueCrypto))
-                        {
-                            logs.Write($"{logPrefix} {errorMessage}");
-                            return null;
-                        }
-                    }
-                }
-                ///////////////
 
 
 #pragma warning disable CS0618

BTCPayServer/Controllers/ManageController.U2F.cs

@@ -58,30 +58,32 @@ namespace BTCPayServer.Controllers
         [HttpPost]
         public async Task<IActionResult> AddU2FDevice(AddU2FDeviceViewModel viewModel)
         {
+            var errorMessage = string.Empty;
             try
             {
                 if (await _u2FService.CompleteRegistration(_userManager.GetUserId(User), viewModel.DeviceResponse,
                     string.IsNullOrEmpty(viewModel.Name) ? "Unlabelled U2F Device" : viewModel.Name))
                 {
                     return RedirectToAction("U2FAuthentication", new
+                        
                     {
                         StatusMessage = "Device added!"
                     });
                 }
-
-                throw new Exception("Could not add device.");
             }
             catch (Exception e)
             {
-                return RedirectToAction("U2FAuthentication", new
-                {
-                    StatusMessage = new StatusMessageModel()
-                    {
-                        Severity = StatusMessageModel.StatusSeverity.Error,
-                        Message = e.Message
-                    }
-                });
+                errorMessage = e.Message;
             }
+
+            return RedirectToAction("U2FAuthentication", new
+            {
+                StatusMessage = new StatusMessageModel()
+                {
+                    Severity = StatusMessageModel.StatusSeverity.Error,
+                    Message = string.IsNullOrEmpty(errorMessage) ? "Could not add device." : errorMessage
+                }
+            });
         }
     }
 }

BTCPayServer/Controllers/PaymentRequestController.cs

@@ -154,18 +154,22 @@ namespace BTCPayServer.Controllers
             blob.Email = viewModel.Email;
             blob.Description = _htmlSanitizer.Sanitize(viewModel.Description);
             blob.Amount = viewModel.Amount;
-            blob.ExpiryDate = viewModel.ExpiryDate;
+            blob.ExpiryDate = viewModel.ExpiryDate?.ToUniversalTime();
             blob.Currency = viewModel.Currency;
             blob.EmbeddedCSS = viewModel.EmbeddedCSS;
             blob.CustomCSSLink = viewModel.CustomCSSLink;
             blob.AllowCustomPaymentAmounts = viewModel.AllowCustomPaymentAmounts;
 
             data.SetBlob(blob);
+            if (string.IsNullOrEmpty(id))
+            {
+                data.Created = DateTimeOffset.UtcNow;
+            }
             data = await _PaymentRequestRepository.CreateOrUpdatePaymentRequest(data);
             _EventAggregator.Publish(new PaymentRequestUpdated()
             {
                 Data = data,
-                PaymentRequestId = data.Id
+                PaymentRequestId = data.Id,
             });
 
             return RedirectToAction("EditPaymentRequest", new {id = data.Id, StatusMessage = "Saved"});

BTCPayServer/Controllers/PublicController.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Web;
 using BTCPayServer.Filters;
 using BTCPayServer.Models;
 using BTCPayServer.Models.StoreViewModels;
@@ -58,7 +59,17 @@ namespace BTCPayServer.Controllers
                 RedirectURL = model.BrowserRedirect,
                 FullNotifications = true
             }, store, HttpContext.Request.GetAbsoluteRoot(), cancellationToken: cancellationToken);
-            return Redirect(invoice.Data.Url);
+            if (string.IsNullOrEmpty(model.CheckoutQueryString))
+            {
+                return Redirect(invoice.Data.Url);
+            }
+
+            var additionalParamValues = HttpUtility.ParseQueryString(model.CheckoutQueryString);
+            var uriBuilder = new UriBuilder(invoice.Data.Url);
+            var paramValues = HttpUtility.ParseQueryString(uriBuilder.Query);
+            paramValues.Add(additionalParamValues);
+            uriBuilder.Query = paramValues.ToString();
+            return Redirect(uriBuilder.Uri.AbsoluteUri);
         }
     }
 }

BTCPayServer/Controllers/PublicLightningNodeInfoController.cs

@@ -41,7 +41,7 @@ namespace BTCPayServer.Controllers
             try
             {
                 var paymentMethodDetails = GetExistingLightningSupportedPaymentMethod(cryptoCode, store);
-                var network = _BtcPayNetworkProvider.GetNetwork(cryptoCode);
+                var network = _BtcPayNetworkProvider.GetNetwork<BTCPayNetwork>(cryptoCode);
                 var nodeInfo =
                     await _LightningLikePaymentHandler.GetNodeInfo(this.Request.IsOnion(), paymentMethodDetails,
                         network);

BTCPayServer/Controllers/RestApi/TestController.cs

@@ -0,0 +1,61 @@
+using System.Threading.Tasks;
+using BTCPayServer.Data;
+using BTCPayServer.Models;
+using BTCPayServer.Security;
+using BTCPayServer.Services.Stores;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc;
+using OpenIddict.Validation;
+
+namespace BTCPayServer.Controllers.RestApi
+{
+    /// <summary>
+    /// this controller serves as a testing endpoint for our OpenId unit tests
+    /// </summary>
+    [Route("api/[controller]")]
+    [ApiController]
+    [Authorize(AuthenticationSchemes = OpenIddictValidationDefaults.AuthenticationScheme)]
+    public class TestController : ControllerBase
+    {
+        private readonly UserManager<ApplicationUser> _userManager;
+        private readonly StoreRepository _storeRepository;
+
+        public TestController(UserManager<ApplicationUser> userManager, StoreRepository storeRepository)
+        {
+            _userManager = userManager;
+            _storeRepository = storeRepository;
+        }
+
+        [HttpGet("me/id")]
+        public string GetCurrentUserId()
+        {
+            return _userManager.GetUserId(User);
+        }
+
+        [HttpGet("me")]
+        public async Task<ApplicationUser> GetCurrentUser()
+        {
+            return await _userManager.GetUserAsync(User);
+        }
+
+        [HttpGet("me/is-admin")]
+        public bool AmIAnAdmin()
+        { 
+            return  User.IsInRole(Roles.ServerAdmin);
+        }
+        [HttpGet("me/stores")]
+        public async Task<StoreData[]> GetCurrentUserStores()
+        {
+            return await _storeRepository.GetStoresByUserId(_userManager.GetUserId(User));
+        }
+
+
+        [HttpGet("me/stores/{storeId}/can-edit")]
+        [Authorize(Policy = Policies.CanModifyStoreSettings.Key, AuthenticationSchemes = OpenIddictValidationDefaults.AuthenticationScheme)]
+        public bool CanEdit(string storeId)
+        {
+            return true;
+        }
+    }
+}

BTCPayServer/Controllers/ServerController.Storage.cs

@@ -14,6 +14,7 @@ using BTCPayServer.Storage.Services.Providers.GoogleCloudStorage;
 using BTCPayServer.Storage.Services.Providers.GoogleCloudStorage.Configuration;
 using BTCPayServer.Storage.Services.Providers.Models;
 using BTCPayServer.Storage.ViewModels;
+using BTCPayServer.Views;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Newtonsoft.Json.Linq;
@@ -26,7 +27,7 @@ namespace BTCPayServer.Controllers
         public async Task<IActionResult> Files(string fileId = null, string statusMessage = null)
         {
             TempData["StatusMessage"] = statusMessage;
-            var fileUrl = string.IsNullOrEmpty(fileId) ? null : await _FileService.GetFileUrl(fileId);
+            var fileUrl = string.IsNullOrEmpty(fileId) ? null : await _FileService.GetFileUrl(Request.GetAbsoluteRootUri(), fileId);
 
             return View(new ViewFilesViewModel()
             {
@@ -96,7 +97,7 @@ namespace BTCPayServer.Controllers
                 return NotFound();
             }
 
-            var expiry = DateTimeOffset.Now;
+            var expiry = DateTimeOffset.UtcNow;
             switch (viewModel.TimeType)
             {
                 case CreateTemporaryFileUrlViewModel.TmpFileTimeType.Seconds:
@@ -115,14 +116,15 @@ namespace BTCPayServer.Controllers
                     throw new ArgumentOutOfRangeException();
             }
 
-            var url = await _FileService.GetTemporaryFileUrl(fileId, expiry, viewModel.IsDownload);
+            var url = await _FileService.GetTemporaryFileUrl(Request.GetAbsoluteRootUri(), fileId, expiry, viewModel.IsDownload);
 
             return RedirectToAction(nameof(Files), new
             {
                 StatusMessage = new StatusMessageModel()
                 {
+                    Severity = StatusMessageModel.StatusSeverity.Success,
                     Html =
-                        $"Generated Temporary Url for file {file.FileName} which expires at {expiry:G}. <a href='{url}' target='_blank'>{url}</a>"
+                        $"Generated Temporary Url for file {file.FileName} which expires at {expiry.ToBrowserDate()}. <a href='{url}' target='_blank'>{url}</a>"
                 }.ToString(),
                 fileId,
             });
@@ -233,6 +235,12 @@ namespace BTCPayServer.Controllers
                         fileProviderService.GetProviderConfiguration(data));
 
                 case FileSystemFileProviderService fileProviderService:
+                    if (data.Provider != BTCPayServer.Storage.Models.StorageProvider.FileSystem)
+                    {
+                        _ = await SaveStorageProvider(new FileSystemStorageConfiguration(),
+                            BTCPayServer.Storage.Models.StorageProvider.FileSystem);
+                    }
+                    
                     return View(nameof(EditFileSystemStorageProvider),
                         fileProviderService.GetProviderConfiguration(data));
             }

BTCPayServer/Controllers/ServerController.cs

@@ -17,6 +17,7 @@ using NBitcoin.DataEncoders;
 using System;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
+using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Net;
@@ -33,6 +34,7 @@ using BTCPayServer.Storage.Services.Providers;
 using BTCPayServer.Services.Apps;
 using Microsoft.AspNetCore.Mvc.Rendering;
 using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore;
 
 namespace BTCPayServer.Controllers
 {
@@ -152,17 +154,20 @@ namespace BTCPayServer.Controllers
         }
 
         [Route("server/users")]
-        public IActionResult ListUsers()
+        public IActionResult ListUsers(int skip = 0, int count = 50)
         {
             var users = new UsersViewModel();
             users.StatusMessage = StatusMessage;
-            users.Users
-                = _UserManager.Users.Select(u => new UsersViewModel.UserViewModel()
+            users.Users = _UserManager.Users.Skip(skip).Take(count)
+                .Select(u => new UsersViewModel.UserViewModel
                 {
                     Name = u.UserName,
                     Email = u.Email,
                     Id = u.Id
                 }).ToList();
+            users.Skip = skip;
+            users.Count = count;
+            users.Total = _UserManager.Users.Count();
             return View(users);
         }
 
@@ -459,43 +464,61 @@ namespace BTCPayServer.Controllers
         public async Task<IActionResult> Policies()
         {
             var data = (await _SettingsRepository.GetSettingAsync<PoliciesSettings>()) ?? new PoliciesSettings();
-
-            // load display app dropdown
-            using (var ctx = _ContextFactory.CreateContext())
-            {
-                var userId = _UserManager.GetUserId(base.User);
-                var selectList = ctx.Users.Where(user => user.Id == userId)
-                                .SelectMany(s => s.UserStores)
-                                .Select(s => s.StoreData)
-                                .SelectMany(s => s.Apps)
-                                .Select(a => new SelectListItem($"{a.AppType} - {a.Name}", a.Id)).ToList();
-                selectList.Insert(0, new SelectListItem("(None)", null));
-                ViewBag.AppsList = new SelectList(selectList, "Value", "Text", data.RootAppId);
-            }
-
+            ViewBag.AppsList = await GetAppSelectList();
             return View(data);
         }
+
         [Route("server/policies")]
         [HttpPost]
-        public async Task<IActionResult> Policies(PoliciesSettings settings)
+        public async Task<IActionResult> Policies(PoliciesSettings settings, string command = "")
         {
-            if (!String.IsNullOrEmpty(settings.RootAppId))
+            ViewBag.AppsList = await GetAppSelectList();
+            if (command == "add-domain")
             {
-                using (var ctx = _ContextFactory.CreateContext())
-                {
-                    var app = ctx.Apps.SingleOrDefault(a => a.Id == settings.RootAppId);
-                    if (app != null)
-                        settings.RootAppType = Enum.Parse<AppType>(app.AppType);
-                    else
-                        settings.RootAppType = null;
-                }
+                ModelState.Clear();
+                settings.DomainToAppMapping.Add(new PoliciesSettings.DomainToAppMappingItem());
+                return View(settings);
+            }
+            if (command.StartsWith("remove-domain", StringComparison.InvariantCultureIgnoreCase))
+            {
+                ModelState.Clear();
+                var index = int.Parse(command.Substring(command.IndexOf(":", StringComparison.InvariantCultureIgnoreCase) + 1), CultureInfo.InvariantCulture);
+                settings.DomainToAppMapping.RemoveAt(index);
+                return View(settings);
+            }
+
+            if (!ModelState.IsValid)
+            {
+                return View(settings);
+            }
+            var appIdsToFetch = settings.DomainToAppMapping.Select(item => item.AppId).ToList();
+            if (!string.IsNullOrEmpty(settings.RootAppId))
+            {
+                appIdsToFetch.Add(settings.RootAppId);
             }
             else
             {
-                // not preserved on client side, but clearing it just in case
                 settings.RootAppType = null;
             }
 
+            if (appIdsToFetch.Any())
+            {
+                using (var ctx = _ContextFactory.CreateContext())
+                {
+                    var apps = await ctx.Apps.Where(data => appIdsToFetch.Contains(data.Id))
+                        .ToDictionaryAsync(data => data.Id, data => Enum.Parse<AppType>(data.AppType));
+                    if (!string.IsNullOrEmpty(settings.RootAppId))
+                    {
+                        settings.RootAppType = apps[settings.RootAppId];
+                    }
+
+                    foreach (var domainToAppMappingItem in settings.DomainToAppMapping)
+                    {
+                        domainToAppMappingItem.AppType = apps[domainToAppMappingItem.AppId];
+                    }
+                }
+            }
+
             await _SettingsRepository.UpdateSetting(settings);
             TempData["StatusMessage"] = "Policies updated successfully";
             return RedirectToAction(nameof(Policies));
@@ -522,6 +545,11 @@ namespace BTCPayServer.Controllers
                     Link = this.Url.Action(nameof(SSHService))
                 });
             }
+            result.OtherExternalServices.Add(new ServicesViewModel.OtherExternalService()
+            {
+                Name = "Dynamic DNS",
+                Link = this.Url.Action(nameof(DynamicDnsServices))
+            });
             foreach (var torService in _torServices.Services)
             {
                 if (torService.VirtualPort == 80)
@@ -549,12 +577,28 @@ namespace BTCPayServer.Controllers
             var storageSettings = await _SettingsRepository.GetSettingAsync<StorageSettings>();
             result.ExternalStorageServices.Add(new ServicesViewModel.OtherExternalService()
             {
-                Name = storageSettings == null? "Not set": storageSettings.Provider.ToString(),
+                Name = storageSettings == null ? "Not set" : storageSettings.Provider.ToString(),
                 Link = Url.Action("Storage")
             });
             return View(result);
         }
 
+        private async Task<List<SelectListItem>> GetAppSelectList()
+        {
+            // load display app dropdown
+            using (var ctx = _ContextFactory.CreateContext())
+            {
+                var userId = _UserManager.GetUserId(base.User);
+                var selectList = await ctx.Users.Where(user => user.Id == userId)
+                    .SelectMany(s => s.UserStores)
+                    .Select(s => s.StoreData)
+                    .SelectMany(s => s.Apps)
+                    .Select(a => new SelectListItem($"{a.AppType} - {a.Name}", a.Id)).ToListAsync();
+                selectList.Insert(0, new SelectListItem("(None)", null));
+                return selectList;
+            }
+        }
+
         private static bool TryParseAsExternalService(TorService torService, out ExternalService externalService)
         {
             externalService = null;
@@ -604,7 +648,7 @@ namespace BTCPayServer.Controllers
                         ServiceLink = service.ConnectionString.Server.AbsoluteUri.WithoutEndingSlash()
                     });
                 }
-                var connectionString = await service.ConnectionString.Expand(this.Request.GetAbsoluteUriNoPathBase(), service.Type);
+                var connectionString = await service.ConnectionString.Expand(this.Request.GetAbsoluteUriNoPathBase(), service.Type, _Options.NetworkType);
                 switch (service.Type)
                 {
                     case ExternalServiceTypes.Charge:
@@ -720,7 +764,7 @@ namespace BTCPayServer.Controllers
             ExternalConnectionString connectionString = null;
             try
             {
-                connectionString = await service.ConnectionString.Expand(this.Request.GetAbsoluteUriNoPathBase(), service.Type);
+                connectionString = await service.ConnectionString.Expand(this.Request.GetAbsoluteUriNoPathBase(), service.Type, _Options.NetworkType);
             }
             catch (Exception ex)
             {
@@ -762,6 +806,134 @@ namespace BTCPayServer.Controllers
             return RedirectToAction(nameof(Service), new { cryptoCode = cryptoCode, serviceName = serviceName, nonce = nonce });
         }
 
+
+        [Route("server/services/dynamic-dns")]
+        public async Task<IActionResult> DynamicDnsServices()
+        {
+            var settings = (await _SettingsRepository.GetSettingAsync<DynamicDnsSettings>()) ?? new DynamicDnsSettings();
+            return View(settings.Services.Select(s => new DynamicDnsViewModel()
+            {
+                Settings = s
+            }).ToArray());
+        }
+        [Route("server/services/dynamic-dns/{hostname}")]
+        public async Task<IActionResult> DynamicDnsServices(string hostname)
+        {
+            var settings = (await _SettingsRepository.GetSettingAsync<DynamicDnsSettings>()) ?? new DynamicDnsSettings();
+            var service = settings.Services.FirstOrDefault(s => s.Hostname.Equals(hostname, StringComparison.OrdinalIgnoreCase));
+            if (service == null)
+                return NotFound();
+            var vm = new DynamicDnsViewModel();
+            vm.Modify = true;
+            vm.Settings = service;
+            return View(nameof(DynamicDnsService), vm);
+        }
+        [Route("server/services/dynamic-dns")]
+        [HttpPost]
+        public async Task<IActionResult> DynamicDnsService(DynamicDnsViewModel viewModel, string command = null)
+        {
+            if (!ModelState.IsValid)
+            {
+                return View(viewModel);
+            }
+            if (command == "Save")
+            {
+                var settings = (await _SettingsRepository.GetSettingAsync<DynamicDnsSettings>()) ?? new DynamicDnsSettings();
+                var i = settings.Services.FindIndex(d => d.Hostname.Equals(viewModel.Settings.Hostname, StringComparison.OrdinalIgnoreCase));
+                if (i != -1)
+                {
+                    ModelState.AddModelError(nameof(viewModel.Settings.Hostname), "This hostname already exists");
+                    return View(viewModel);
+                }
+                if (viewModel.Settings.Hostname != null)
+                    viewModel.Settings.Hostname = viewModel.Settings.Hostname.Trim().ToLowerInvariant();
+                string errorMessage = await viewModel.Settings.SendUpdateRequest(HttpClientFactory.CreateClient());
+                if (errorMessage == null)
+                {
+                    StatusMessage = $"The Dynamic DNS has been successfully queried, your configuration is saved";
+                    viewModel.Settings.LastUpdated = DateTimeOffset.UtcNow;
+                    settings.Services.Add(viewModel.Settings);
+                    await _SettingsRepository.UpdateSetting(settings);
+                    return RedirectToAction(nameof(DynamicDnsServices));
+                }
+                else
+                {
+                    ModelState.AddModelError(string.Empty, errorMessage);
+                    return View(viewModel);
+                }
+            }
+            else
+            {
+                return View(new DynamicDnsViewModel() { Settings = new DynamicDnsService() });
+            }
+        }
+        [Route("server/services/dynamic-dns/{hostname}")]
+        [HttpPost]
+        public async Task<IActionResult> DynamicDnsService(DynamicDnsViewModel viewModel, string hostname, string command = null)
+        {
+            var settings = (await _SettingsRepository.GetSettingAsync<DynamicDnsSettings>()) ?? new DynamicDnsSettings();
+            
+            var i = settings.Services.FindIndex(d => d.Hostname.Equals(hostname, StringComparison.OrdinalIgnoreCase));
+            if (i == -1)
+                return NotFound();
+            if (viewModel.Settings.Password == null)
+                viewModel.Settings.Password = settings.Services[i].Password;
+            if (viewModel.Settings.Hostname != null)
+                viewModel.Settings.Hostname = viewModel.Settings.Hostname.Trim().ToLowerInvariant();
+            if (!viewModel.Settings.Enabled)
+            {
+                StatusMessage = $"The Dynamic DNS service has been disabled";
+                viewModel.Settings.LastUpdated = null;
+            }
+            else
+            {
+                string errorMessage = await viewModel.Settings.SendUpdateRequest(HttpClientFactory.CreateClient());
+                if (errorMessage == null)
+                {
+                    StatusMessage = $"The Dynamic DNS has been successfully queried, your configuration is saved";
+                    viewModel.Settings.LastUpdated = DateTimeOffset.UtcNow;
+                }
+                else
+                {
+                    ModelState.AddModelError(string.Empty, errorMessage);
+                    return View(viewModel);
+                }
+            }
+            settings.Services[i] = viewModel.Settings;
+            await _SettingsRepository.UpdateSetting(settings);
+            this.RouteData.Values.Remove(nameof(hostname));
+            return RedirectToAction(nameof(DynamicDnsServices));
+        }
+        [HttpGet]
+        [Route("server/services/dynamic-dns/{hostname}/delete")]
+        public async Task<IActionResult> DeleteDynamicDnsService(string hostname)
+        {
+            var settings = (await _SettingsRepository.GetSettingAsync<DynamicDnsSettings>()) ?? new DynamicDnsSettings();
+            var i = settings.Services.FindIndex(d => d.Hostname.Equals(hostname, StringComparison.OrdinalIgnoreCase));
+            if (i == -1)
+                return NotFound();
+            return View("Confirm", new ConfirmModel()
+            {
+                Title = "Delete the dynamic dns service for " + hostname,
+                Description = "BTCPayServer will stop updating this DNS record periodically",
+                Action = "Delete"
+            });
+        }
+        [HttpPost]
+        [Route("server/services/dynamic-dns/{hostname}/delete")]
+        public async Task<IActionResult> DeleteDynamicDnsServicePost(string hostname)
+        {
+            var settings = (await _SettingsRepository.GetSettingAsync<DynamicDnsSettings>()) ?? new DynamicDnsSettings();
+            var i = settings.Services.FindIndex(d => d.Hostname.Equals(hostname, StringComparison.OrdinalIgnoreCase));
+            if (i == -1)
+                return NotFound();
+            settings.Services.RemoveAt(i);
+            await _SettingsRepository.UpdateSetting(settings);
+            StatusMessage = "Dynamic DNS service successfully removed";
+            this.RouteData.Values.Remove(nameof(hostname));
+            return RedirectToAction(nameof(DynamicDnsServices));
+        }
+
         [Route("server/services/ssh")]
         public IActionResult SSHService(bool downloadKeyFile = false)
         {
@@ -823,7 +995,8 @@ namespace BTCPayServer.Controllers
                 try
                 {
                     var client = model.Settings.CreateSmtpClient();
-                    await client.SendMailAsync(model.Settings.From, model.TestEmail, "BTCPay test", "BTCPay test");
+                    var message = model.Settings.CreateMailMessage(new MailAddress(model.TestEmail), "BTCPay test", "BTCPay test");
+                    await client.SendMailAsync(message);
                     model.StatusMessage = "Email sent to " + model.TestEmail + ", please, verify you received it";
                 }
                 catch (Exception ex)
@@ -875,14 +1048,16 @@ namespace BTCPayServer.Controllers
                     .ToList();
                 vm.LogFileOffset = offset;
 
-                if (string.IsNullOrEmpty(file))
+                if (string.IsNullOrEmpty(file) || !file.EndsWith(fileExtension, StringComparison.Ordinal))
                     return View("Logs", vm);
                 vm.Log = "";
-                var path = Path.Combine(di.FullName, file);
+                var fi = vm.LogFiles.FirstOrDefault(o => o.Name == file);
+                if (fi == null)
+                    return NotFound();
                 try
                 {
                     using (var fileStream = new FileStream(
-                        path,
+                        fi.FullName,
                         FileMode.Open,
                         FileAccess.Read,
                         FileShare.ReadWrite))

BTCPayServer/Controllers/StorageController.cs

@@ -1,23 +1,28 @@
+using System;
 using System.Threading.Tasks;
+using BTCPayServer.Configuration;
 using BTCPayServer.Storage.Services;
+using BTCPayServer.Storage.Services.Providers.FileSystemStorage;
 using Microsoft.AspNetCore.Mvc;
 
 namespace BTCPayServer.Storage
 {
     [Route("Storage")]
-    public class StorageController
+    public class StorageController : Controller
     {
         private readonly FileService _FileService;
+        private string _dir;
 
-        public StorageController(FileService fileService)
+        public StorageController(FileService fileService, BTCPayServerOptions serverOptions)
         {
             _FileService = fileService;
+            _dir =FileSystemFileProviderService.GetTempStorageDir(serverOptions);
         }
 
         [HttpGet("{fileId}")]
         public async Task<IActionResult> GetFile(string fileId)
         {
-            var url = await _FileService.GetFileUrl(fileId);
+            var url = await _FileService.GetFileUrl(Request.GetAbsoluteRootUri(), fileId);
             return new RedirectResult(url);
         }
     }

BTCPayServer/Controllers/StoresController.BTCLike.cs

@@ -1,16 +1,19 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
+using System.IO;
 using System.Linq;
 using System.Net.WebSockets;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Data;
+using BTCPayServer.Models;
 using BTCPayServer.Models.StoreViewModels;
 using BTCPayServer.Payments;
 using BTCPayServer.Services;
 using LedgerWallet;
+using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using NBitcoin;
 using NBXplorer.DerivationStrategy;
@@ -36,10 +39,19 @@ namespace BTCPayServer.Controllers
             DerivationSchemeViewModel vm = new DerivationSchemeViewModel();
             vm.CryptoCode = cryptoCode;
             vm.RootKeyPath = network.GetRootKeyPath();
+            vm.Network = network;
             SetExistingValues(store, vm);
             return View(vm);
         }
 
+        class GetXPubs
+        {
+            public BitcoinExtPubKey ExtPubKey { get; set; }
+            public DerivationStrategyBase DerivationScheme { get; set; }
+            public HDFingerprint RootFingerprint { get; set; }
+            public string Source { get; set; }
+        }
+
         [HttpGet]
         [Route("{storeId}/derivations/{cryptoCode}/ledger/ws")]
         public async Task<IActionResult> AddDerivationSchemeLedger(
@@ -52,9 +64,9 @@ namespace BTCPayServer.Controllers
                 return NotFound();
 
             var webSocket = await HttpContext.WebSockets.AcceptWebSocketAsync();
-            var hw = new HardwareWalletService(webSocket);
+            var hw = new LedgerHardwareWalletService(webSocket);
             object result = null;
-            var network = _NetworkProvider.GetNetwork(cryptoCode);
+            var network = _NetworkProvider.GetNetwork<BTCPayNetwork>(cryptoCode);
 
             using (var normalOperationTimeout = new CancellationTokenSource())
             {
@@ -70,7 +82,18 @@ namespace BTCPayServer.Controllers
                         var k = KeyPath.Parse(keyPath);
                         if (k.Indexes.Length == 0)
                             throw new FormatException("Invalid key path");
-                        var getxpubResult = await hw.GetExtPubKey(network, k, normalOperationTimeout.Token);
+
+                        var getxpubResult = new GetXPubs();
+                        getxpubResult.ExtPubKey = await hw.GetExtPubKey(network, k, normalOperationTimeout.Token);
+                        var segwit = network.NBitcoinNetwork.Consensus.SupportSegwit;
+                        var derivation = new DerivationStrategyFactory(network.NBitcoinNetwork).CreateDirectDerivationStrategy(getxpubResult.ExtPubKey, new DerivationStrategyOptions()
+                        {
+                            P2SH = segwit,
+                            Legacy = !segwit
+                        });
+                        getxpubResult.DerivationScheme = derivation;
+                        getxpubResult.RootFingerprint = (await hw.GetExtPubKey(network, new KeyPath(), normalOperationTimeout.Token)).ExtPubKey.PubKey.GetHDFingerPrint();
+                        getxpubResult.Source = hw.Device;
                         result = getxpubResult;
                     }
                 }
@@ -84,7 +107,7 @@ namespace BTCPayServer.Controllers
                     if (result != null)
                     {
                         UTF8Encoding UTF8NOBOM = new UTF8Encoding(false);
-                        var bytes = UTF8NOBOM.GetBytes(JsonConvert.SerializeObject(result, MvcJsonOptions.Value.SerializerSettings));
+                        var bytes = UTF8NOBOM.GetBytes(JsonConvert.SerializeObject(result, network.NBXplorerNetwork.JsonSerializerSettings));
                         await webSocket.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Text, true, new CancellationTokenSource(2000).Token);
                     }
                 }
@@ -97,24 +120,34 @@ namespace BTCPayServer.Controllers
             return new EmptyResult();
         }
 
+        
+        
         private void SetExistingValues(StoreData store, DerivationSchemeViewModel vm)
         {
-            vm.DerivationScheme = GetExistingDerivationStrategy(vm.CryptoCode, store)?.DerivationStrategyBase.ToString();
+            var derivation = GetExistingDerivationStrategy(vm.CryptoCode, store);
+            if (derivation != null)
+            {
+                vm.DerivationScheme = derivation.AccountDerivation.ToString();
+                vm.Config = derivation.ToJson();
+            }
             vm.Enabled = !store.GetStoreBlob().IsExcluded(new PaymentMethodId(vm.CryptoCode, PaymentTypes.BTCLike));
         }
 
-        private DerivationStrategy GetExistingDerivationStrategy(string cryptoCode, StoreData store)
+        private DerivationSchemeSettings GetExistingDerivationStrategy(string cryptoCode, StoreData store)
         {
             var id = new PaymentMethodId(cryptoCode, PaymentTypes.BTCLike);
             var existing = store.GetSupportedPaymentMethods(_NetworkProvider)
-                .OfType<DerivationStrategy>()
+                .OfType<DerivationSchemeSettings>()
                 .FirstOrDefault(d => d.PaymentId == id);
             return existing;
         }
+        
+        
 
         [HttpPost]
         [Route("{storeId}/derivations/{cryptoCode}")]
-        public async Task<IActionResult> AddDerivationScheme(string storeId, DerivationSchemeViewModel vm, string cryptoCode)
+        public async Task<IActionResult> AddDerivationScheme(string storeId, DerivationSchemeViewModel vm,
+            string cryptoCode)
         {
             vm.CryptoCode = cryptoCode;
             var store = HttpContext.GetStoreData();
@@ -126,45 +159,100 @@ namespace BTCPayServer.Controllers
             {
                 return NotFound();
             }
+
+            vm.Network = network;
             vm.RootKeyPath = network.GetRootKeyPath();
+            DerivationSchemeSettings strategy = null;
+            
             var wallet = _WalletProvider.GetWallet(network);
             if (wallet == null)
             {
                 return NotFound();
             }
 
-            PaymentMethodId paymentMethodId = new PaymentMethodId(network.CryptoCode, PaymentTypes.BTCLike);
-            var exisingStrategy = store.GetSupportedPaymentMethods(_NetworkProvider)
-                                       .Where(c => c.PaymentId == paymentMethodId)
-                                       .OfType<DerivationStrategy>()
-                                       .Select(c => c.DerivationStrategyBase.ToString())
-                                       .FirstOrDefault();
-            DerivationStrategy strategy = null;
-            try
+            if (!string.IsNullOrEmpty(vm.Config))
             {
-                if (!string.IsNullOrEmpty(vm.DerivationScheme))
+                if (!DerivationSchemeSettings.TryParseFromJson(vm.Config, network, out strategy))
                 {
-                    strategy = ParseDerivationStrategy(vm.DerivationScheme, null, network);
-                    vm.DerivationScheme = strategy.ToString();
+                    vm.StatusMessage = new StatusMessageModel()
+                    {
+                        Severity = StatusMessageModel.StatusSeverity.Error,
+                        Message = "Config file was not in the correct format"
+                    }.ToString();
+                    vm.Confirmation = false;
+                    return View(vm);
                 }
             }
-            catch
+
+            if (vm.ColdcardPublicFile != null)
             {
-                ModelState.AddModelError(nameof(vm.DerivationScheme), "Invalid Derivation Scheme");
-                vm.Confirmation = false;
-                return View(vm);
+                if (!DerivationSchemeSettings.TryParseFromColdcard(await ReadAllText(vm.ColdcardPublicFile), network, out strategy))
+                {
+                    vm.StatusMessage = new StatusMessageModel()
+                    {
+                        Severity = StatusMessageModel.StatusSeverity.Error,
+                        Message = "Coldcard public file was not in the correct format"
+                    }.ToString();
+                    vm.Confirmation = false;
+                    return View(vm);
+                }
             }
+            else
+            {
+                try
+                {
+                    if (!string.IsNullOrEmpty(vm.DerivationScheme))
+                    {
+                        var newStrategy = ParseDerivationStrategy(vm.DerivationScheme, null, network);
+                        if (newStrategy.AccountDerivation != strategy?.AccountDerivation)
+                        {
+                            var accountKey = string.IsNullOrEmpty(vm.AccountKey) ? null : new BitcoinExtPubKey(vm.AccountKey, network.NBitcoinNetwork);
+                            if (accountKey != null)
+                            {
+                                var accountSettings = newStrategy.AccountKeySettings.FirstOrDefault(a => a.AccountKey == accountKey);
+                                if (accountSettings != null)
+                                {
+                                    accountSettings.AccountKeyPath = vm.KeyPath == null ? null : KeyPath.Parse(vm.KeyPath);
+                                    accountSettings.RootFingerprint = string.IsNullOrEmpty(vm.RootFingerprint) ? (HDFingerprint?)null : new HDFingerprint(NBitcoin.DataEncoders.Encoders.Hex.DecodeData(vm.RootFingerprint));
+                                }
+                            }
+                            strategy = newStrategy;
+                            strategy.Source = vm.Source;
+                            vm.DerivationScheme = strategy.AccountDerivation.ToString();
+                        }
+                    }
+                    else
+                    {
+                        strategy = null;
+                    }
+                }
+                catch
+                {
+                    ModelState.AddModelError(nameof(vm.DerivationScheme), "Invalid Derivation Scheme");
+                    vm.Confirmation = false;
+                    return View(vm);
+                }
+            }
+
+            var oldConfig = vm.Config;
+            vm.Config = strategy == null ? null : strategy.ToJson();
+
+            PaymentMethodId paymentMethodId = new PaymentMethodId(network.CryptoCode, PaymentTypes.BTCLike);
+            var exisingStrategy = store.GetSupportedPaymentMethods(_NetworkProvider)
+                .Where(c => c.PaymentId == paymentMethodId)
+                .OfType<DerivationSchemeSettings>()
+                .FirstOrDefault();
             var storeBlob = store.GetStoreBlob();
             var wasExcluded = storeBlob.GetExcludedPaymentMethods().Match(paymentMethodId);
             var willBeExcluded = !vm.Enabled;
 
             var showAddress = // Show addresses if:
-                              // - If the user is testing the hint address in confirmation screen
-                              (vm.Confirmation && !string.IsNullOrWhiteSpace(vm.HintAddress)) ||
-                              // - The user is setting a new derivation scheme
-                              (!vm.Confirmation && strategy != null && exisingStrategy != strategy.DerivationStrategyBase.ToString()) ||
-                              // - The user is clicking on continue without changing anything   
-                              (!vm.Confirmation && willBeExcluded == wasExcluded);
+                // - If the user is testing the hint address in confirmation screen
+                (vm.Confirmation && !string.IsNullOrWhiteSpace(vm.HintAddress)) ||
+                // - The user is clicking on continue after changing the config
+                (!vm.Confirmation && oldConfig != vm.Config) ||
+                // - The user is clickingon continue without changing config nor enabling/disabling
+                (!vm.Confirmation && oldConfig == vm.Config && willBeExcluded == wasExcluded);
 
             showAddress = showAddress && strategy != null;
             if (!showAddress)
@@ -172,10 +260,9 @@ namespace BTCPayServer.Controllers
                 try
                 {
                     if (strategy != null)
-                        await wallet.TrackAsync(strategy.DerivationStrategyBase);
+                        await wallet.TrackAsync(strategy.AccountDerivation);
                     store.SetSupportedPaymentMethod(paymentMethodId, strategy);
-                    storeBlob.SetExcluded(paymentMethodId, willBeExcluded);                    
-                    storeBlob.SetWalletKeyPathRoot(paymentMethodId, vm.KeyPath == null ? null : KeyPath.Parse(vm.KeyPath));
+                    storeBlob.SetExcluded(paymentMethodId, willBeExcluded);
                     store.SetStoreBlob(storeBlob);
                 }
                 catch
@@ -185,8 +272,14 @@ namespace BTCPayServer.Controllers
                 }
 
                 await _Repo.UpdateStore(store);
-                StatusMessage = $"Derivation scheme for {network.CryptoCode} has been modified.";
-                return RedirectToAction(nameof(UpdateStore), new { storeId = storeId });
+                if (oldConfig != vm.Config)
+                    StatusMessage = $"Derivation settings for {network.CryptoCode} has been modified.";
+                if (willBeExcluded != wasExcluded)
+                {
+                    var label = willBeExcluded ? "disabled" : "enabled";
+                    StatusMessage = $"On-Chain payments for {network.CryptoCode} has been {label}.";
+                }
+                return RedirectToAction(nameof(UpdateStore), new {storeId = storeId});
             }
             else if (!string.IsNullOrEmpty(vm.HintAddress))
             {
@@ -203,27 +296,43 @@ namespace BTCPayServer.Controllers
 
                 try
                 {
-                    strategy = ParseDerivationStrategy(vm.DerivationScheme, address.ScriptPubKey, network);
+                    var newStrategy = ParseDerivationStrategy(vm.DerivationScheme, address.ScriptPubKey, network);
+                    if (newStrategy.AccountDerivation != strategy.AccountDerivation)
+                    {
+                        strategy.AccountDerivation = newStrategy.AccountDerivation;
+                        strategy.AccountOriginal = null;
+                    }
                 }
                 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\"";
+                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);
         }
 
-        private IActionResult ShowAddresses(DerivationSchemeViewModel vm, DerivationStrategy strategy)
+        private async Task<string> ReadAllText(IFormFile file)
         {
-            vm.DerivationScheme = strategy.DerivationStrategyBase.ToString();
+            using (var stream = new StreamReader(file.OpenReadStream()))
+            {
+                return await stream.ReadToEndAsync();
+            }
+        }
+
+        private IActionResult ShowAddresses(DerivationSchemeViewModel vm, DerivationSchemeSettings strategy)
+        {
+            vm.DerivationScheme = strategy.AccountDerivation.ToString();
             if (!string.IsNullOrEmpty(vm.DerivationScheme))
             {
-                var line = strategy.DerivationStrategyBase.GetLineFor(DerivationFeature.Deposit);
+                var line = strategy.AccountDerivation.GetLineFor(DerivationFeature.Deposit);
 
                 for (int i = 0; i < 10; i++)
                 {
@@ -232,6 +341,7 @@ namespace BTCPayServer.Controllers
                 }
             }
             vm.Confirmation = true;
+            ModelState.Remove(nameof(vm.Config)); // Remove the cached value
             return View(vm);
         }
     }

BTCPayServer/Controllers/StoresController.Email.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Net.Mail;
 using System.Threading.Tasks;
 using BTCPayServer.Data;
 using BTCPayServer.Models.ServerViewModels;
@@ -39,7 +40,8 @@ namespace BTCPayServer.Controllers
                         return View(model);
                     }
                     var client = model.Settings.CreateSmtpClient();
-                    await client.SendMailAsync(model.Settings.From, model.TestEmail, "BTCPay test", "BTCPay test");
+                    var message = model.Settings.CreateMailMessage(new MailAddress(model.TestEmail), "BTCPay test", "BTCPay test");
+                    await client.SendMailAsync(message);
                     model.StatusMessage = "Email sent to " + model.TestEmail + ", please, verify you received it";
                 }
                 catch (Exception ex)

BTCPayServer/Controllers/StoresController.LightningLike.cs

@@ -152,7 +152,7 @@ namespace BTCPayServer.Controllers
                     ModelState.AddModelError(nameof(vm.ConnectionString), "Missing url parameter");
                     return View(vm);
                 case "test":
-                    var handler = (LightningLikePaymentHandler)_ServiceProvider.GetRequiredService<IPaymentMethodHandler<Payments.Lightning.LightningSupportedPaymentMethod>>();
+                    var handler = _ServiceProvider.GetRequiredService<LightningLikePaymentHandler>();
                     try
                     {
                         var info = await handler.GetNodeInfo(this.Request.IsOnion(), paymentMethod, network);

BTCPayServer/Controllers/StoresController.cs

@@ -17,6 +17,7 @@ using BTCPayServer.Payments.Lightning;
 using BTCPayServer.Rating;
 using BTCPayServer.Security;
 using BTCPayServer.Services;
+using BTCPayServer.Services.Invoices;
 using BTCPayServer.Services.Rates;
 using BTCPayServer.Services.Stores;
 using BTCPayServer.Services.Wallets;
@@ -34,7 +35,7 @@ namespace BTCPayServer.Controllers
 {
     [Route("stores")]
     [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
-    [Authorize(Policy = Policies.CanModifyStoreSettings.Key)]
+    [Authorize(Policy = Policies.CanModifyStoreSettings.Key, AuthenticationSchemes = Policies.CookieAuthentication)]
     [AutoValidateAntiforgeryToken]
     public partial class StoresController : Controller
     {
@@ -56,7 +57,8 @@ namespace BTCPayServer.Controllers
             LanguageService langService,
             ChangellyClientProvider changellyClientProvider,
             IOptions<MvcJsonOptions> mvcJsonOptions,
-            IHostingEnvironment env, IHttpClientFactory httpClientFactory)
+            IHostingEnvironment env, IHttpClientFactory httpClientFactory,
+            PaymentMethodHandlerDictionary paymentMethodHandlerDictionary)
         {
             _RateFactory = rateFactory;
             _Repo = repo;
@@ -69,6 +71,7 @@ namespace BTCPayServer.Controllers
             _WalletProvider = walletProvider;
             _Env = env;
             _httpClientFactory = httpClientFactory;
+            _paymentMethodHandlerDictionary = paymentMethodHandlerDictionary;
             _NetworkProvider = networkProvider;
             _ExplorerProvider = explorerProvider;
             _FeeRateProvider = feeRateProvider;
@@ -91,6 +94,7 @@ namespace BTCPayServer.Controllers
         private readonly ChangellyClientProvider _changellyClientProvider;
         IHostingEnvironment _Env;
         private IHttpClientFactory _httpClientFactory;
+        private readonly PaymentMethodHandlerDictionary _paymentMethodHandlerDictionary;
 
         [TempData]
         public string StatusMessage
@@ -362,7 +366,7 @@ namespace BTCPayServer.Controllers
         void SetCryptoCurrencies(CheckoutExperienceViewModel vm, Data.StoreData storeData)
         {
             var choices = storeData.GetEnabledPaymentIds(_NetworkProvider)
-                                      .Select(o => new CheckoutExperienceViewModel.Format() { Name = GetDisplayName(o), Value = o.ToString(), PaymentId = o }).ToArray();
+                                      .Select(o => new CheckoutExperienceViewModel.Format() { Name = o.ToPrettyString(), Value = o.ToString(), PaymentId = o }).ToArray();
 
             var defaultPaymentId = storeData.GetDefaultPaymentId(_NetworkProvider);
             var chosen = choices.FirstOrDefault(c => c.PaymentId == defaultPaymentId);
@@ -370,13 +374,6 @@ namespace BTCPayServer.Controllers
             vm.DefaultPaymentMethod = chosen?.Value;
         }
 
-        private string GetDisplayName(PaymentMethodId paymentMethodId)
-        {
-            var display = _NetworkProvider.GetNetwork(paymentMethodId.CryptoCode)?.DisplayName ?? paymentMethodId.CryptoCode;
-            return paymentMethodId.PaymentType == PaymentTypes.BTCLike ?
-                display : $"{display} (Lightning)";
-        }
-
         [HttpPost]
         [Route("{storeId}/checkout")]
         public async Task<IActionResult> CheckoutExperience(CheckoutExperienceViewModel model)
@@ -470,38 +467,40 @@ namespace BTCPayServer.Controllers
             var derivationByCryptoCode =
                 store
                 .GetSupportedPaymentMethods(_NetworkProvider)
-                .OfType<DerivationStrategy>()
+                .OfType<DerivationSchemeSettings>()
                 .ToDictionary(c => c.Network.CryptoCode);
-            foreach (var network in _NetworkProvider.GetAll())
-            {
-                var strategy = derivationByCryptoCode.TryGet(network.CryptoCode);
-                vm.DerivationSchemes.Add(new StoreViewModel.DerivationScheme()
-                {
-                    Crypto = network.CryptoCode,
-                    Value = strategy?.DerivationStrategyBase?.ToString() ?? string.Empty,
-                    WalletId = new WalletId(store.Id, network.CryptoCode),
-                    Enabled = !excludeFilters.Match(new Payments.PaymentMethodId(network.CryptoCode, Payments.PaymentTypes.BTCLike))
-                });
-            }
 
             var lightningByCryptoCode = store
-                                        .GetSupportedPaymentMethods(_NetworkProvider)
-                                        .OfType<Payments.Lightning.LightningSupportedPaymentMethod>()
-                                        .ToDictionary(c => c.CryptoCode);
+                .GetSupportedPaymentMethods(_NetworkProvider)
+                .OfType<LightningSupportedPaymentMethod>()
+                .ToDictionary(c => c.CryptoCode);
 
-            foreach (var network in _NetworkProvider.GetAll())
+            foreach (var paymentMethodId in _paymentMethodHandlerDictionary.Distinct().SelectMany(handler => handler.GetSupportedPaymentMethods()))
             {
-                var lightning = lightningByCryptoCode.TryGet(network.CryptoCode);
-                var paymentId = new Payments.PaymentMethodId(network.CryptoCode, Payments.PaymentTypes.LightningLike);
-                vm.LightningNodes.Add(new StoreViewModel.LightningNode()
+                 switch (paymentMethodId.PaymentType)
                 {
-                    CryptoCode = network.CryptoCode,
-                    Address = lightning?.GetLightningUrl()?.BaseUri.AbsoluteUri ?? string.Empty,
-                    Enabled = !excludeFilters.Match(paymentId)
-                });
+                    case BitcoinPaymentType _:
+                        var strategy = derivationByCryptoCode.TryGet(paymentMethodId.CryptoCode);
+                        vm.DerivationSchemes.Add(new StoreViewModel.DerivationScheme()
+                        {
+                            Crypto = paymentMethodId.CryptoCode,
+                            Value = strategy?.ToPrettyString() ?? string.Empty,
+                            WalletId = new WalletId(store.Id, paymentMethodId.CryptoCode),
+                            Enabled = !excludeFilters.Match(paymentMethodId)
+                        });
+                        break;
+                    case LightningPaymentType _:
+                        var lightning = lightningByCryptoCode.TryGet(paymentMethodId.CryptoCode);
+                        vm.LightningNodes.Add(new StoreViewModel.LightningNode()
+                        {
+                            CryptoCode = paymentMethodId.CryptoCode,
+                            Address = lightning?.GetLightningUrl()?.BaseUri.AbsoluteUri ?? string.Empty,
+                            Enabled = !excludeFilters.Match(paymentMethodId)
+                        });
+                        break;
+                }   
             }
 
-
             var changellyEnabled = storeBlob.ChangellySettings != null && storeBlob.ChangellySettings.Enabled;
             vm.ThirdPartyPaymentMethods.Add(new StoreViewModel.ThirdPartyPaymentMethod()
             {
@@ -591,16 +590,17 @@ namespace BTCPayServer.Controllers
         private CoinAverageExchange[] GetSupportedExchanges()
         {
             return _RateFactory.RateProviderFactory.GetSupportedExchanges()
+                    .Where(r => !string.IsNullOrWhiteSpace(r.Value.Display))
                     .Select(c => c.Value)
                     .OrderBy(s => s.Name, StringComparer.OrdinalIgnoreCase)
                     .ToArray();
         }
 
-        private DerivationStrategy ParseDerivationStrategy(string derivationScheme, Script hint, BTCPayNetwork network)
+        private DerivationSchemeSettings ParseDerivationStrategy(string derivationScheme, Script hint, BTCPayNetwork network)
         {
-            var parser = new DerivationSchemeParser(network.NBitcoinNetwork);
+            var parser = new DerivationSchemeParser(network);
             parser.HintScriptPubKey = hint;
-            return new DerivationStrategy(parser.Parse(derivationScheme), network);
+            return new DerivationSchemeSettings(parser.Parse(derivationScheme), network);
         }
 
         [HttpGet]