Move back ToPrettyString() in PaymentMethodId to fix crash if a payment method as been disabled

New register form

.circleci/config.yml

@@ -0,0 +1,120 @@
+version: 2
+jobs:
+  fast_tests:
+    machine:
+        docker_layer_caching: true
+    steps:
+      - checkout
+      - run:
+          command: |
+            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
+  amd64:
+    machine:
+      docker_layer_caching: true
+    steps:
+      - checkout  
+      - run:
+          command: |
+            LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
+            #
+            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
+
+  arm32v7:
+    machine:
+      docker_layer_caching: true
+    steps:
+      - checkout  
+      - run:
+          command: |
+            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 arm32v7.Dockerfile .
+            sudo docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
+            sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-arm32v7
+
+  multiarch:
+    machine:
+      enabled: true
+      image: circleci/classic:201808-01
+    steps:
+      - run:
+          command: |
+            # Turn on Experimental features
+            sudo mkdir $HOME/.docker
+            sudo sh -c 'echo "{ \"experimental\": \"enabled\" }" >> $HOME/.docker/config.json'
+            #
+            sudo docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
+            #
+            LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
+            sudo docker manifest create --amend $DOCKERHUB_REPO:$LATEST_TAG $DOCKERHUB_REPO:$LATEST_TAG-amd64 $DOCKERHUB_REPO:$LATEST_TAG-arm32v7
+            sudo docker manifest annotate $DOCKERHUB_REPO:$LATEST_TAG $DOCKERHUB_REPO:$LATEST_TAG-amd64 --os linux --arch amd64
+            sudo docker manifest annotate $DOCKERHUB_REPO:$LATEST_TAG $DOCKERHUB_REPO:$LATEST_TAG-arm32v7 --os linux --arch arm --variant v7
+            sudo docker manifest push $DOCKERHUB_REPO:$LATEST_TAG -p
+
+workflows:
+  version: 2
+  build_and_test:
+    jobs:
+      - fast_tests
+      - selenium_tests
+      - integration_tests
+      - external_tests:
+          filters:
+            branches:
+                only: master
+
+  publish:
+    jobs:
+      - amd64:
+          filters:
+            # ignore any commit on any branch by default
+            branches:
+              ignore: /.*/
+            # only act on version tags
+            tags:
+              only: /v[1-9]+(\.[0-9]+)*/
+      - arm32v7:
+          filters:
+            branches:
+              ignore: /.*/
+            tags:
+              only: /v[1-9]+(\.[0-9]+)*/
+      - multiarch:
+          requires:
+            - amd64
+            - arm32v7
+          filters:
+            branches:
+              ignore: /.*/
+            tags:
+              only: /v[1-9]+(\.[0-9]+)*/

.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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,34 @@
+---
+name: Report a problem
+about: File a technical problem or report a bug
+---
+
+**Describe the problem/bug**
+A clear and concise description of what the bug is.
+
+**Your environment**
+* Version of BTCPay Server:
+* Deployment method: 
+* Other relevant environment details:
+
+**Logs (if applicable)**
+Basic logs can be found in Server Settings > Logs.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Actual behavior**
+Tell us what happens instead
+
+**Screenshots/Links**
+If applicable, add screenshots or links to help explain your problem.
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Ideas and feature requests
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Provide examples**
+If applicable provide examples, wireframes, sketches or images to better explain your idea.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.gitignore

@@ -291,3 +291,5 @@ __pycache__/
 # Bundling JS/CSS
 BTCPayServer/wwwroot/bundles/*
 !BTCPayServer/wwwroot/bundles/.gitignore
+
+.vscode

BTCPayServer.Common/BTCPayNetwork.cs

@@ -0,0 +1,139 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+using NBXplorer;
+using Newtonsoft.Json;
+
+namespace BTCPayServer
+{
+    public enum DerivationType
+    {
+        Legacy,
+        SegwitP2SH,
+        Segwit
+    }
+    public class BTCPayDefaultSettings
+    {
+        static BTCPayDefaultSettings()
+        {
+            _Settings = new Dictionary<NetworkType, BTCPayDefaultSettings>();
+            foreach (var chainType in new[] { NetworkType.Mainnet, NetworkType.Testnet, NetworkType.Regtest })
+            {
+                var settings = new BTCPayDefaultSettings();
+                _Settings.Add(chainType, settings);
+                settings.DefaultDataDirectory = StandardConfiguration.DefaultDataDirectory.GetDirectory("BTCPayServer", NBXplorerDefaultSettings.GetFolderName(chainType));
+                settings.DefaultConfigurationFile = Path.Combine(settings.DefaultDataDirectory, "settings.config");
+                settings.DefaultPort = (chainType == NetworkType.Mainnet ? 23000 :
+                                                      chainType == NetworkType.Regtest ? 23002 :
+                                                      chainType == NetworkType.Testnet ? 23001 : throw new NotSupportedException(chainType.ToString()));
+            }
+        }
+
+        static Dictionary<NetworkType, BTCPayDefaultSettings> _Settings;
+
+        public static BTCPayDefaultSettings GetDefaultSettings(NetworkType chainType)
+        {
+            return _Settings[chainType];
+        }
+
+        public string DefaultDataDirectory { get; set; }
+        public string DefaultConfigurationFile { get; set; }
+        public int DefaultPort { get; set; }
+    }
+
+    public class BTCPayNetwork: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 string DisplayName { get; set; }
+
+        [Obsolete("Should not be needed")]
+        public bool IsBTC
+        {
+            get
+            {
+                return CryptoCode == "BTC";
+            }
+        }
+
+        public string CryptoImagePath { get; set; }
+
+        public int MaxTrackedConfirmation { get; internal set; } = 6;
+        public string[] DefaultRateRules { get; internal set; } = Array.Empty<string>();
+        public override string ToString()
+        {
+            return CryptoCode;
+        }
+
+        public virtual T ToObject<T>(string json)
+        {
+            return JsonConvert.DeserializeObject<T>(json);
+        }
+
+        public virtual string ToString<T>(T obj)
+        {
+            return JsonConvert.SerializeObject(obj);
+        }
+    }
+}

BTCPayServer.Common/BTCPayNetworkProvider.Bitcoin.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitBitcoin()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("BTC");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Bitcoin",
+                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'"),
+                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.BitcoinGold.cs

@@ -0,0 +1,30 @@
+using NBitcoin;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitBitcoinGold()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("BTG");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "BGold",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://explorer.bitcoingold.org/insight/tx/{0}/" : "https://test-explorer.bitcoingold.org/insight/tx/{0}",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "bitcoingold",
+                DefaultRateRules = new[]
+                {
+                    "BTG_X = BTG_BTC * BTC_X",
+                    "BTG_BTC = bitfinex(BTG_BTC)",
+                },
+                CryptoImagePath = "imlegacy/btg.svg",
+                LightningImagePath = "imlegacy/btg-lightning.svg",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("156'") : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer.Common/BTCPayNetworkProvider.Bitcoinplus.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitBitcoinplus()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("XBC");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Bitcoinplus",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://chainz.cryptoid.info/xbc/tx.dws?{0}" : "https://chainz.cryptoid.info/xbc/tx.dws?{0}",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "bitcoinplus",
+                DefaultRateRules = new[] 
+                {
+                                "XBC_X = XBC_BTC * BTC_X",
+                                "XBC_BTC = cryptopia(XBC_BTC)"
+                },
+                CryptoImagePath = "imlegacy/bitcoinplus.png",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("65'") : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer.Common/BTCPayNetworkProvider.Bitcore.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitBitcore()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("BTX");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Bitcore",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://insight.bitcore.cc/tx/{0}" : "https://insight.bitcore.cc/tx/{0}",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "bitcore",
+                DefaultRateRules = new[]
+                {
+                                "BTX_X = BTX_BTC * BTC_X",
+                                "BTX_BTC = hitbtc(BTX_BTC)"
+                },
+                CryptoImagePath = "imlegacy/bitcore.svg",
+                LightningImagePath = "imlegacy/bitcore-lightning.svg",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("160'") : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer.Common/BTCPayNetworkProvider.Dash.cs

@@ -0,0 +1,34 @@
+using NBitcoin;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitDash()
+        {
+            //not needed: NBitcoin.Altcoins.Dash.Instance.EnsureRegistered();
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("DASH");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Dash",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet
+                    ? "https://insight.dash.org/insight/tx/{0}"
+                    : "https://testnet-insight.dashevo.org/insight/tx/{0}",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "dash",
+                DefaultRateRules = new[]
+                    {
+                        "DASH_X = DASH_BTC * BTC_X",
+                        "DASH_BTC = bittrex(DASH_BTC)"
+                    },
+                CryptoImagePath = "imlegacy/dash.png",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                //https://github.com/satoshilabs/slips/blob/master/slip-0044.md
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("5'")
+                    : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer.Common/BTCPayNetworkProvider.Dogecoin.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitDogecoin()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("DOGE");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Dogecoin",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://dogechain.info/tx/{0}" : "https://dogechain.info/tx/{0}",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "dogecoin",
+                DefaultRateRules = new[] 
+                {
+                                "DOGE_X = DOGE_BTC * BTC_X",
+                                "DOGE_BTC = bittrex(DOGE_BTC)"
+                },
+                CryptoImagePath = "imlegacy/dogecoin.png",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("3'") : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer.Common/BTCPayNetworkProvider.Feathercoin.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitFeathercoin()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("FTC");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Feathercoin",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://explorer.feathercoin.com/tx/{0}" : "https://explorer.feathercoin.com/tx/{0}",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "feathercoin",
+                DefaultRateRules = new[] 
+                {
+                                "FTC_X = FTC_BTC * BTC_X",
+                                "FTC_BTC = bittrex(FTC_BTC)"
+                },
+                CryptoImagePath = "imlegacy/feathercoin.png",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("8'") : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer.Common/BTCPayNetworkProvider.Groestlcoin.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        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",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "groestlcoin",
+                DefaultRateRules = new[]
+                {
+                    "GRS_X = GRS_BTC * BTC_X",
+                    "GRS_BTC = bittrex(GRS_BTC)"
+                },
+                CryptoImagePath = "imlegacy/groestlcoin.png",
+                LightningImagePath = "imlegacy/groestlcoin-lightning.svg",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("17'") : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer.Common/BTCPayNetworkProvider.Litecoin.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitLitecoin()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("LTC");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Litecoin",
+                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'"),
+                //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

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitMonacoin()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("MONA");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Monacoin",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://mona.insight.monaco-ex.org/insight/tx/{0}" : "https://testnet-mona.insight.monaco-ex.org/insight/tx/{0}",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "monacoin",
+                DefaultRateRules = new[] 
+                {
+                                "MONA_X = MONA_BTC * BTC_X",
+                                "MONA_BTC = bittrex(MONA_BTC)"
+                },
+                CryptoImagePath = "imlegacy/monacoin.png",
+                LightningImagePath = "imlegacy/mona-lightning.svg",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("22'") : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer.Common/BTCPayNetworkProvider.Polis.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitPolis()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("POLIS");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Polis",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://insight.polispay.org/tx/{0}" : "https://insight.polispay.org/tx/{0}",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "polis",
+                DefaultRateRules = new[]
+                {
+                                "POLIS_X = POLIS_BTC * BTC_X",
+                                "POLIS_BTC = cryptopia(POLIS_BTC)"
+                },
+                CryptoImagePath = "imlegacy/polis.png",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("1997'") : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer.Common/BTCPayNetworkProvider.Ufo.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitUfo()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("UFO");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Ufo",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://chainz.cryptoid.info/ufo/tx.dws?{0}" : "https://chainz.cryptoid.info/ufo/tx.dws?{0}",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "ufo",
+                DefaultRateRules = new[] 
+                {
+                                "UFO_X = UFO_BTC * BTC_X",
+                                "UFO_BTC = coinexchange(UFO_BTC)"
+                },
+                CryptoImagePath = "imlegacy/ufo.png",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("202'") : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer.Common/BTCPayNetworkProvider.Viacoin.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitViacoin()
+        {
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("VIA");
+            Add(new BTCPayNetwork()
+            {
+                CryptoCode = nbxplorerNetwork.CryptoCode,
+                DisplayName = "Viacoin",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://explorer.viacoin.org/tx/{0}" : "https://explorer.viacoin.org/tx/{0}",
+                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
+                NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "viacoin",
+                DefaultRateRules = new[]
+                {
+                                "VIA_X = VIA_BTC * BTC_X",
+                                "VIA_BTC = bittrex(VIA_BTC)"
+                },
+                CryptoImagePath = "imlegacy/viacoin.png",
+                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("14'") : new KeyPath("1'")
+            });
+        }
+    }
+}

BTCPayServer.Common/BTCPayNetworkProvider.cs

@@ -0,0 +1,116 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using NBitcoin;
+using NBXplorer;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        Dictionary<string, BTCPayNetworkBase> _Networks = new Dictionary<string, BTCPayNetworkBase>();
+
+
+        private readonly NBXplorerNetworkProvider _NBXplorerNetworkProvider;
+        public NBXplorerNetworkProvider NBXplorerNetworkProvider
+        {
+            get
+            {
+                return _NBXplorerNetworkProvider;
+            }
+        }
+
+        BTCPayNetworkProvider(BTCPayNetworkProvider filtered, string[] cryptoCodes)
+        {
+            NetworkType = filtered.NetworkType;
+            _NBXplorerNetworkProvider = new NBXplorerNetworkProvider(filtered.NetworkType);
+            _Networks = new Dictionary<string, BTCPayNetworkBase>();
+            cryptoCodes = cryptoCodes.Select(c => c.ToUpperInvariant()).ToArray();
+            foreach (var network in filtered._Networks)
+            {
+                if(cryptoCodes.Contains(network.Key))
+                {
+                    _Networks.Add(network.Key, network.Value);
+                }
+            }
+        }
+
+        public NetworkType NetworkType { get; private set; }
+        public BTCPayNetworkProvider(NetworkType networkType)
+        {
+            _NBXplorerNetworkProvider = new NBXplorerNetworkProvider(networkType);
+            NetworkType = networkType;
+            InitBitcoin();
+            InitLitecoin();
+            InitBitcore();
+            InitDogecoin();
+            InitBitcoinGold();
+            InitMonacoin();
+            InitDash();
+            InitFeathercoin();
+            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();
+            //InitUfo();
+        }
+
+        /// <summary>
+        /// Keep only the specified crypto
+        /// </summary>
+        /// <param name="cryptoCodes">Crypto to support</param>
+        /// <returns></returns>
+        public BTCPayNetworkProvider Filter(string[] cryptoCodes)
+        {
+            return new BTCPayNetworkProvider(this, cryptoCodes);
+        }
+
+        [Obsolete("To use only for legacy stuff")]
+        public BTCPayNetwork BTC => GetNetwork<BTCPayNetwork>("BTC");
+
+        public void Add(BTCPayNetworkBase network)
+        {
+            _Networks.Add(network.CryptoCode.ToUpperInvariant(), network);
+        }
+
+        public IEnumerable<BTCPayNetworkBase> GetAll()
+        {
+            return _Networks.Values.ToArray();
+        }
+
+        public bool Support(string cryptoCode)
+        {
+            return _Networks.ContainsKey(cryptoCode.ToUpperInvariant());
+        }
+
+        public T GetNetwork<T>(string cryptoCode) where T: BTCPayNetworkBase
+        {
+            if(!_Networks.TryGetValue(cryptoCode.ToUpperInvariant(), out BTCPayNetworkBase network))
+            {
+                if (cryptoCode == "XBT")
+                    return GetNetwork<T>("BTC");
+            }
+            return network as T;
+        }
+    }
+}

BTCPayServer.Common/BTCPayServer.Common.csproj

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../Version.csproj" Condition="Exists('../Version.csproj')" />
+  <Import Project="../Common.csproj" />
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.App" Version="2.1.9" />
+    <PackageReference Include="NBitcoin" Version="4.1.2.35" />
+    <PackageReference Include="NBXplorer.Client" Version="2.0.0.17" />
+  </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/Logging/ConsoleLogger.cs

@@ -1,13 +1,14 @@
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Logging.Console;
-using Microsoft.Extensions.Logging.Console.Internal;
-using System;
+using System;
 using System.Collections.Concurrent;
-using System.Collections.Generic;
 using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions.Internal;
+using Microsoft.Extensions.Logging.Console;
+using Microsoft.Extensions.Logging.Console.Internal;
 
 namespace BTCPayServer.Logging
 {
@@ -20,19 +21,18 @@ namespace BTCPayServer.Logging
         }
         public ILogger CreateLogger(string categoryName)
         {
-            return new CustomConsoleLogger(categoryName, (a, b) => true, false, _Processor);
+            return new CustomerConsoleLogger(categoryName, (a, b) => true, null, _Processor);
         }
 
         public void Dispose()
         {
-
         }
     }
 
     /// <summary>
     /// A variant of ASP.NET Core ConsoleLogger which does not make new line for the category
     /// </summary>
-    public class CustomConsoleLogger : ILogger
+    public class CustomerConsoleLogger : ILogger
     {
         private static readonly string _loglevelPadding = ": ";
         private static readonly string _messagePadding;
@@ -47,19 +47,33 @@ namespace BTCPayServer.Logging
         [ThreadStatic]
         private static StringBuilder _logBuilder;
 
-        static CustomConsoleLogger()
+        static CustomerConsoleLogger()
         {
             var logLevelString = GetLogLevelString(LogLevel.Information);
             _messagePadding = new string(' ', logLevelString.Length + _loglevelPadding.Length);
             _newLineWithMessagePadding = Environment.NewLine + _messagePadding;
         }
 
-        public CustomConsoleLogger(string name, Func<string, LogLevel, bool> filter, bool includeScopes, ConsoleLoggerProcessor loggerProcessor)
+        public CustomerConsoleLogger(string name, Func<string, LogLevel, bool> filter, bool includeScopes)
+            : this(name, filter, includeScopes ? new LoggerExternalScopeProvider() : null, new ConsoleLoggerProcessor())
         {
-            Name = name ?? throw new ArgumentNullException(nameof(name));
-            Filter = filter ?? ((category, logLevel) => true);
-            IncludeScopes = includeScopes;
+        }
 
+        internal CustomerConsoleLogger(string name, Func<string, LogLevel, bool> filter, IExternalScopeProvider scopeProvider)
+            : this(name, filter, scopeProvider, new ConsoleLoggerProcessor())
+        {
+        }
+
+        internal CustomerConsoleLogger(string name, Func<string, LogLevel, bool> filter, IExternalScopeProvider scopeProvider, ConsoleLoggerProcessor loggerProcessor)
+        {
+            if (name == null)
+            {
+                throw new ArgumentNullException(nameof(name));
+            }
+
+            Name = name;
+            Filter = filter ?? ((category, logLevel) => true);
+            ScopeProvider = scopeProvider;
             _queueProcessor = loggerProcessor;
 
             if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
@@ -80,7 +94,12 @@ namespace BTCPayServer.Logging
             }
             set
             {
-                _queueProcessor.Console = value ?? throw new ArgumentNullException(nameof(value));
+                if (value == null)
+                {
+                    throw new ArgumentNullException(nameof(value));
+                }
+
+                _queueProcessor.Console = value;
             }
         }
 
@@ -92,13 +111,13 @@ namespace BTCPayServer.Logging
             }
             set
             {
-                _filter = value ?? throw new ArgumentNullException(nameof(value));
-            }
-        }
+                if (value == null)
+                {
+                    throw new ArgumentNullException(nameof(value));
+                }
 
-        public bool IncludeScopes
-        {
-            get; set;
+                _filter = value;
+            }
         }
 
         public string Name
@@ -106,6 +125,16 @@ namespace BTCPayServer.Logging
             get;
         }
 
+        internal IExternalScopeProvider ScopeProvider
+        {
+            get; set;
+        }
+
+        public bool DisableColors
+        {
+            get; set;
+        }
+
         public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
         {
             if (!IsEnabled(logLevel))
@@ -154,10 +183,7 @@ namespace BTCPayServer.Logging
             while (lenAfter++ < 18)
                 logBuilder.Append(" ");
             // scope information
-            if (IncludeScopes)
-            {
-                GetScopeInformation(logBuilder);
-            }
+            GetScopeInformation(logBuilder);
 
             if (!string.IsNullOrEmpty(message))
             {
@@ -202,18 +228,15 @@ namespace BTCPayServer.Logging
 
         public bool IsEnabled(LogLevel logLevel)
         {
+            if (logLevel == LogLevel.None)
+            {
+                return false;
+            }
+
             return Filter(Name, logLevel);
         }
 
-        public IDisposable BeginScope<TState>(TState state)
-        {
-            if (state == null)
-            {
-                throw new ArgumentNullException(nameof(state));
-            }
-
-            return ConsoleLogScope.Push(Name, state);
-        }
+        public IDisposable BeginScope<TState>(TState state) => ScopeProvider?.Push(state) ?? NullScope.Instance;
 
         private static string GetLogLevelString(LogLevel logLevel)
         {
@@ -238,6 +261,11 @@ namespace BTCPayServer.Logging
 
         private ConsoleColors GetLogLevelConsoleColors(LogLevel logLevel)
         {
+            if (DisableColors)
+            {
+                return new ConsoleColors(null, null);
+            }
+
             // We must explicitly set the background color if we are setting the foreground color,
             // since just setting one can look bad on the users console.
             switch (logLevel)
@@ -259,30 +287,25 @@ namespace BTCPayServer.Logging
             }
         }
 
-        private void GetScopeInformation(StringBuilder builder)
+        private void GetScopeInformation(StringBuilder stringBuilder)
         {
-            var current = ConsoleLogScope.Current;
-            string scopeLog = string.Empty;
-            var length = builder.Length;
-
-            while (current != null)
+            var scopeProvider = ScopeProvider;
+            if (scopeProvider != null)
             {
-                if (length == builder.Length)
-                {
-                    scopeLog = $"=> {current}";
-                }
-                else
-                {
-                    scopeLog = $"=> {current} ";
-                }
+                var initialLength = stringBuilder.Length;
 
-                builder.Insert(length, scopeLog);
-                current = current.Parent;
-            }
-            if (builder.Length > length)
-            {
-                builder.Insert(length, _messagePadding);
-                builder.AppendLine();
+                scopeProvider.ForEachScope((scope, state) =>
+                {
+                    var (builder, length) = state;
+                    var first = length == builder.Length;
+                    builder.Append(first ? "=> " : " => ").Append(scope);
+                }, (stringBuilder, initialLength));
+
+                if (stringBuilder.Length > initialLength)
+                {
+                    stringBuilder.Insert(initialLength, _messagePadding);
+                    stringBuilder.AppendLine();
+                }
             }
         }
 
@@ -333,9 +356,9 @@ namespace BTCPayServer.Logging
             // Start Console message queue processor
             _outputTask = Task.Factory.StartNew(
                 ProcessLogQueue,
-                this,
-                default(CancellationToken),
-                TaskCreationOptions.LongRunning, TaskScheduler.Default);
+                state: this,
+                cancellationToken: default(CancellationToken),
+                creationOptions: TaskCreationOptions.LongRunning, scheduler: TaskScheduler.Default);
         }
 
         public virtual void EnqueueMessage(LogMessageEntry message)

BTCPayServer.Common/Logging/Logs.cs

@@ -15,9 +15,14 @@ namespace BTCPayServer.Logging
         }
         public static void Configure(ILoggerFactory factory)
         {
-            Configuration = factory.CreateLogger("Configuration");
-            PayServer = factory.CreateLogger("PayServer");
-            Events = factory.CreateLogger("Events");
+            if (factory == null)
+                Configure(new FuncLoggerFactory(n => NullLogger.Instance));
+            else
+            {
+                Configuration = factory.CreateLogger("Configuration");
+                PayServer = factory.CreateLogger("PayServer");
+                Events = factory.CreateLogger("Events");
+            }
         }
         public static ILogger Configuration
         {

BTCPayServer.Common/MultiValueDictionary.cs

@@ -1111,4 +1111,17 @@ namespace BTCPayServer
             #endregion
         }
     }
+
+    public static class MultiValueDictionaryExtensions
+    {
+        public static MultiValueDictionary<TKey, TValue> ToMultiValueDictionary<TInput, TKey, TValue>(this IEnumerable<TInput> collection, Func<TInput, TKey> keySelector, Func<TInput, TValue> valueSelector)
+        {
+            var dictionary = new MultiValueDictionary<TKey, TValue>();
+            foreach(var item in collection)
+            {
+                dictionary.Add(keySelector(item), valueSelector(item));
+            }
+            return dictionary;
+        }
+    }
 }

BTCPayServer.Common/SynchronizationContextRemover.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace BTCPayServer
+{
+    public struct SynchronizationContextRemover : INotifyCompletion
+    {
+        public bool IsCompleted => SynchronizationContext.Current == null;
+
+        public void OnCompleted(Action continuation)
+        {
+            var prev = SynchronizationContext.Current;
+            try
+            {
+                SynchronizationContext.SetSynchronizationContext(null);
+                continuation();
+            }
+            finally
+            {
+                SynchronizationContext.SetSynchronizationContext(prev);
+            }
+        }
+
+        public SynchronizationContextRemover GetAwaiter()
+        {
+            return this;
+        }
+
+        public void GetResult()
+        {
+        }
+    }
+}

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="../Version.csproj" Condition="Exists('../Version.csproj')" />
+  <Import Project="../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

@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Rating
+{
+    public class CurrencyPair
+    {
+        static readonly BTCPayNetworkProvider _NetworkProvider = new BTCPayNetworkProvider(NBitcoin.NetworkType.Mainnet);
+        public CurrencyPair(string left, string right)
+        {
+            if (right == null)
+                throw new ArgumentNullException(nameof(right));
+            if (left == null)
+                throw new ArgumentNullException(nameof(left));
+            Right = right.ToUpperInvariant();
+            Left = left.ToUpperInvariant();
+        }
+        public string Left { get; private set; }
+        public string Right { get; private set; }
+
+        public static CurrencyPair Parse(string str)
+        {
+            if (!TryParse(str, out var result))
+                throw new FormatException("Invalid currency pair");
+            return result;
+        }
+        public static bool TryParse(string str, out CurrencyPair value)
+        {
+            if (str == null)
+                throw new ArgumentNullException(nameof(str));
+            value = null;
+            str = str.Trim();
+            if (str.Length > 12)
+                return false;
+            var splitted = str.Split(new[] { '_', '-' }, StringSplitOptions.RemoveEmptyEntries);
+            if (splitted.Length == 2)
+            {
+                value = new CurrencyPair(splitted[0], splitted[1]);
+                return true;
+            }
+            else if (splitted.Length == 1)
+            {
+                var currencyPair = splitted[0];
+                if (currencyPair.Length < 6 || currencyPair.Length > 10)
+                    return false;
+                if (currencyPair.Length == 6)
+                { 
+                    value = new CurrencyPair(currencyPair.Substring(0,3), currencyPair.Substring(3, 3));
+                    return true;
+                }
+                for (int i = 3; i < 5; i++)
+                {
+                    var potentialCryptoName = currencyPair.Substring(0, i);
+                    var network = _NetworkProvider.GetNetwork<BTCPayNetworkBase>(potentialCryptoName);
+                    if (network != null)
+                    {
+                        value = new CurrencyPair(network.CryptoCode, currencyPair.Substring(i));
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+
+        public override bool Equals(object obj)
+        {
+            CurrencyPair item = obj as CurrencyPair;
+            if (item == null)
+                return false;
+            return ToString().Equals(item.ToString(), StringComparison.OrdinalIgnoreCase);
+        }
+        public static bool operator ==(CurrencyPair a, CurrencyPair b)
+        {
+            if (System.Object.ReferenceEquals(a, b))
+                return true;
+            if (((object)a == null) || ((object)b == null))
+                return false;
+            return a.ToString() == b.ToString();
+        }
+
+        public static bool operator !=(CurrencyPair a, CurrencyPair b)
+        {
+            return !(a == b);
+        }
+
+        public override int GetHashCode()
+        {
+            return ToString().GetHashCode(StringComparison.OrdinalIgnoreCase);
+        }
+        public override string ToString()
+        {
+            return $"{Left}_{Right}";
+        }
+
+        public CurrencyPair Inverse()
+        {
+            return new CurrencyPair(Right, Left);
+        }
+    }
+}

BTCPayServer.Rating/ExchangeRates.cs

@@ -0,0 +1,245 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Rating
+{
+    public class ExchangeRates : IEnumerable<ExchangeRate>
+    {
+        Dictionary<string, ExchangeRate> _AllRates = new Dictionary<string, ExchangeRate>();
+        public ExchangeRates()
+        {
+
+        }
+        public ExchangeRates(IEnumerable<ExchangeRate> rates)
+        {
+            foreach (var rate in rates)
+            {
+                Add(rate);
+            }
+        }
+        List<ExchangeRate> _Rates = new List<ExchangeRate>();
+        public MultiValueDictionary<string, ExchangeRate> ByExchange
+        {
+            get;
+            private set;
+        } = new MultiValueDictionary<string, ExchangeRate>();
+
+        public void Add(ExchangeRate rate)
+        {
+            // 1 DOGE is always 1 DOGE
+            if (rate.CurrencyPair.Left == rate.CurrencyPair.Right)
+                return;
+            var key = $"({rate.Exchange}) {rate.CurrencyPair}";
+            if (_AllRates.TryAdd(key, rate))
+            {
+                _Rates.Add(rate);
+                ByExchange.Add(rate.Exchange, rate);
+            }
+            else
+            {
+                if (rate.BidAsk != null)
+                {
+                    _AllRates[key].BidAsk = rate.BidAsk;
+                }
+            }
+        }
+
+        public IEnumerator<ExchangeRate> GetEnumerator()
+        {
+            return _Rates.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        public void SetRate(string exchangeName, CurrencyPair currencyPair, BidAsk bidAsk)
+        {
+            if (ByExchange.TryGetValue(exchangeName, out var rates))
+            {
+                var rate = rates.FirstOrDefault(r => r.CurrencyPair == currencyPair);
+                if(rate != null)
+                {
+                    rate.BidAsk = bidAsk;
+                }
+                var invPair = currencyPair.Inverse();
+                var invRate = rates.FirstOrDefault(r => r.CurrencyPair == invPair);
+                if (invRate != null)
+                {
+                    invRate.BidAsk = bidAsk?.Inverse();
+                }
+            }
+        }
+        public BidAsk GetRate(string exchangeName, CurrencyPair currencyPair)
+        {
+            if (currencyPair.Left == currencyPair.Right)
+                return BidAsk.One;
+            if (ByExchange.TryGetValue(exchangeName, out var rates))
+            {
+                var rate = rates.FirstOrDefault(r => r.CurrencyPair == currencyPair);
+                if (rate != null)
+                    return rate.BidAsk;
+            }
+            return null;
+        }
+    }
+    public class BidAsk
+    {
+
+        private readonly static BidAsk _One = new BidAsk(1.0m);
+        public static BidAsk One
+        {
+            get
+            {
+                return _One;
+            }
+        }
+
+        private readonly static BidAsk _Zero = new BidAsk(0.0m);
+        public static BidAsk Zero
+        {
+            get
+            {
+                return _Zero;
+            }
+        }
+        public BidAsk(decimal bid, decimal ask)
+        {
+            if (bid > ask)
+                throw new ArgumentException("the bid should be lower than ask", nameof(bid));
+            _Ask = ask;
+            _Bid = bid;
+        }
+        public BidAsk(decimal v) : this(v, v)
+        {
+
+        }
+
+        private readonly decimal _Bid;
+        public decimal Bid
+        {
+            get
+            {
+                return _Bid;
+            }
+        }
+
+
+        private readonly decimal _Ask;
+        public decimal Ask
+        {
+            get
+            {
+                return _Ask;
+            }
+        }
+
+        public decimal Center => (Ask + Bid) / 2.0m;
+
+        public BidAsk Inverse()
+        {
+            return new BidAsk(1.0m / Ask, 1.0m / Bid);
+        }
+
+        public static BidAsk operator +(BidAsk a, BidAsk b)
+        {
+            return new BidAsk(a.Bid + b.Bid, a.Ask + b.Ask);
+        }
+
+        public static BidAsk operator +(BidAsk a)
+        {
+            return new BidAsk(a.Bid, a.Ask);
+        }
+
+        public static BidAsk operator -(BidAsk a)
+        {
+            return new BidAsk(-a.Bid, -a.Ask);
+        }
+
+        public static BidAsk operator *(BidAsk a, BidAsk b)
+        {
+            return new BidAsk(a.Bid * b.Bid, a.Ask * b.Ask);
+        }
+
+        public static BidAsk operator /(BidAsk a, BidAsk b)
+        {
+            // This one is tricky.
+            // BTC_EUR = (6000, 6100)
+            // Implicit rule give
+            // EUR_BTC = 1 / BTC_EUR
+            // Or
+            // EUR_BTC = (1, 1) / BTC_EUR
+            // Naive calculation would give us ( 1/6000, 1/6100) = (0.000166, 0.000163)
+            // However, this is an invalid BidAsk!!! because 0.000166 > 0.000163
+            // So instead, we need to calculate (1/6100, 1/6000)
+            return new BidAsk(a.Bid / b.Ask, a.Ask / b.Bid);
+        }
+
+        public static BidAsk operator -(BidAsk a, BidAsk b)
+        {
+            return new BidAsk(a.Bid - b.Bid, a.Ask - b.Ask);
+        }
+
+
+        public override bool Equals(object obj)
+        {
+            BidAsk item = obj as BidAsk;
+            if (item == null)
+                return false;
+            return Bid == item.Bid && Ask == item.Ask;
+        }
+        public static bool operator ==(BidAsk a, BidAsk b)
+        {
+            if (System.Object.ReferenceEquals(a, b))
+                return true;
+            if (((object)a == null) || ((object)b == null))
+                return false;
+            return a.Bid == b.Bid && a.Ask == b.Ask;
+        }
+
+        public static bool operator !=(BidAsk a, BidAsk b)
+        {
+            return !(a == b);
+        }
+
+        public override int GetHashCode()
+        {
+            return ToString().GetHashCode(StringComparison.InvariantCulture);
+        }
+
+        public override string ToString()
+        {
+            if (Bid == Ask)
+                return Bid.ToString(CultureInfo.InvariantCulture);
+            return $"({Bid.ToString(CultureInfo.InvariantCulture)} , {Ask.ToString(CultureInfo.InvariantCulture)})";
+        }
+    }
+    public class ExchangeRate
+    {
+        public ExchangeRate()
+        {
+
+        }
+        public ExchangeRate(string exchange, CurrencyPair currencyPair, BidAsk bidAsk)
+        {
+            this.Exchange = exchange;
+            this.CurrencyPair = currencyPair;
+            this.BidAsk = bidAsk;
+        }
+        public string Exchange { get; set; }
+        public CurrencyPair CurrencyPair { get; set; }
+        public BidAsk BidAsk { get; set; }
+
+        public override string ToString()
+        {
+            if (BidAsk == null)
+                return $"{Exchange}({CurrencyPair})";
+            return $"{Exchange}({CurrencyPair}) == {BidAsk.ToString()}";
+        }
+    }
+}

BTCPayServer.Rating/Providers/BackgroundFetcherRateProvider.cs

@@ -0,0 +1,170 @@
+using System;
+using Microsoft.Extensions.Logging;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.ExceptionServices;
+using System.Threading.Tasks;
+using BTCPayServer.Rating;
+using System.Threading;
+using Microsoft.Extensions.Logging.Abstractions;
+using BTCPayServer.Logging;
+
+namespace BTCPayServer.Services.Rates
+{
+    public class BackgroundFetcherRateProvider : IRateProvider
+    {
+        public class LatestFetch
+        {
+            public ExchangeRates Latest;
+            public DateTimeOffset NextRefresh;
+            public TimeSpan Backoff = TimeSpan.FromSeconds(5.0); 
+            public DateTimeOffset Expiration;
+            public Exception Exception;
+            public string ExchangeName;
+            internal ExchangeRates GetResult()
+            {
+                if (Expiration <= DateTimeOffset.UtcNow)
+                {
+                    if (Exception != null)
+                    {
+                        ExceptionDispatchInfo.Capture(Exception).Throw();
+                    }
+                    else
+                    {
+                        throw new InvalidOperationException($"The rate has expired ({ExchangeName})");
+                    }
+                }
+                return Latest;
+            }
+        }
+
+        IRateProvider _Inner;
+
+        public BackgroundFetcherRateProvider(IRateProvider inner)
+        {
+            if (inner == null)
+                throw new ArgumentNullException(nameof(inner));
+            _Inner = inner;
+        }
+
+        TimeSpan _RefreshRate = TimeSpan.FromSeconds(30);
+        public TimeSpan RefreshRate
+        {
+            get
+            {
+                return _RefreshRate;
+            }
+            set
+            {
+                var diff = value - _RefreshRate;
+                var latest = _Latest;
+                if (latest != null)
+                    latest.NextRefresh += diff;
+                _RefreshRate = value;
+            }
+        }
+
+        TimeSpan _ValidatyTime = TimeSpan.FromMinutes(10);
+        public TimeSpan ValidatyTime
+        {
+            get
+            {
+                return _ValidatyTime;
+            }
+            set
+            {
+                var diff = value - _ValidatyTime;
+                var latest = _Latest;
+                if (latest != null)
+                    latest.Expiration += diff;
+                _ValidatyTime = value;
+            }
+        }
+
+        public DateTimeOffset NextUpdate
+        {
+            get
+            {
+                var latest = _Latest;
+                if (latest == null)
+                    return DateTimeOffset.UtcNow;
+                return latest.NextRefresh;
+            }
+        }
+
+        public bool DoNotAutoFetchIfExpired { get; set; }
+        readonly static TimeSpan MaxBackoff = TimeSpan.FromMinutes(5.0);
+
+        public async Task<LatestFetch> UpdateIfNecessary(CancellationToken cancellationToken)
+        {
+            if (NextUpdate <= DateTimeOffset.UtcNow)
+            {
+                try
+                {
+                    await Fetch(cancellationToken);
+                }
+                catch { } // Exception is inside _Latest
+                return _Latest;
+            }
+            return _Latest;
+        }
+
+        LatestFetch _Latest;
+        public async Task<ExchangeRates> GetRatesAsync(CancellationToken cancellationToken)
+        {
+            var latest = _Latest;
+            if (!DoNotAutoFetchIfExpired && latest != null && latest.Expiration <= DateTimeOffset.UtcNow + TimeSpan.FromSeconds(1.0))
+            {
+                Logs.PayServer.LogWarning($"GetRatesAsync was called on {GetExchangeName()} when the rate is outdated. It should never happen, let BTCPayServer developers know about this.");
+                latest = null;
+            }
+            return (latest ?? (await Fetch(cancellationToken))).GetResult();
+        }
+
+        private string GetExchangeName()
+        {
+            if (_Inner is IHasExchangeName exchangeName)
+                return exchangeName.ExchangeName ?? "???";
+            return "???";
+        }
+
+        private async Task<LatestFetch> Fetch(CancellationToken cancellationToken)
+        {
+            var previous = _Latest;
+            var fetch = new LatestFetch();
+            fetch.ExchangeName = GetExchangeName();
+            try
+            {
+                var rates = await _Inner.GetRatesAsync(cancellationToken);
+                fetch.Latest = rates;
+                fetch.Expiration = DateTimeOffset.UtcNow + ValidatyTime;
+                fetch.NextRefresh = DateTimeOffset.UtcNow + RefreshRate;
+            }
+            catch (Exception ex)
+            {
+                if (previous != null)
+                {
+                    fetch.Latest = previous.Latest;
+                    fetch.Expiration = previous.Expiration;
+                    fetch.Backoff = previous.Backoff * 2;
+                    if (fetch.Backoff > MaxBackoff)
+                        fetch.Backoff = MaxBackoff;
+                }
+                else
+                {
+                    fetch.Expiration = DateTimeOffset.UtcNow;
+                }
+                fetch.NextRefresh = DateTimeOffset.UtcNow + fetch.Backoff;
+                fetch.Exception = ex;
+            }
+            _Latest = fetch;
+            fetch.GetResult(); // Will throw if not valid
+            return fetch;
+        }
+
+        public void InvalidateCache()
+        {
+            _Latest = null;
+        }
+    }
+}

BTCPayServer.Rating/Providers/BitbankRateProvider.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Rating;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Services.Rates
+{
+    public class BitbankRateProvider : IRateProvider, IHasExchangeName
+    {
+        private readonly HttpClient _httpClient;
+        public BitbankRateProvider(HttpClient httpClient)
+        {
+            _httpClient = httpClient ?? new HttpClient();
+        }
+        public string ExchangeName => "bitbank";
+
+        public async Task<ExchangeRates> GetRatesAsync(CancellationToken cancellationToken)
+        {
+            var response = await _httpClient.GetAsync("https://public.bitbank.cc/prices", cancellationToken);
+            var jobj = await response.Content.ReadAsAsync<JObject>(cancellationToken);
+            return new ExchangeRates(((jobj["data"] as JObject) ?? new JObject())
+                .Properties()
+                .Select(p => new ExchangeRate(ExchangeName, CurrencyPair.Parse(p.Name), CreateBidAsk(p)))
+                .ToArray());
+
+        }
+
+        private static BidAsk CreateBidAsk(JProperty p)
+        {
+            var buy = p.Value["buy"].Value<decimal>();
+            var sell = p.Value["sell"].Value<decimal>();
+            // Bug from their API (https://github.com/btcpayserver/btcpayserver/issues/741)
+            return buy < sell ? new BidAsk(buy, sell) : new BidAsk(sell, buy);
+        }
+    }
+}

BTCPayServer.Rating/Providers/BitpayRateProvider.cs

@@ -0,0 +1,33 @@
+using NBitpayClient;
+using System.Linq;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using BTCPayServer.Rating;
+using System.Threading;
+
+namespace BTCPayServer.Services.Rates
+{
+    public class BitpayRateProvider : IRateProvider, IHasExchangeName
+    {
+        public const string BitpayName = "bitpay";
+        Bitpay _Bitpay;
+        public BitpayRateProvider(Bitpay bitpay)
+        {
+            if (bitpay == null)
+                throw new ArgumentNullException(nameof(bitpay));
+            _Bitpay = bitpay;
+        }
+
+        public string ExchangeName => BitpayName;
+
+        public async Task<ExchangeRates> GetRatesAsync(CancellationToken cancellationToken)
+        {
+            return new ExchangeRates((await _Bitpay.GetRatesAsync().ConfigureAwait(false))
+                .AllRates
+                .Select(r => new ExchangeRate() { Exchange = BitpayName, CurrencyPair = new CurrencyPair("BTC", r.Code), BidAsk = new BidAsk(r.Value) })
+                .ToList());
+        }
+    }
+}

BTCPayServer.Rating/Providers/ByllsRateProvider.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Rating;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Services.Rates
+{
+    public class ByllsRateProvider : IRateProvider, IHasExchangeName
+    {
+        private readonly HttpClient _httpClient;
+        public ByllsRateProvider(HttpClient httpClient)
+        {
+            _httpClient = httpClient ?? new HttpClient();
+        }
+        public string ExchangeName => "bylls";
+
+        public async Task<ExchangeRates> GetRatesAsync(CancellationToken cancellationToken)
+        {
+            var response = await _httpClient.GetAsync("https://bylls.com/api/price?from_currency=BTC&to_currency=CAD", cancellationToken);
+            var jobj = await response.Content.ReadAsAsync<JObject>(cancellationToken);
+            var value = jobj["public_price"]["to_price"].Value<decimal>();
+            return new ExchangeRates(new[] { new ExchangeRate(ExchangeName, new CurrencyPair("BTC", "CAD"), new BidAsk(value)) });
+        }
+    }
+}

BTCPayServer.Rating/Providers/CachedRateProvider.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Rating;
+using BTCPayServer.Services.Rates;
+using Microsoft.Extensions.Caching.Memory;
+
+namespace BTCPayServer.Services.Rates
+{
+    public class CachedRateProvider : IRateProvider, IHasExchangeName
+    {
+        private IRateProvider _Inner;
+        private IMemoryCache _MemoryCache;
+
+        public CachedRateProvider(string exchangeName, IRateProvider inner, IMemoryCache memoryCache)
+        {
+            if (inner == null)
+                throw new ArgumentNullException(nameof(inner));
+            if (memoryCache == null)
+                throw new ArgumentNullException(nameof(memoryCache));
+            this._Inner = inner;
+            this.MemoryCache = memoryCache;
+            this.ExchangeName = exchangeName;
+        }
+
+        public IRateProvider Inner
+        {
+            get
+            {
+                return _Inner;
+            }
+        }
+
+        public string ExchangeName { get; }
+
+        public TimeSpan CacheSpan
+        {
+            get;
+            set;
+        } = TimeSpan.FromMinutes(1.0);
+        public IMemoryCache MemoryCache { get => _MemoryCache; set => _MemoryCache = value; }
+        
+        public Task<ExchangeRates> GetRatesAsync(CancellationToken cancellationToken)
+        {
+            return MemoryCache.GetOrCreateAsync("EXCHANGE_RATES_" + ExchangeName, (ICacheEntry entry) =>
+            {
+                entry.AbsoluteExpiration = DateTimeOffset.UtcNow + CacheSpan;
+                return _Inner.GetRatesAsync(cancellationToken);
+            });
+        }
+    }
+}

BTCPayServer.Rating/Providers/CoinAverageRateProvider.cs

@@ -0,0 +1,238 @@
+using Newtonsoft.Json;
+using Microsoft.Extensions.DependencyInjection;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Net.Http;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading.Tasks;
+using System.ComponentModel;
+using BTCPayServer.Rating;
+using System.Threading;
+
+namespace BTCPayServer.Services.Rates
+{
+    public class CoinAverageException : Exception
+    {
+        public CoinAverageException(string message) : base(message)
+        {
+
+        }
+    }
+
+    public class GetExchangeTickersResponse
+    {
+        public class Exchange
+        {
+            public string Name { get; set; }
+            [JsonProperty("display_name")]
+            public string DisplayName { get; set; }
+            public string[] Symbols { get; set; }
+        }
+        public bool Success { get; set; }
+        public Exchange[] Exchanges { get; set; }
+    }
+
+    public class RatesSetting
+    {
+        public string PublicKey { get; set; }
+        public string PrivateKey { get; set; }
+        [DefaultValue(15)]
+        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Populate)]
+        public int CacheInMinutes { get; set; } = 15;
+    }
+
+    public interface ICoinAverageAuthenticator
+    {
+        Task AddHeader(HttpRequestMessage message);
+    }
+
+    public class CoinAverageRateProvider : IRateProvider, IHasExchangeName
+    {
+        public const string CoinAverageName = "coinaverage";
+        public CoinAverageRateProvider()
+        {
+
+        }
+
+        public HttpClient HttpClient
+        {
+            get
+            {
+                return _LocalClient ?? _Client;
+            }
+            set
+            {
+                _LocalClient = value;
+            }
+        }
+        HttpClient _LocalClient;
+        static HttpClient _Client = new HttpClient();
+
+        public string Exchange { get; set; } = CoinAverageName;
+
+        public string CryptoCode { get; set; }
+
+        public string Market
+        {
+            get; set;
+        } = "global";
+
+        public ICoinAverageAuthenticator Authenticator { get; set; }
+
+        public string ExchangeName => Exchange ?? CoinAverageName;
+
+        private bool TryToBidAsk(JProperty p, out BidAsk bidAsk)
+        {
+            bidAsk = null;
+            if (Exchange == CoinAverageName)
+            {
+                JToken last = p.Value["last"];
+                if (!decimal.TryParse(last.Value<string>(), System.Globalization.NumberStyles.AllowExponent | System.Globalization.NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var v) ||
+                    v <= 0)
+                    return false;
+                bidAsk = new BidAsk(v);
+                return true;
+            }
+            else
+            {
+                JToken bid = p.Value["bid"];
+                JToken ask = p.Value["ask"];
+                if (bid == null || ask == null ||
+                    !decimal.TryParse(bid.Value<string>(), System.Globalization.NumberStyles.AllowExponent | System.Globalization.NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var v1) ||
+                    !decimal.TryParse(ask.Value<string>(), System.Globalization.NumberStyles.AllowExponent | System.Globalization.NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var v2) ||
+                    v1 > v2 ||
+                    v1 <= 0 || v2 <= 0)
+                    return false;
+                bidAsk = new BidAsk(v1, v2);
+                return true;
+            }
+        }
+
+        public async Task<ExchangeRates> GetRatesAsync(CancellationToken cancellationToken)
+        {
+            string url = Exchange == CoinAverageName ? $"https://apiv2.bitcoinaverage.com/indices/{Market}/ticker/short"
+                                         : $"https://apiv2.bitcoinaverage.com/exchanges/{Exchange}";
+
+            var request = new HttpRequestMessage(HttpMethod.Get, url);
+            var auth = Authenticator;
+            if (auth != null)
+            {
+                await auth.AddHeader(request);
+            }
+            var resp = await HttpClient.SendAsync(request, cancellationToken);
+            using (resp)
+            {
+
+                if ((int)resp.StatusCode == 401)
+                    throw new CoinAverageException("Unauthorized access to the API");
+                if ((int)resp.StatusCode == 429)
+                    throw new CoinAverageException("Exceed API limits");
+                if ((int)resp.StatusCode == 403)
+                    throw new CoinAverageException("Unauthorized access to the API, premium plan needed");
+                resp.EnsureSuccessStatusCode();
+                var rates = JObject.Parse(await resp.Content.ReadAsStringAsync());
+                if (Exchange != CoinAverageName)
+                {
+                    rates = (JObject)rates["symbols"];
+                }
+
+                var exchangeRates = new ExchangeRates();
+                foreach (var prop in rates.Properties())
+                {
+                    ExchangeRate exchangeRate = new ExchangeRate();
+                    exchangeRate.Exchange = Exchange;
+                    if (!TryToBidAsk(prop, out var value))
+                        continue;
+                    exchangeRate.BidAsk = value;
+                    if (CurrencyPair.TryParse(prop.Name, out var pair))
+                    {
+                        exchangeRate.CurrencyPair = pair;
+                        exchangeRates.Add(exchangeRate);
+                    }
+                }
+                return exchangeRates;
+            }
+        }
+
+        public async Task TestAuthAsync()
+        {
+            var request = new HttpRequestMessage(HttpMethod.Get, "https://apiv2.bitcoinaverage.com/blockchain/tx_price/BTCUSD/8a3b4394ba811a9e2b0bbf3cc56888d053ea21909299b2703cdc35e156c860ff");
+            var auth = Authenticator;
+            if (auth != null)
+            {
+                await auth.AddHeader(request);
+            }
+            var resp = await HttpClient.SendAsync(request);
+            resp.EnsureSuccessStatusCode();
+        }
+
+        public async Task<GetRateLimitsResponse> GetRateLimitsAsync()
+        {
+            var request = new HttpRequestMessage(HttpMethod.Get, "https://apiv2.bitcoinaverage.com/info/ratelimits");
+            var auth = Authenticator;
+            if (auth != null)
+            {
+                await auth.AddHeader(request);
+            }
+            var resp = await HttpClient.SendAsync(request);
+            resp.EnsureSuccessStatusCode();
+            var jobj = JObject.Parse(await resp.Content.ReadAsStringAsync());
+            var response = new GetRateLimitsResponse();
+            response.CounterReset = TimeSpan.FromSeconds(jobj["counter_reset"].Value<int>());
+            var totalPeriod = jobj["total_period"].Value<string>();
+            if (totalPeriod == "24h")
+            {
+                response.TotalPeriod = TimeSpan.FromHours(24);
+            }
+            else if (totalPeriod == "30d")
+            {
+                response.TotalPeriod = TimeSpan.FromDays(30);
+            }
+            else
+            {
+                response.TotalPeriod = TimeSpan.FromSeconds(jobj["total_period"].Value<int>());
+            }
+            response.RequestsLeft = jobj["requests_left"].Value<int>();
+            response.RequestsPerPeriod = jobj["requests_per_period"].Value<int>();
+            return response;
+        }
+
+        public async Task<GetExchangeTickersResponse> GetExchangeTickersAsync()
+        {
+            var request = new HttpRequestMessage(HttpMethod.Get, "https://apiv2.bitcoinaverage.com/symbols/exchanges/ticker");
+            var auth = Authenticator;
+            if (auth != null)
+            {
+                await auth.AddHeader(request);
+            }
+            var resp = await HttpClient.SendAsync(request);
+            resp.EnsureSuccessStatusCode();
+            var jobj = JObject.Parse(await resp.Content.ReadAsStringAsync());
+            var response = new GetExchangeTickersResponse();
+            response.Success = jobj["success"].Value<bool>();
+            var exchanges = (JObject)jobj["exchanges"];
+            response.Exchanges = exchanges
+                .Properties()
+                .Select(p =>
+                {
+                    var exchange = JsonConvert.DeserializeObject<GetExchangeTickersResponse.Exchange>(p.Value.ToString());
+                    exchange.Name = p.Name;
+                    return exchange;
+                })
+                .ToArray();
+            return response;
+        }
+    }
+
+    public class GetRateLimitsResponse
+    {
+        public TimeSpan CounterReset { get; set; }
+        public int RequestsLeft { get; set; }
+        public int RequestsPerPeriod { get; set; }
+        public TimeSpan TotalPeriod { get; set; }
+    }
+}

BTCPayServer.Rating/Providers/CoinAverageSettings.cs

@@ -0,0 +1,154 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Services.Rates
+{
+    public class CoinAverageSettingsAuthenticator : ICoinAverageAuthenticator
+    {
+        CoinAverageSettings _Settings;
+        public CoinAverageSettingsAuthenticator(CoinAverageSettings settings)
+        {
+            _Settings = settings;
+        }
+        public Task AddHeader(HttpRequestMessage message)
+        {
+            return _Settings.AddHeader(message);
+        }
+    }
+
+    public class CoinAverageExchange
+    {
+        public CoinAverageExchange(string name, string display, string url)
+        {
+            Name = name;
+            Display = display;
+            Url = url;
+        }
+        public string Name { get; set; }
+        public string Display { get; set; }
+        public string Url
+        {
+            get;
+            set;
+        }
+    }
+    public class CoinAverageExchanges : Dictionary<string, CoinAverageExchange>
+    {
+        public CoinAverageExchanges()
+        {
+        }
+
+        public void Add(CoinAverageExchange exchange)
+        {
+            if (!TryAdd(exchange.Name, exchange))
+            {
+                this.Remove(exchange.Name);
+                this.Add(exchange.Name, exchange);
+            }
+        }
+    }
+    public class CoinAverageSettings : ICoinAverageAuthenticator
+    {
+        private static readonly DateTime _epochUtc = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+
+        public (String PublicKey, String PrivateKey)? KeyPair { get; set; }
+        public CoinAverageExchanges AvailableExchanges { get; set; } = new CoinAverageExchanges();
+
+        public CoinAverageSettings()
+        {
+            //GENERATED BY:
+            //StringBuilder b = new StringBuilder();
+            //b.AppendLine("_coinAverageSettings.AvailableExchanges = new[] {");
+            //foreach (var availableExchange in _coinAverageSettings.AvailableExchanges)
+            //{
+            //    b.AppendLine($"(DisplayName: \"{availableExchange.DisplayName}\", Name: \"{availableExchange.Name}\"),");
+            //}
+            //b.AppendLine("}.ToArray()");
+            AvailableExchanges = new CoinAverageExchanges();
+            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: "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: "BTC Markets", Name: "btcmarkets"),
+                (DisplayName: "Bitso", Name: "bitso"),
+                })
+            {
+                AvailableExchanges.TryAdd(item.Name, new CoinAverageExchange(item.Name, item.DisplayName, $"https://apiv2.bitcoinaverage.com/exchanges/{item.Name}"));
+            }
+        }
+
+        public Task AddHeader(HttpRequestMessage message)
+        {
+            var signature = GetCoinAverageSignature();
+            if (signature != null)
+            {
+                message.Headers.Add("X-signature", signature);
+            }
+            return Task.CompletedTask;
+        }
+
+        public string GetCoinAverageSignature()
+        {
+            var keyPair = KeyPair;
+            if (!keyPair.HasValue)
+                return null;
+            if (string.IsNullOrEmpty(keyPair.Value.PublicKey) || string.IsNullOrEmpty(keyPair.Value.PrivateKey))
+                return null;
+            var timestamp = (int)((DateTime.UtcNow - _epochUtc).TotalSeconds);
+            var payload = timestamp + "." + keyPair.Value.PublicKey;
+            var digestValueBytes = new HMACSHA256(Encoding.ASCII.GetBytes(keyPair.Value.PrivateKey)).ComputeHash(Encoding.ASCII.GetBytes(payload));
+            var digestValueHex = NBitcoin.DataEncoders.Encoders.Hex.EncodeData(digestValueBytes);
+            return payload + "." + digestValueHex;
+        }
+    }
+}

BTCPayServer.Rating/Providers/ExchangeSharpRateProvider.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Rating;
+using ExchangeSharp;
+
+namespace BTCPayServer.Services.Rates
+{
+    public class ExchangeSharpRateProvider : IRateProvider, IHasExchangeName
+    {
+        readonly ExchangeAPI _ExchangeAPI;
+        readonly string _ExchangeName;
+        public ExchangeSharpRateProvider(string exchangeName, ExchangeAPI exchangeAPI, bool reverseCurrencyPair = false)
+        {
+            if (exchangeAPI == null)
+                throw new ArgumentNullException(nameof(exchangeAPI));
+            exchangeAPI.RequestTimeout = TimeSpan.FromSeconds(5.0);
+            _ExchangeAPI = exchangeAPI;
+            _ExchangeName = exchangeName;
+            ReverseCurrencyPair = reverseCurrencyPair;
+        }
+
+        public bool ReverseCurrencyPair
+        {
+            get; set;
+        }
+
+        public string ExchangeName => _ExchangeName;
+
+        public async Task<ExchangeRates> GetRatesAsync(CancellationToken cancellationToken)
+        {
+            await new SynchronizationContextRemover();
+            var rates = await _ExchangeAPI.GetTickersAsync();
+            lock (notFoundSymbols)
+            {
+                var exchangeRates =
+                    rates
+                    .Where(t => t.Value.Ask != 0m && t.Value.Bid != 0m)
+                    .Select(t => CreateExchangeRate(t))
+                    .Where(t => t != null)
+                    .ToArray();
+                return new ExchangeRates(exchangeRates);
+            }
+        }
+
+        // ExchangeSymbolToGlobalSymbol throws exception which would kill perf
+        ConcurrentDictionary<string, string> notFoundSymbols = new ConcurrentDictionary<string, string>();
+        private ExchangeRate CreateExchangeRate(KeyValuePair<string, ExchangeTicker> ticker)
+        {
+            if (notFoundSymbols.ContainsKey(ticker.Key))
+                return null;
+            try
+            {
+                var tickerName = _ExchangeAPI.ExchangeSymbolToGlobalSymbol(ticker.Key);
+                if (!CurrencyPair.TryParse(tickerName, out var pair))
+                {
+                    notFoundSymbols.TryAdd(ticker.Key, ticker.Key);
+                    return null;
+                }
+                if(ReverseCurrencyPair)
+                    pair = new CurrencyPair(pair.Right, pair.Left);
+                var rate = new ExchangeRate();
+                rate.CurrencyPair = pair;
+                rate.Exchange = _ExchangeName;
+                rate.BidAsk = new BidAsk(ticker.Value.Bid, ticker.Value.Ask);
+                return rate;
+            }
+            catch (ArgumentException)
+            {
+                notFoundSymbols.TryAdd(ticker.Key, ticker.Key);
+                return null;
+            }
+        }
+    }
+}

BTCPayServer.Rating/Providers/FallbackRateProvider.cs

@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
+using BTCPayServer.Rating;
 
 namespace BTCPayServer.Services.Rates
 {
@@ -14,30 +16,24 @@ namespace BTCPayServer.Services.Rates
                 throw new ArgumentNullException(nameof(providers));
             _Providers = providers;
         }
-        public async Task<decimal> GetRateAsync(string currency)
-        {
-            foreach(var p in _Providers)
-            {
-                try
-                {
-                    return await p.GetRateAsync(currency).ConfigureAwait(false);
-                }
-                catch { }
-            }
-            throw new RateUnavailableException(currency);
-        }
 
-        public async Task<ICollection<Rate>> GetRatesAsync()
+        public async Task<ExchangeRates> GetRatesAsync(CancellationToken cancellationToken)
         {
             foreach (var p in _Providers)
             {
                 try
                 {
-                    return await p.GetRatesAsync().ConfigureAwait(false);
+                    return await p.GetRatesAsync(cancellationToken).ConfigureAwait(false);
                 }
-                catch { }
+                catch when (cancellationToken.IsCancellationRequested)
+                {
+                    throw;
+                }
+                catch(Exception ex) { Exceptions.Add(ex); }
             }
-            throw new RateUnavailableException("ALL");
+            return new ExchangeRates();
         }
+
+        public List<Exception> Exceptions { get; set; } = new List<Exception>();
     }
 }

BTCPayServer.Rating/Providers/IHasExchangeName.cs

@@ -5,8 +5,8 @@ using System.Threading.Tasks;
 
 namespace BTCPayServer.Services.Rates
 {
-    public interface IRateProviderFactory
+    public interface IHasExchangeName
     {
-        IRateProvider GetRateProvider(BTCPayNetwork network, bool longCache);
+        string ExchangeName { get; }
     }
 }

BTCPayServer.Rating/Providers/IRateProvider.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Rating;
+
+namespace BTCPayServer.Services.Rates
+{
+    public interface IRateProvider
+    {
+        Task<ExchangeRates> GetRatesAsync(CancellationToken cancellationToken);
+    }
+}

BTCPayServer.Rating/Providers/KrakenExchangeRateProvider.cs

@@ -0,0 +1,195 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Rating;
+using ExchangeSharp;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Services.Rates
+{
+    // Make sure that only one request is sent to kraken in general
+    public class KrakenExchangeRateProvider : IRateProvider, IHasExchangeName
+    {
+        public KrakenExchangeRateProvider()
+        {
+            _Helper = new ExchangeKrakenAPI();
+        }
+        ExchangeKrakenAPI _Helper;
+        public HttpClient HttpClient
+        {
+            get
+            {
+                return _LocalClient ?? _Client;
+            }
+            set
+            {
+                _LocalClient = value;
+            }
+        }
+
+        public string ExchangeName => "kraken";
+
+        HttpClient _LocalClient;
+        static HttpClient _Client = new HttpClient();
+
+        // ExchangeSymbolToGlobalSymbol throws exception which would kill perf
+        ConcurrentDictionary<string, string> notFoundSymbols = new ConcurrentDictionary<string, string>(new Dictionary<string, string>()
+        {
+            {"ADAXBT","ADAXBT"},
+            { "BSVUSD","BSVUSD"},
+            { "QTUMEUR","QTUMEUR"},
+            { "QTUMXBT","QTUMXBT"},
+            { "EOSUSD","EOSUSD"},
+            { "XTZUSD","XTZUSD"},
+            { "XREPZUSD","XREPZUSD"},
+            { "ADAEUR","ADAEUR"},
+            { "ADAUSD","ADAUSD"},
+            { "GNOEUR","GNOEUR"},
+            { "XTZETH","XTZETH"},
+            { "XXRPZJPY","XXRPZJPY"},
+            { "XXRPZCAD","XXRPZCAD"},
+            { "XTZEUR","XTZEUR"},
+            { "QTUMETH","QTUMETH"},
+            { "XXLMZUSD","XXLMZUSD"},
+            { "QTUMCAD","QTUMCAD"},
+            { "QTUMUSD","QTUMUSD"},
+            { "XTZXBT","XTZXBT"},
+            { "GNOUSD","GNOUSD"},
+            { "ADAETH","ADAETH"},
+            { "ADACAD","ADACAD"},
+            { "XTZCAD","XTZCAD"},
+            { "BSVEUR","BSVEUR"},
+            { "XZECZJPY","XZECZJPY"},
+            { "XXLMZEUR","XXLMZEUR"},
+            {"EOSEUR","EOSEUR"},
+            {"BSVXBT","BSVXBT"}
+        });
+        string[] _Symbols = Array.Empty<string>();
+        DateTimeOffset? _LastSymbolUpdate = null;
+
+
+        Dictionary<string, string> _TickerMapping = new Dictionary<string, string>()
+        {
+            { "XXDG", "DOGE" },
+            { "XXBT", "BTC" },
+            { "XBT", "BTC" },
+            { "DASH", "DASH" },
+            { "ZUSD", "USD" },
+            { "ZEUR", "EUR" },
+            { "ZJPY", "JPY" },
+            { "ZCAD", "CAD" },
+        };
+
+        public async Task<ExchangeRates> GetRatesAsync(CancellationToken cancellationToken)
+        {
+            var result = new ExchangeRates();
+            var symbols = await GetSymbolsAsync();
+            var normalizedPairsList = symbols.Where(s => !notFoundSymbols.ContainsKey(s)).Select(s => _Helper.NormalizeSymbol(s)).ToList();
+            var csvPairsList = string.Join(",", normalizedPairsList);
+            JToken apiTickers = await MakeJsonRequestAsync<JToken>("/0/public/Ticker", null, new Dictionary<string, object> { { "pair", csvPairsList } });
+            var tickers = new List<KeyValuePair<string, ExchangeTicker>>();
+            foreach (string symbol in symbols)
+            {
+                var ticker = ConvertToExchangeTicker(symbol, apiTickers[symbol]);
+                if (ticker != null)
+                {
+                    try
+                    {
+                        string global = null;
+                        var mapped1 = _TickerMapping.Where(t => symbol.StartsWith(t.Key, StringComparison.OrdinalIgnoreCase))
+                                                   .Select(t => new { KrakenTicker = t.Key, PayTicker = t.Value }).SingleOrDefault();
+                        if (mapped1 != null)
+                        {
+                            var p2 = symbol.Substring(mapped1.KrakenTicker.Length);
+                            if (_TickerMapping.TryGetValue(p2, out var mapped2))
+                                p2 = mapped2;
+                            global = $"{p2}_{mapped1.PayTicker}";
+                        }
+                        else
+                        {
+                            global = _Helper.ExchangeSymbolToGlobalSymbol(symbol);
+                        }
+                        if (CurrencyPair.TryParse(global, out var pair))
+                            result.Add(new ExchangeRate("kraken", pair.Inverse(), new BidAsk(ticker.Bid, ticker.Ask)));
+                        else
+                            notFoundSymbols.TryAdd(symbol, symbol);
+                    }
+                    catch (ArgumentException)
+                    {
+                        notFoundSymbols.TryAdd(symbol, symbol);
+                    }
+                }
+            }
+            return result;
+        }
+
+        private static ExchangeTicker ConvertToExchangeTicker(string symbol, JToken ticker)
+        {
+            if (ticker == null)
+                return null;
+            decimal last = ticker["c"][0].ConvertInvariant<decimal>();
+            return new ExchangeTicker
+            {
+                Ask = ticker["a"][0].ConvertInvariant<decimal>(),
+                Bid = ticker["b"][0].ConvertInvariant<decimal>(),
+                Last = last,
+                Volume = new ExchangeVolume
+                {
+                    BaseVolume = ticker["v"][1].ConvertInvariant<decimal>(),
+                    BaseSymbol = symbol,
+                    ConvertedVolume = ticker["v"][1].ConvertInvariant<decimal>() * last,
+                    ConvertedSymbol = symbol,
+                    Timestamp = DateTime.UtcNow
+                }
+            };
+        }
+
+        private async Task<string[]> GetSymbolsAsync()
+        {
+            if (_LastSymbolUpdate != null && DateTimeOffset.UtcNow - _LastSymbolUpdate.Value < TimeSpan.FromDays(0.5))
+            {
+                return _Symbols;
+            }
+            else
+            {
+                JToken json = await MakeJsonRequestAsync<JToken>("/0/public/AssetPairs");
+                var symbols = (from prop in json.Children<JProperty>() where !prop.Name.Contains(".d", StringComparison.OrdinalIgnoreCase) select prop.Name).ToArray();
+                _Symbols = symbols;
+                _LastSymbolUpdate = DateTimeOffset.UtcNow;
+                return symbols;
+            }
+        }
+
+        private async Task<T> MakeJsonRequestAsync<T>(string url, string baseUrl = null, Dictionary<string, object> payload = null, string requestMethod = null, CancellationToken cancellationToken = default)
+        {
+            StringBuilder sb = new StringBuilder();
+            sb.Append("https://api.kraken.com");
+            ;
+            sb.Append(url);
+            if (payload != null)
+            {
+                sb.Append("?");
+                sb.Append(String.Join('&', payload.Select(kv => $"{kv.Key}={kv.Value}").OfType<object>().ToArray()));
+            }
+            var request = new HttpRequestMessage(HttpMethod.Get, sb.ToString());
+            var response = await HttpClient.SendAsync(request, cancellationToken);
+            string stringResult = await response.Content.ReadAsStringAsync();
+            var result = JsonConvert.DeserializeObject<T>(stringResult);
+            if (result is JToken json)
+            {
+                if (!(json is JArray) && json["error"] is JArray error && error.Count != 0)
+                {
+                    throw new APIException(error[0].ToStringInvariant());
+                }
+                result = (T)(object)(json["result"] ?? json);
+            }
+            return result;
+        }
+    }
+}

BTCPayServer.Rating/Providers/NullRateProvider.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Rating;
+
+namespace BTCPayServer.Services.Rates
+{
+    public class NullRateProvider : IRateProvider
+    {
+        private NullRateProvider()
+        {
+
+        }
+        private static readonly NullRateProvider _Instance = new NullRateProvider();
+        public static NullRateProvider Instance
+        {
+            get
+            {
+                return _Instance;
+            }
+        }
+        public Task<ExchangeRates> GetRatesAsync(CancellationToken cancellationToken)
+        {
+            return Task.FromResult(new ExchangeRates());
+        }
+    }
+}

BTCPayServer.Rating/RateRules.cs

@@ -0,0 +1,590 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace BTCPayServer.Rating
+{
+    public enum RateRulesErrors
+    {
+        Ok,
+        TooMuchNestedCalls,
+        InvalidCurrencyIdentifier,
+        NestedInvocation,
+        UnsupportedOperator,
+        MissingArgument,
+        DivideByZero,
+        InvalidNegative,
+        PreprocessError,
+        RateUnavailable,
+        InvalidExchangeName,
+    }
+    public class RateRules
+    {
+        class NormalizeCurrencyPairsRewritter : CSharpSyntaxRewriter
+        {
+            public List<RateRulesErrors> Errors = new List<RateRulesErrors>();
+
+            bool IsInvocation;
+            public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node)
+            {
+                if (IsInvocation)
+                {
+                    Errors.Add(RateRulesErrors.NestedInvocation);
+                    return base.VisitInvocationExpression(node);
+                }
+                if (node.Expression is IdentifierNameSyntax id)
+                {
+                    IsInvocation = true;
+                    var arglist = (ArgumentListSyntax)this.Visit(node.ArgumentList);
+                    IsInvocation = false;
+                    return SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName(id.Identifier.ValueText.ToLowerInvariant()), arglist)
+                                        .WithTriviaFrom(id);
+                }
+                else
+                {
+                    Errors.Add(RateRulesErrors.InvalidExchangeName);
+                    return node;
+                }
+            }
+            public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node)
+            {
+                if (CurrencyPair.TryParse(node.Identifier.ValueText, out var currencyPair))
+                {
+                    return SyntaxFactory.IdentifierName(currencyPair.ToString())
+                                        .WithTriviaFrom(node);
+                }
+                else
+                {
+                    Errors.Add(RateRulesErrors.InvalidCurrencyIdentifier);
+                    return base.VisitIdentifierName(node);
+                }
+            }
+        }
+        class RuleList : CSharpSyntaxWalker
+        {
+            public Dictionary<CurrencyPair, (ExpressionSyntax Expression, SyntaxNode Trivia)> ExpressionsByPair = new Dictionary<CurrencyPair, (ExpressionSyntax Expression, SyntaxNode Trivia)>();
+            public override void VisitAssignmentExpression(AssignmentExpressionSyntax node)
+            {
+                if (node.Kind() == SyntaxKind.SimpleAssignmentExpression
+                    && node.Left is IdentifierNameSyntax id
+                    && node.Right is ExpressionSyntax expression)
+                {
+                    if (CurrencyPair.TryParse(id.Identifier.ValueText, out var currencyPair))
+                    {
+                        expression = expression.WithTriviaFrom(expression);
+                        ExpressionsByPair.TryAdd(currencyPair, (expression, id));
+                    }
+                }
+                base.VisitAssignmentExpression(node);
+            }
+
+            public SyntaxNode GetSyntaxNode()
+            {
+                return SyntaxFactory.Block(
+                        ExpressionsByPair.Select(e =>
+                                SyntaxFactory.ExpressionStatement(
+                                    SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
+                                            SyntaxFactory.IdentifierName(e.Key.ToString()).WithTriviaFrom(e.Value.Trivia),
+                                            e.Value.Expression)
+                                    ))
+                    );
+            }
+        }
+
+        SyntaxNode root;
+        RuleList ruleList;
+
+        decimal _Spread;
+        public decimal Spread
+        {
+            get
+            {
+                return _Spread;
+            }
+            set
+            {
+                if (value > 1.0m || value < 0.0m)
+                    throw new ArgumentOutOfRangeException(paramName: nameof(value), message: "The spread should be between 0 and 1");
+                _Spread = value;
+            }
+        }
+
+        RateRules(SyntaxNode root)
+        {
+            ruleList = new RuleList();
+            ruleList.Visit(root);
+            // Remove every irrelevant statements
+            this.root = ruleList.GetSyntaxNode();
+        }
+        public static bool TryParse(string str, out RateRules rules)
+        {
+            return TryParse(str, out rules, out var unused);
+        }
+        public static bool TryParse(string str, out RateRules rules, out List<RateRulesErrors> errors)
+        {
+            rules = null;
+            errors = null;
+            var expression = CSharpSyntaxTree.ParseText(str, new CSharpParseOptions(LanguageVersion.Default).WithKind(SourceCodeKind.Script));
+            var rewriter = new NormalizeCurrencyPairsRewritter();
+            // Rename BTC_usd to BTC_USD and verify structure
+            var root = rewriter.Visit(expression.GetRoot());
+            if (rewriter.Errors.Count > 0)
+            {
+                errors = rewriter.Errors;
+                return false;
+            }
+            rules = new RateRules(root);
+            return true;
+        }
+
+        public RateRule GetRuleFor(CurrencyPair currencyPair)
+        {
+            if (currencyPair.Left == "X" || currencyPair.Right == "X")
+                throw new ArgumentException(paramName: nameof(currencyPair), message: "Invalid X currency");
+            if (currencyPair.Left == currencyPair.Right)
+                return new RateRule(this, currencyPair, CreateExpression("1.0"));
+            var candidate = FindBestCandidate(currencyPair);
+            if (Spread != decimal.Zero)
+            {
+                candidate = CreateExpression($"({candidate}) * ({(1.0m - Spread).ToString(CultureInfo.InvariantCulture)}, {(1.0m + Spread).ToString(CultureInfo.InvariantCulture)})");
+            }
+            return new RateRule(this, currencyPair, candidate);
+        }
+
+        public ExpressionSyntax FindBestCandidate(CurrencyPair p)
+        {
+            var invP = p.Inverse();
+            var candidates = new List<(CurrencyPair Pair, int Prioriy, ExpressionSyntax Expression, bool Inverse)>();
+            foreach (var pair in new[]
+            {
+                (Pair: p, Priority: 0, Inverse: false),
+                (Pair: invP, Priority: 1, Inverse: true),
+                (Pair: new CurrencyPair(p.Left, "X"), Priority: 2, Inverse: false),
+                (Pair: new CurrencyPair("X", p.Right), Priority: 2, Inverse: false),
+                (Pair: new CurrencyPair(invP.Left, "X"), Priority: 3, Inverse: true),
+                (Pair: new CurrencyPair("X", invP.Right), Priority: 3, Inverse: true),
+                (Pair: new CurrencyPair("X", "X"), Priority: 4, Inverse: false)
+            })
+            {
+                if (ruleList.ExpressionsByPair.TryGetValue(pair.Pair, out var expression))
+                {
+                    candidates.Add((pair.Pair, pair.Priority, expression.Expression, pair.Inverse));
+                }
+            }
+            if (candidates.Count == 0)
+                return CreateExpression($"ERR_NO_RULE_MATCH({p})");
+            var best = candidates
+                    .OrderBy(c => c.Prioriy)
+                    .ThenBy(c => c.Expression.Span.Start)
+                    .First();
+            return best.Inverse
+                   ? CreateExpression($"1 / {invP}")
+                   : best.Expression;
+        }
+
+        internal static ExpressionSyntax CreateExpression(string str)
+        {
+            return (ExpressionSyntax)CSharpSyntaxTree.ParseText(str, new CSharpParseOptions(LanguageVersion.Default).WithKind(SourceCodeKind.Script)).GetRoot().ChildNodes().First().ChildNodes().First().ChildNodes().First();
+        }
+
+        public override string ToString()
+        {
+            return root.NormalizeWhitespace("", "\n")
+                .ToFullString()
+                .Replace("{\n", string.Empty, StringComparison.OrdinalIgnoreCase)
+                            .Replace("\n}", string.Empty, StringComparison.OrdinalIgnoreCase);
+        }
+    }
+
+    public class RateRule
+    {
+        class ReplaceExchangeRateRewriter : CSharpSyntaxRewriter
+        {
+            public List<RateRulesErrors> Errors = new List<RateRulesErrors>();
+            public ExchangeRates Rates;
+            public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node)
+            {
+                var exchangeName = node.Expression.ToString();
+                if (exchangeName.StartsWith("ERR_", StringComparison.OrdinalIgnoreCase))
+                {
+                    Errors.Add(RateRulesErrors.PreprocessError);
+                    return base.VisitInvocationExpression(node);
+                }
+
+                var currencyPair = node.ArgumentList.ChildNodes().FirstOrDefault()?.ToString();
+                if (currencyPair == null || !CurrencyPair.TryParse(currencyPair, out var pair))
+                {
+                    Errors.Add(RateRulesErrors.InvalidCurrencyIdentifier);
+                    return RateRules.CreateExpression($"ERR_INVALID_CURRENCY_PAIR({node.ToString()})");
+                }
+                else
+                {
+                    var rate = Rates.GetRate(exchangeName, pair);
+                    if (rate == null)
+                    {
+                        Errors.Add(RateRulesErrors.RateUnavailable);
+                        return RateRules.CreateExpression($"ERR_RATE_UNAVAILABLE({exchangeName}, {pair.ToString()})");
+                    }
+                    else
+                    {
+                        return RateRules.CreateExpression(rate.ToString());
+                    }
+                }
+            }
+        }
+
+        class CalculateWalker : CSharpSyntaxWalker
+        {
+            public Stack<BidAsk> Values = new Stack<BidAsk>();
+            public List<RateRulesErrors> Errors = new List<RateRulesErrors>();
+
+            public override void VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
+            {
+                base.VisitPrefixUnaryExpression(node);
+                bool invalid = false;
+                switch (node.Kind())
+                {
+                    case SyntaxKind.UnaryMinusExpression:
+                    case SyntaxKind.UnaryPlusExpression:
+                        if (Values.Count < 1)
+                        {
+                            invalid = true;
+                            Errors.Add(RateRulesErrors.MissingArgument);
+                        }
+                        break;
+                    default:
+                        invalid = true;
+                        Errors.Add(RateRulesErrors.UnsupportedOperator);
+                        break;
+                }
+
+                if (invalid)
+                    return;
+
+                switch (node.Kind())
+                {
+                    case SyntaxKind.UnaryMinusExpression:
+                        var v = Values.Pop();
+                        if (v.Bid == v.Ask)
+                        {
+                            Values.Push(-v);
+                        }
+                        else
+                        {
+                            Errors.Add(RateRulesErrors.InvalidNegative);
+                        }
+                        break;
+                    case SyntaxKind.UnaryPlusExpression:
+                        Values.Push(+Values.Pop());
+                        break;
+                    default:
+                        throw new NotSupportedException("Should never happen");
+                }
+            }
+
+            public override void VisitBinaryExpression(BinaryExpressionSyntax node)
+            {
+                base.VisitBinaryExpression(node);
+
+
+                bool invalid = false;
+                switch (node.Kind())
+                {
+                    case SyntaxKind.AddExpression:
+                    case SyntaxKind.MultiplyExpression:
+                    case SyntaxKind.DivideExpression:
+                    case SyntaxKind.SubtractExpression:
+                        if (Values.Count < 2)
+                        {
+                            invalid = true;
+                            Errors.Add(RateRulesErrors.MissingArgument);
+                        }
+                        break;
+                }
+
+                if (invalid)
+                    return;
+
+                var b = Values.Pop();
+                var a = Values.Pop();
+
+                switch (node.Kind())
+                {
+                    case SyntaxKind.AddExpression:
+                        Values.Push(a + b);
+                        break;
+                    case SyntaxKind.MultiplyExpression:
+                        Values.Push(a * b);
+                        break;
+                    case SyntaxKind.DivideExpression:
+                        if (a.Ask == decimal.Zero || b.Ask == decimal.Zero)
+                        {
+                            Errors.Add(RateRulesErrors.DivideByZero);
+                        }
+                        else
+                        {
+                            Values.Push(a / b);
+                        }
+                        break;
+                    case SyntaxKind.SubtractExpression:
+                        if (b.Bid == b.Ask)
+                        {
+                            Values.Push(a - b);
+                        }
+                        else
+                        {
+                            Errors.Add(RateRulesErrors.InvalidNegative);
+                        }
+                        break;
+                    default:
+                        throw new NotSupportedException("Should never happen");
+                }
+            }
+
+            Stack<decimal> _TupleValues = null;
+            public override void VisitTupleExpression(TupleExpressionSyntax node)
+            {
+                _TupleValues = new Stack<decimal>();
+                base.VisitTupleExpression(node);
+                if (_TupleValues.Count != 2)
+                {
+                    Errors.Add(RateRulesErrors.MissingArgument);
+                }
+                else
+                {
+                    var ask = _TupleValues.Pop();
+                    var bid = _TupleValues.Pop();
+                    Values.Push(new BidAsk(bid, ask));
+                }
+                _TupleValues = null;
+            }
+
+            public override void VisitLiteralExpression(LiteralExpressionSyntax node)
+            {
+                switch (node.Kind())
+                {
+                    case SyntaxKind.NumericLiteralExpression:
+                        var v = decimal.Parse(node.ToString(), CultureInfo.InvariantCulture);
+                        if (_TupleValues == null)
+                            Values.Push(new BidAsk(v));
+                        else
+                            _TupleValues.Push(v);
+                        break;
+                }
+            }
+        }
+
+        class HasBinaryOperations : CSharpSyntaxWalker
+        {
+            public bool Result = false;
+            public override void VisitBinaryExpression(BinaryExpressionSyntax node)
+            {
+                base.VisitBinaryExpression(node);
+                switch (node.Kind())
+                {
+                    case SyntaxKind.AddExpression:
+                    case SyntaxKind.MultiplyExpression:
+                    case SyntaxKind.DivideExpression:
+                    case SyntaxKind.MinusToken:
+                        Result = true;
+                        break;
+                }
+            }
+        }
+        class FlattenExpressionRewriter : CSharpSyntaxRewriter
+        {
+            RateRules parent;
+            CurrencyPair pair;
+            int nested = 0;
+            public FlattenExpressionRewriter(RateRules parent, CurrencyPair pair)
+            {
+                this.pair = pair;
+                this.parent = parent;
+            }
+
+            public ExchangeRates ExchangeRates = new ExchangeRates();
+            bool IsInvocation;
+            public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node)
+            {
+                if (IsInvocation)
+                {
+                    Errors.Add(RateRulesErrors.InvalidCurrencyIdentifier);
+                    return RateRules.CreateExpression($"ERR_INVALID_CURRENCY_PAIR({node.ToString()})");
+                }
+                IsInvocation = true;
+                _ExchangeName = node.Expression.ToString();
+                var result = base.VisitInvocationExpression(node);
+                IsInvocation = false;
+                return result;
+            }
+
+            bool IsArgumentList;
+            public override SyntaxNode VisitArgumentList(ArgumentListSyntax node)
+            {
+                IsArgumentList = true;
+                var result = base.VisitArgumentList(node);
+                IsArgumentList = false;
+                return result;
+            }
+
+            string _ExchangeName = null;
+
+            public List<RateRulesErrors> Errors = new List<RateRulesErrors>();
+            const int MaxNestedCount = 8;
+            public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node)
+            {
+                if (
+                    (!IsInvocation || IsArgumentList) &&
+                    CurrencyPair.TryParse(node.Identifier.ValueText, out var currentPair))
+                {
+                    var replacedPair = new CurrencyPair(left: currentPair.Left == "X" ? pair.Left : currentPair.Left,
+                                                       right: currentPair.Right == "X" ? pair.Right : currentPair.Right);
+                    if (IsInvocation) // eg. replace bittrex(BTC_X) to bittrex(BTC_USD)
+                    {
+                        ExchangeRates.Add(new ExchangeRate() { CurrencyPair = replacedPair, Exchange = _ExchangeName });
+                        return SyntaxFactory.IdentifierName(replacedPair.ToString());
+                    }
+                    else // eg. replace BTC_X to BTC_USD, then replace by the expression for BTC_USD
+                    {
+                        var bestCandidate = parent.FindBestCandidate(replacedPair);
+                        if (nested > MaxNestedCount)
+                        {
+                            Errors.Add(RateRulesErrors.TooMuchNestedCalls);
+                            return RateRules.CreateExpression($"ERR_TOO_MUCH_NESTED_CALLS({replacedPair})");
+                        }
+                        var innerFlatten = CreateNewContext(replacedPair);
+                        var replaced = innerFlatten.Visit(bestCandidate);
+                        if (replaced is ExpressionSyntax expression)
+                        {
+                            var hasBinaryOps = new HasBinaryOperations();
+                            hasBinaryOps.Visit(expression);
+                            if (hasBinaryOps.Result)
+                            {
+                                replaced = SyntaxFactory.ParenthesizedExpression(expression);
+                            }
+                        }
+                        if (Errors.Contains(RateRulesErrors.TooMuchNestedCalls))
+                        {
+                            return RateRules.CreateExpression($"ERR_TOO_MUCH_NESTED_CALLS({replacedPair})");
+                        }
+                        return replaced;
+                    }
+                }
+                return base.VisitIdentifierName(node);
+            }
+
+            private FlattenExpressionRewriter CreateNewContext(CurrencyPair pair)
+            {
+                return new FlattenExpressionRewriter(parent, pair)
+                {
+                    Errors = Errors,
+                    nested = nested + 1,
+                    ExchangeRates = ExchangeRates,
+                };
+            }
+        }
+        private SyntaxNode expression;
+        FlattenExpressionRewriter flatten;
+
+        public RateRule(RateRules parent, CurrencyPair currencyPair, SyntaxNode candidate)
+        {
+            _CurrencyPair = currencyPair;
+            flatten = new FlattenExpressionRewriter(parent, currencyPair);
+            this.expression = flatten.Visit(candidate);
+        }
+
+
+        private readonly CurrencyPair _CurrencyPair;
+        public CurrencyPair CurrencyPair
+        {
+            get
+            {
+                return _CurrencyPair;
+            }
+        }
+
+        public ExchangeRates ExchangeRates
+        {
+            get
+            {
+                return flatten.ExchangeRates;
+            }
+        }
+
+
+        public bool Reevaluate()
+        {
+            _BidAsk = null;
+            _EvaluatedNode = null;
+            _Evaluated = null;
+            Errors.Clear();
+
+            var rewriter = new ReplaceExchangeRateRewriter();
+            rewriter.Rates = ExchangeRates;
+            var result = rewriter.Visit(this.expression);
+            Errors.AddRange(rewriter.Errors);
+            _Evaluated = result.NormalizeWhitespace("", "\n").ToString();
+            if (HasError)
+                return false;
+
+            var calculate = new CalculateWalker();
+            calculate.Visit(result);
+            if (calculate.Values.Count != 1 || calculate.Errors.Count != 0)
+            {
+                Errors.AddRange(calculate.Errors);
+                return false;
+            }
+            _BidAsk = calculate.Values.Pop();
+            _EvaluatedNode = result;
+            return true;
+        }
+
+
+        private readonly HashSet<RateRulesErrors> _Errors = new HashSet<RateRulesErrors>();
+        public HashSet<RateRulesErrors> Errors
+        {
+            get
+            {
+                return _Errors;
+            }
+        }
+
+        SyntaxNode _EvaluatedNode;
+        string _Evaluated;
+        public bool HasError
+        {
+            get
+            {
+                return _Errors.Count != 0;
+            }
+        }
+
+        public string ToString(bool evaluated)
+        {
+            if (!evaluated)
+                return ToString();
+            if (_Evaluated == null)
+                return "Call Evaluate() first";
+            return _Evaluated;
+        }
+
+        public override string ToString()
+        {
+            return expression.NormalizeWhitespace("", "\n").ToString();
+        }
+
+        BidAsk _BidAsk;
+        public BidAsk BidAsk
+        {
+            get
+            {
+                return _BidAsk;
+            }
+        }
+    }
+}

BTCPayServer.Rating/Services/RateFetcher.cs

@@ -0,0 +1,95 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Rating;
+using ExchangeSharp;
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Options;
+using static BTCPayServer.Services.Rates.RateProviderFactory;
+
+namespace BTCPayServer.Services.Rates
+{
+    public class ExchangeException
+    {
+        public Exception Exception { get; set; }
+        public string ExchangeName { get; set; }
+    }
+    public class RateResult
+    {
+        public List<ExchangeException> ExchangeExceptions { get; set; } = new List<ExchangeException>();
+        public string Rule { get; set; }
+        public string EvaluatedRule { get; set; }
+        public HashSet<RateRulesErrors> Errors { get; set; }
+        public BidAsk BidAsk { get; set; }
+        public TimeSpan Latency { get; internal set; }
+    }
+
+    public class RateFetcher
+    {
+        private readonly RateProviderFactory _rateProviderFactory;
+
+        public RateFetcher(RateProviderFactory rateProviderFactory)
+        {
+            _rateProviderFactory = rateProviderFactory;
+        }
+
+        public RateProviderFactory RateProviderFactory => _rateProviderFactory;
+
+        public async Task<RateResult> FetchRate(CurrencyPair pair, RateRules rules, CancellationToken cancellationToken)
+        {
+            return await FetchRates(new HashSet<CurrencyPair>(new[] { pair }), rules, cancellationToken).First().Value;
+        }
+
+        public Dictionary<CurrencyPair, Task<RateResult>> FetchRates(HashSet<CurrencyPair> pairs, RateRules rules, CancellationToken cancellationToken)
+        {
+            if (rules == null)
+                throw new ArgumentNullException(nameof(rules));
+
+            var fetchingRates = new Dictionary<CurrencyPair, Task<RateResult>>();
+            var fetchingExchanges = new Dictionary<string, Task<QueryRateResult>>();
+            var consolidatedRates = new ExchangeRates();
+
+            foreach (var i in pairs.Select(p => (Pair: p, RateRule: rules.GetRuleFor(p))))
+            {
+                var dependentQueries = new List<Task<QueryRateResult>>();
+                foreach (var requiredExchange in i.RateRule.ExchangeRates)
+                {
+                    if (!fetchingExchanges.TryGetValue(requiredExchange.Exchange, out var fetching))
+                    {
+                        fetching = _rateProviderFactory.QueryRates(requiredExchange.Exchange, cancellationToken);
+                        fetchingExchanges.Add(requiredExchange.Exchange, fetching);
+                    }
+                    dependentQueries.Add(fetching);
+                }
+                fetchingRates.Add(i.Pair, GetRuleValue(dependentQueries, i.RateRule));
+            }
+            return fetchingRates;
+        }
+
+        private async Task<RateResult> GetRuleValue(List<Task<QueryRateResult>> dependentQueries, RateRule rateRule)
+        {
+            var result = new RateResult();
+            foreach (var queryAsync in dependentQueries)
+            {
+                var query = await queryAsync;
+                result.Latency = query.Latency;
+                if (query.Exception != null)
+                    result.ExchangeExceptions.Add(query.Exception);
+                foreach (var rule in query.ExchangeRates)
+                {
+                    rateRule.ExchangeRates.SetRate(rule.Exchange, rule.CurrencyPair, rule.BidAsk);
+                }
+            }
+            rateRule.Reevaluate();
+            result.BidAsk = rateRule.BidAsk;
+            result.Errors = rateRule.Errors;
+            result.EvaluatedRule = rateRule.ToString(true);
+            result.Rule = rateRule.ToString(false);
+            return result;
+        }
+    }
+}

BTCPayServer.Rating/Services/RateProviderFactory.cs

@@ -0,0 +1,194 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+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
+{
+    public class RateProviderFactory
+    {
+        class WrapperRateProvider : IRateProvider
+        {
+            private readonly IRateProvider _inner;
+            public Exception Exception { get; private set; }
+            public TimeSpan Latency { get; set; }
+            public WrapperRateProvider(IRateProvider inner)
+            {
+                _inner = inner;
+            }
+            public async Task<ExchangeRates> GetRatesAsync(CancellationToken cancellationToken)
+            {
+                DateTimeOffset now = DateTimeOffset.UtcNow;
+                try
+                {
+                    return await _inner.GetRatesAsync(cancellationToken);
+                }
+                catch (Exception ex)
+                {
+                    Exception = ex;
+                    return new ExchangeRates();
+                }
+                finally
+                {
+                    Latency = DateTimeOffset.UtcNow - now;
+                }
+            }
+        }
+        public class QueryRateResult
+        {
+            public TimeSpan Latency { get; set; }
+            public ExchangeRates ExchangeRates { get; set; }
+            public ExchangeException Exception { get; internal set; }
+        }
+        public RateProviderFactory(IOptions<MemoryCacheOptions> cacheOptions,
+                                   IHttpClientFactory httpClientFactory,
+                                   CoinAverageSettings coinAverageSettings)
+        {
+            _httpClientFactory = httpClientFactory;
+            _CoinAverageSettings = coinAverageSettings;
+            _CacheOptions = cacheOptions;
+            // We use 15 min because of limits with free version of bitcoinaverage
+            CacheSpan = TimeSpan.FromMinutes(15.0);
+            InitExchanges();
+        }
+        private IOptions<MemoryCacheOptions> _CacheOptions;
+        TimeSpan _CacheSpan;
+        public TimeSpan CacheSpan
+        {
+            get
+            {
+                return _CacheSpan;
+            }
+            set
+            {
+                _CacheSpan = value;
+                InvalidateCache();
+            }
+        }
+        public void InvalidateCache()
+        {
+            var cache = new MemoryCache(_CacheOptions);
+            foreach (var provider in Providers.Select(p => p.Value as CachedRateProvider).Where(p => p != null))
+            {
+                provider.CacheSpan = CacheSpan;
+                provider.MemoryCache = cache;
+            }
+            if (Providers.TryGetValue(CoinAverageRateProvider.CoinAverageName, out var coinAverage) && coinAverage is BackgroundFetcherRateProvider c)
+            {
+                c.RefreshRate = CacheSpan;
+                c.ValidatyTime = CacheSpan + TimeSpan.FromMinutes(1.0);
+            }
+        }
+        CoinAverageSettings _CoinAverageSettings;
+        private readonly IHttpClientFactory _httpClientFactory;
+        private readonly Dictionary<string, IRateProvider> _DirectProviders = new Dictionary<string, IRateProvider>();
+        public Dictionary<string, IRateProvider> Providers
+        {
+            get
+            {
+                return _DirectProviders;
+            }
+        }
+
+        private void InitExchanges()
+        {
+            // We need to be careful to only add exchanges which OnGetTickers implementation make only 1 request
+            Providers.Add("binance", new ExchangeSharpRateProvider("binance", new ExchangeBinanceAPI(), true));
+            Providers.Add("bittrex", new ExchangeSharpRateProvider("bittrex", new ExchangeBittrexAPI(), true));
+            Providers.Add("poloniex", new ExchangeSharpRateProvider("poloniex", new ExchangePoloniexAPI(), true));
+            Providers.Add("hitbtc", new ExchangeSharpRateProvider("hitbtc", new ExchangeHitbtcAPI(), false));
+
+            // Cryptopia is often not available
+            // Disabled because of https://twitter.com/Cryptopia_NZ/status/1085084168852291586
+            // Providers.Add("cryptopia", new ExchangeSharpRateProvider("cryptopia", new ExchangeCryptopiaAPI(), false));
+
+            // Handmade providers
+            Providers.Add(CoinAverageRateProvider.CoinAverageName, new CoinAverageRateProvider() { Exchange = CoinAverageRateProvider.CoinAverageName, HttpClient = _httpClientFactory?.CreateClient("EXCHANGE_COINAVERAGE"), Authenticator = _CoinAverageSettings });
+            Providers.Add("kraken", new KrakenExchangeRateProvider() { HttpClient = _httpClientFactory?.CreateClient("EXCHANGE_KRAKEN") });
+            Providers.Add("bylls", new ByllsRateProvider(_httpClientFactory?.CreateClient("EXCHANGE_BYLLS")));
+            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()));
+            //DirectProviders.Add("bitstamp", new ExchangeSharpRateProvider("bitstamp", new ExchangeBitstampAPI()));
+
+            foreach (var provider in Providers.ToArray())
+            {
+                if (provider.Key == "cryptopia") // Shitty exchange, rate often unavailable, it spams the logs
+                    continue;
+                var prov = new BackgroundFetcherRateProvider(Providers[provider.Key]);
+                if(provider.Key == CoinAverageRateProvider.CoinAverageName)
+                {
+                    prov.RefreshRate = CacheSpan;
+                    prov.ValidatyTime = CacheSpan + TimeSpan.FromMinutes(1.0);
+                }
+                else
+                {
+                    prov.RefreshRate = TimeSpan.FromMinutes(1.0);
+                    prov.ValidatyTime = TimeSpan.FromMinutes(5.0);
+                }
+                Providers[provider.Key] = prov;
+            }
+
+            var cache = new MemoryCache(_CacheOptions);
+            foreach (var supportedExchange in GetSupportedExchanges())
+            {
+                if (!Providers.ContainsKey(supportedExchange.Key))
+                {
+                    var coinAverage = new CoinAverageRateProvider()
+                    {
+                        Exchange = supportedExchange.Key,
+                        HttpClient = _httpClientFactory?.CreateClient(),
+                        Authenticator = _CoinAverageSettings
+                    };
+                    var cached = new CachedRateProvider(supportedExchange.Key, coinAverage, cache)
+                    {
+                        CacheSpan = CacheSpan
+                    };
+                    Providers.Add(supportedExchange.Key, cached);
+                }
+            }
+        }
+
+        public CoinAverageExchanges GetSupportedExchanges()
+        {
+            CoinAverageExchanges exchanges = new CoinAverageExchanges();
+            foreach (var exchange in _CoinAverageSettings.AvailableExchanges)
+            {
+                exchanges.Add(exchange.Value);
+            }
+
+            // Add other exchanges supported here
+            exchanges.Add(new CoinAverageExchange(CoinAverageRateProvider.CoinAverageName, "Coin Average", $"https://apiv2.bitcoinaverage.com/indices/global/ticker/short"));
+            exchanges.Add(new CoinAverageExchange("bylls", "Bylls", "https://bylls.com/api/price?from_currency=BTC&to_currency=CAD"));
+            exchanges.Add(new CoinAverageExchange("bitbank", "Bitbank", "https://public.bitbank.cc/prices"));
+
+            return exchanges;
+        }
+
+        public async Task<QueryRateResult> QueryRates(string exchangeName, CancellationToken cancellationToken)
+        {
+            Providers.TryGetValue(exchangeName, out var directProvider);
+            directProvider = directProvider ?? NullRateProvider.Instance;
+
+            var wrapper = new WrapperRateProvider(directProvider);
+            var value = await wrapper.GetRatesAsync(cancellationToken);
+            return new QueryRateResult()
+            {
+                Latency = wrapper.Latency,
+                ExchangeRates = value,
+                Exception = wrapper.Exception != null ? new ExchangeException() { Exception = wrapper.Exception, ExchangeName = exchangeName } : null
+            };
+        }
+    }
+}

BTCPayServer.Tests/BTCPayServer.Tests.csproj

@@ -1,20 +1,23 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp2.0</TargetFramework>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
 
     <IsPackable>false</IsPackable>
     <NoWarn>NU1701,CA1816,CA1308,CA1810,CA2208</NoWarn>
+    <LangVersion>7.2</LangVersion>
+    <UserSecretsId>AB0AC1DD-9D26-485B-9416-56A33F268117</UserSecretsId>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.6.0" />
-    <PackageReference Include="xunit" Version="2.3.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\BTCPayServer\BTCPayServer.csproj" />
+    <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>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
   </ItemGroup>
 
   <ItemGroup>
@@ -24,6 +27,14 @@
     <None Update="docker-compose.yml">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>
+    <None Update="xunit.runner.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\BTCPayServer.Rating\BTCPayServer.Rating.csproj" />
+    <ProjectReference Include="..\BTCPayServer\BTCPayServer.csproj" />
   </ItemGroup>
 
 </Project>

BTCPayServer.Tests/BTCPayServerTester.cs

@@ -1,7 +1,14 @@
 using BTCPayServer.Configuration;
+using System.Linq;
+using BTCPayServer.HostedServices;
 using BTCPayServer.Hosting;
+using BTCPayServer.Payments;
+using BTCPayServer.Payments.Lightning;
+using BTCPayServer.Rating;
+using BTCPayServer.Security;
 using BTCPayServer.Services.Invoices;
 using BTCPayServer.Services.Rates;
+using BTCPayServer.Services.Stores;
 using BTCPayServer.Tests.Logging;
 using BTCPayServer.Tests.Mocks;
 using Microsoft.AspNetCore.Hosting;
@@ -26,10 +33,21 @@ 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
 {
+    public enum TestDatabases
+    {
+        Postgres,
+        MySQL,
+    }
+
     public class BTCPayServerTester : IDisposable
     {
         private string _Directory;
@@ -45,13 +63,18 @@ namespace BTCPayServer.Tests
         }
 
         public Uri LTCNBXplorerUri { get; set; }
-        
+
         public Uri ServerUri
         {
             get;
             set;
         }
 
+        public string MySQL
+        {
+            get; set;
+        }
+
         public string Postgres
         {
             get; set;
@@ -63,11 +86,18 @@ namespace BTCPayServer.Tests
             get; set;
         }
 
+        public TestDatabases TestDatabase
+        {
+            get; set;
+        }
+
+        public bool MockRates { get; set; } = true;
+
         public void Start()
         {
             if (!Directory.Exists(_Directory))
                 Directory.CreateDirectory(_Directory);
-            string chain = ChainType.Regtest.ToNetwork().Name;
+            string chain = NBXplorerDefaultSettings.GetFolderName(NetworkType.Regtest);
             string chainDirectory = Path.Combine(_Directory, chain);
             if (!Directory.Exists(chainDirectory))
                 Directory.CreateDirectory(chainDirectory);
@@ -75,38 +105,40 @@ 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}");
 
-            config.AppendLine($"internallightningnode={IntegratedLightning.AbsoluteUri}");
-
-            if (Postgres != null)
+            if (TestDatabase == TestDatabases.MySQL && !String.IsNullOrEmpty(MySQL))
+                config.AppendLine($"mysql=" + MySQL);
+            else if (!String.IsNullOrEmpty(Postgres))
                 config.AppendLine($"postgres=" + Postgres);
             var confPath = Path.Combine(chainDirectory, "settings.config");
             File.WriteAllText(confPath, config.ToString());
 
             ServerUri = new Uri("http://" + HostName + ":" + Port + "/");
-
+            HttpClient = new HttpClient();
+            HttpClient.BaseAddress = ServerUri;
             Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development");
-            var conf = new DefaultConfiguration() { Logger = Logs.LogProvider.CreateLogger("Console") }.CreateConfiguration(new[] { "--datadir", _Directory, "--conf", confPath });
+            var conf = new DefaultConfiguration() { Logger = Logs.LogProvider.CreateLogger("Console") }.CreateConfiguration(new[] { "--datadir", _Directory, "--conf", confPath, "--disable-registration", "false" });
             _Host = new WebHostBuilder()
                     .UseConfiguration(conf)
+                    .UseContentRoot(FindBTCPayServerDirectory())
                     .ConfigureServices(s =>
                     {
-                        var mockRates = new MockRateProviderFactory();
-                        var btc = new MockRateProvider("BTC", new Rate("USD", 5000m));
-                        var ltc = new MockRateProvider("LTC", new Rate("USD", 500m));
-                        mockRates.AddMock(btc);
-                        mockRates.AddMock(ltc);
-                        s.AddSingleton<IRateProviderFactory>(mockRates);
                         s.AddLogging(l =>
                         {
+                            l.AddFilter("System.Net.Http.HttpClient", LogLevel.Critical);
                             l.SetMinimumLevel(LogLevel.Information)
                             .AddFilter("Microsoft", LogLevel.Error)
                             .AddFilter("Hangfire", LogLevel.Error)
@@ -117,31 +149,151 @@ namespace BTCPayServer.Tests
                     .UseStartup<Startup>()
                     .Build();
             _Host.Start();
+
+            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));
+            Networks = (BTCPayNetworkProvider)_Host.Services.GetService(typeof(BTCPayNetworkProvider));
+
+            if (MockRates)
+            {
+                var rateProvider = (RateProviderFactory)_Host.Services.GetService(typeof(RateProviderFactory));
+                rateProvider.Providers.Clear();
+
+                var coinAverageMock = new MockRateProvider();
+                coinAverageMock.ExchangeRates.Add(new Rating.ExchangeRate()
+                {
+                    Exchange = "coinaverage",
+                    CurrencyPair = CurrencyPair.Parse("BTC_USD"),
+                    BidAsk = new BidAsk(5000m)
+                });
+                coinAverageMock.ExchangeRates.Add(new Rating.ExchangeRate()
+                {
+                    Exchange = "coinaverage",
+                    CurrencyPair = CurrencyPair.Parse("BTC_CAD"),
+                    BidAsk = new BidAsk(4500m)
+                });
+                coinAverageMock.ExchangeRates.Add(new Rating.ExchangeRate()
+                {
+                    Exchange = "coinaverage",
+                    CurrencyPair = CurrencyPair.Parse("LTC_BTC"),
+                    BidAsk = new BidAsk(0.001m)
+                });
+                coinAverageMock.ExchangeRates.Add(new Rating.ExchangeRate()
+                {
+                    Exchange = "coinaverage",
+                    CurrencyPair = CurrencyPair.Parse("LTC_USD"),
+                    BidAsk = new BidAsk(500m)
+                });
+                rateProvider.Providers.Add("coinaverage", coinAverageMock);
+
+                var bitflyerMock = new MockRateProvider();
+                bitflyerMock.ExchangeRates.Add(new Rating.ExchangeRate()
+                {
+                    Exchange = "bitflyer",
+                    CurrencyPair = CurrencyPair.Parse("BTC_JPY"),
+                    BidAsk = new BidAsk(700000m)
+                });
+                rateProvider.Providers.Add("bitflyer", bitflyerMock);
+
+                var quadrigacx = new MockRateProvider();
+                quadrigacx.ExchangeRates.Add(new Rating.ExchangeRate()
+                {
+                    Exchange = "quadrigacx",
+                    CurrencyPair = CurrencyPair.Parse("BTC_CAD"),
+                    BidAsk = new BidAsk(6000m)
+                });
+                rateProvider.Providers.Add("quadrigacx", quadrigacx);
+
+                var bittrex = new MockRateProvider();
+                bittrex.ExchangeRates.Add(new Rating.ExchangeRate()
+                {
+                    Exchange = "bittrex",
+                    CurrencyPair = CurrencyPair.Parse("DOGE_BTC"),
+                    BidAsk = new BidAsk(0.004m)
+                });
+                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()
+        {
+            var solutionDirectory = LanguageService.TryGetSolutionDirectoryInfo(Directory.GetCurrentDirectory());
+            return Path.Combine(solutionDirectory.FullName, "BTCPayServer");
+        }
+
+        public HttpClient HttpClient { get; set; }
+
         public string HostName
         {
             get;
             internal set;
         }
         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; }
 
         public T GetService<T>()
         {
             return _Host.Services.GetRequiredService<T>();
         }
 
-        public T GetController<T>(string userId = null) where T : Controller
+        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();
-            context.Request.Host = new HostString("127.0.0.1");
+            context.Request.Host = new HostString("127.0.0.1", Port);
             context.Request.Scheme = "http";
             context.Request.Protocol = "http";
             if (userId != null)
             {
-                context.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim(ClaimTypes.NameIdentifier, userId) }));
+                List<Claim> claims = new List<Claim>();
+                claims.Add(new Claim(OpenIdConnectConstants.Claims.Subject, userId));
+                if (additionalClaims != null)
+                    claims.AddRange(additionalClaims);
+                context.User = new ClaimsPrincipal(new ClaimsIdentity(claims.ToArray(), Policies.CookieAuthentication));
+            }
+            if (storeId != null)
+            {
+                context.SetStoreData(GetService<StoreRepository>().FindStore(storeId, userId).GetAwaiter().GetResult());
             }
             var scope = (IServiceScopeFactory)_Host.Services.GetService(typeof(IServiceScopeFactory));
             var provider = scope.CreateScope().ServiceProvider;

BTCPayServer.Tests/ChangellyTests.cs

@@ -0,0 +1,253 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Threading.Tasks;
+using BTCPayServer.Controllers;
+using BTCPayServer.Data;
+using BTCPayServer.Models;
+using BTCPayServer.Models.StoreViewModels;
+using BTCPayServer.Payments.Changelly;
+using BTCPayServer.Payments.Changelly.Models;
+using BTCPayServer.Services.Rates;
+using BTCPayServer.Services.Stores;
+using BTCPayServer.Tests.Logging;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace BTCPayServer.Tests
+{
+    public class ChangellyTests
+    {
+        public ChangellyTests(ITestOutputHelper helper)
+        {
+            Logs.Tester = new XUnitLog(helper) {Name = "Tests"};
+            Logs.LogProvider = new XUnitLogProvider(helper);
+        }
+
+        [Fact(Timeout = 60000)]
+        [Trait("Integration", "Integration")]
+        public async void CanSetChangellyPaymentMethod()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var controller = tester.PayTester.GetController<StoresController>(user.UserId, user.StoreId);
+
+
+                var storeBlob = controller.StoreData.GetStoreBlob();
+                Assert.Null(storeBlob.ChangellySettings);
+
+                var updateModel = new UpdateChangellySettingsViewModel()
+                {
+                    ApiSecret = "secret",
+                    ApiKey = "key",
+                    ApiUrl = "http://gozo.com",
+                    ChangellyMerchantId = "aaa",
+                };
+
+                Assert.Equal("UpdateStore", Assert.IsType<RedirectToActionResult>(
+                    await controller.UpdateChangellySettings(user.StoreId, updateModel, "save")).ActionName);
+
+                var store = await tester.PayTester.StoreRepository.FindStore(user.StoreId);
+                storeBlob = controller.StoreData.GetStoreBlob();
+                Assert.NotNull(storeBlob.ChangellySettings);
+                Assert.NotNull(storeBlob.ChangellySettings);
+                Assert.IsType<ChangellySettings>(storeBlob.ChangellySettings);
+                Assert.Equal(storeBlob.ChangellySettings.ApiKey, updateModel.ApiKey);
+                Assert.Equal(storeBlob.ChangellySettings.ApiSecret,
+                    updateModel.ApiSecret);
+                Assert.Equal(storeBlob.ChangellySettings.ApiUrl, updateModel.ApiUrl);
+                Assert.Equal(storeBlob.ChangellySettings.ChangellyMerchantId,
+                    updateModel.ChangellyMerchantId);
+            }
+        }
+
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async void CanToggleChangellyPaymentMethod()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var controller = tester.PayTester.GetController<StoresController>(user.UserId, user.StoreId);
+
+                var updateModel = new UpdateChangellySettingsViewModel()
+                {
+                    ApiSecret = "secret",
+                    ApiKey = "key",
+                    ApiUrl = "http://gozo.com",
+                    ChangellyMerchantId = "aaa",
+                    Enabled = true
+                };
+                Assert.Equal("UpdateStore", Assert.IsType<RedirectToActionResult>(
+                    await controller.UpdateChangellySettings(user.StoreId, updateModel, "save")).ActionName);
+
+
+                var store = await tester.PayTester.StoreRepository.FindStore(user.StoreId);
+
+                Assert.True(store.GetStoreBlob().ChangellySettings.Enabled);
+
+                updateModel.Enabled = false;
+
+                Assert.Equal("UpdateStore", Assert.IsType<RedirectToActionResult>(
+                    await controller.UpdateChangellySettings(user.StoreId, updateModel, "save")).ActionName);
+
+                store = await tester.PayTester.StoreRepository.FindStore(user.StoreId);
+
+                Assert.False(store.GetStoreBlob().ChangellySettings.Enabled);
+            }
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async void CannotUseChangellyApiWithoutChangellyPaymentMethodSet()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var changellyController =
+                    tester.PayTester.GetController<ChangellyController>(user.UserId, user.StoreId);
+                changellyController.IsTest = true;
+
+                //test non existing payment method
+                Assert.IsType<BitpayErrorModel>(Assert
+                    .IsType<BadRequestObjectResult>(await changellyController.GetCurrencyList(user.StoreId))
+                    .Value);
+
+                var updateModel = CreateDefaultChangellyParams(false);
+                var storesController = tester.PayTester.GetController<StoresController>(user.UserId, user.StoreId);
+                //set payment method but disabled
+
+
+                Assert.Equal("UpdateStore", Assert.IsType<RedirectToActionResult>(
+                    await storesController.UpdateChangellySettings(user.StoreId, updateModel, "save")).ActionName);
+
+
+                Assert.IsType<BitpayErrorModel>(Assert
+                    .IsType<BadRequestObjectResult>(await changellyController.GetCurrencyList(user.StoreId))
+                    .Value);
+
+                updateModel.Enabled = true;
+                //test with enabled method
+
+                Assert.Equal("UpdateStore", Assert.IsType<RedirectToActionResult>(
+                    await storesController.UpdateChangellySettings(user.StoreId, updateModel, "save")).ActionName);
+
+
+                Assert.IsNotType<BitpayErrorModel>(Assert
+                    .IsType<OkObjectResult>(await changellyController.GetCurrencyList(user.StoreId))
+                    .Value);
+            }
+        }
+
+        UpdateChangellySettingsViewModel CreateDefaultChangellyParams(bool enabled)
+        {
+            return new UpdateChangellySettingsViewModel()
+            {
+                ApiKey = "6ed02cdf1b614d89a8c0ceb170eebb61",
+                ApiSecret = "8fbd66a2af5fd15a6b5f8ed0159c5842e32a18538521ffa145bd6c9e124d3483",
+                ChangellyMerchantId = "804298eb5753",
+                Enabled = enabled
+            };
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async void CanGetCurrencyListFromChangelly()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+
+                //save changelly settings
+                var updateModel = CreateDefaultChangellyParams(true);
+                var storesController = tester.PayTester.GetController<StoresController>(user.UserId, user.StoreId);
+
+                //confirm saved
+                Assert.Equal("UpdateStore", Assert.IsType<RedirectToActionResult>(
+                    await storesController.UpdateChangellySettings(user.StoreId, updateModel, "save")).ActionName);
+
+                var factory = UnitTest1.CreateBTCPayRateFactory();
+                var fetcher = new RateFetcher(factory);
+                var httpClientFactory = new MockHttpClientFactory();
+                var changellyController = new ChangellyController(
+                    new ChangellyClientProvider(tester.PayTester.StoreRepository, httpClientFactory),
+                    tester.NetworkProvider, fetcher);
+                changellyController.IsTest = true;
+                var result = Assert
+                    .IsType<OkObjectResult>(await changellyController.GetCurrencyList(user.StoreId))
+                    .Value as IEnumerable<CurrencyFull>;
+                Assert.True(result.Any());
+            }
+        }
+
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async void CanCalculateToAmountForChangelly()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+
+                var updateModel = CreateDefaultChangellyParams(true);
+                var storesController = tester.PayTester.GetController<StoresController>(user.UserId, user.StoreId);
+
+                Assert.Equal("UpdateStore", Assert.IsType<RedirectToActionResult>(
+                    await storesController.UpdateChangellySettings(user.StoreId, updateModel, "save")).ActionName);
+
+                var factory = UnitTest1.CreateBTCPayRateFactory();
+                var fetcher = new RateFetcher(factory);
+                var httpClientFactory = new MockHttpClientFactory();
+                var changellyController = new ChangellyController(
+                    new ChangellyClientProvider(tester.PayTester.StoreRepository, httpClientFactory),
+                    tester.NetworkProvider, fetcher);
+                changellyController.IsTest = true;
+                Assert.IsType<decimal>(Assert
+                    .IsType<OkObjectResult>(await changellyController.CalculateAmount(user.StoreId, "ltc", "btc", 1.0m, default))
+                    .Value);
+            }
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public void CanComputeBaseAmount()
+        {
+            Assert.Equal(1, ChangellyCalculationHelper.ComputeBaseAmount(1, 1));
+            Assert.Equal(0.5m, ChangellyCalculationHelper.ComputeBaseAmount(1, 0.5m));
+            Assert.Equal(2, ChangellyCalculationHelper.ComputeBaseAmount(0.5m, 1));
+            Assert.Equal(4m, ChangellyCalculationHelper.ComputeBaseAmount(1, 4));
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public void CanComputeCorrectAmount()
+        {
+            Assert.Equal(1, ChangellyCalculationHelper.ComputeCorrectAmount(0.5m, 1, 2));
+            Assert.Equal(0.25m, ChangellyCalculationHelper.ComputeCorrectAmount(0.5m, 1, 0.5m));
+            Assert.Equal(20, ChangellyCalculationHelper.ComputeCorrectAmount(10, 1, 2));
+        }
+    }
+
+    public class MockHttpClientFactory : IHttpClientFactory
+    {
+        public HttpClient CreateClient(string name)
+        {
+            return new HttpClient();
+        }
+    }
+}

BTCPayServer.Tests/ChargeTester.cs

@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
-using BTCPayServer.Payments.Lightning.CLightning;
+using BTCPayServer.Lightning;
+using BTCPayServer.Lightning.Charge;
+using BTCPayServer.Payments.Lightning;
 using NBitcoin;
 
 namespace BTCPayServer.Tests
@@ -14,7 +16,7 @@ namespace BTCPayServer.Tests
         {
             this._Parent = serverTester;
             var url = serverTester.GetEnvironment(environmentName, defaultValue);
-            Client = new ChargeClient(new Uri(url), network);
+            Client = (ChargeClient)LightningClientFactory.CreateClient(url, network);
             P2PHost = _Parent.GetEnvironment(environmentName + "_HOST", defaultHost);
         }        
         public ChargeClient Client { get; set; }

BTCPayServer.Tests/CoinSwitchTests.cs

@@ -0,0 +1,89 @@
+using BTCPayServer.Controllers;
+using BTCPayServer.Models.StoreViewModels;
+using BTCPayServer.Payments.CoinSwitch;
+using BTCPayServer.Tests.Logging;
+using Microsoft.AspNetCore.Mvc;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace BTCPayServer.Tests
+{
+    public class CoinSwitchTests
+    {
+        public CoinSwitchTests(ITestOutputHelper helper)
+        {
+            Logs.Tester = new XUnitLog(helper) {Name = "Tests"};
+            Logs.LogProvider = new XUnitLogProvider(helper);
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async void CanSetCoinSwitchPaymentMethod()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var controller = tester.PayTester.GetController<StoresController>(user.UserId, user.StoreId);
+
+
+                var storeBlob = controller.StoreData.GetStoreBlob();
+                Assert.Null(storeBlob.CoinSwitchSettings);
+
+                var updateModel = new UpdateCoinSwitchSettingsViewModel()
+                {
+                    MerchantId = "aaa",
+                };
+
+                Assert.Equal("UpdateStore", Assert.IsType<RedirectToActionResult>(
+                    await controller.UpdateCoinSwitchSettings(user.StoreId, updateModel, "save")).ActionName);
+
+                var store = await tester.PayTester.StoreRepository.FindStore(user.StoreId);
+                storeBlob = controller.StoreData.GetStoreBlob();
+                Assert.NotNull(storeBlob.CoinSwitchSettings);
+                Assert.NotNull(storeBlob.CoinSwitchSettings);
+                Assert.IsType<CoinSwitchSettings>(storeBlob.CoinSwitchSettings);
+                Assert.Equal(storeBlob.CoinSwitchSettings.MerchantId,
+                    updateModel.MerchantId);
+            }
+        }
+
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async void CanToggleCoinSwitchPaymentMethod()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var controller = tester.PayTester.GetController<StoresController>(user.UserId, user.StoreId);
+
+                var updateModel = new UpdateCoinSwitchSettingsViewModel()
+                {
+                    MerchantId = "aaa",
+                    Enabled = true
+                };
+                Assert.Equal("UpdateStore", Assert.IsType<RedirectToActionResult>(
+                    await controller.UpdateCoinSwitchSettings(user.StoreId, updateModel, "save")).ActionName);
+
+
+                var store = await tester.PayTester.StoreRepository.FindStore(user.StoreId);
+
+                Assert.True(store.GetStoreBlob().CoinSwitchSettings.Enabled);
+
+                updateModel.Enabled = false;
+
+                Assert.Equal("UpdateStore", Assert.IsType<RedirectToActionResult>(
+                    await controller.UpdateCoinSwitchSettings(user.StoreId, updateModel, "save")).ActionName);
+
+                store = await tester.PayTester.StoreRepository.FindStore(user.StoreId);
+
+                Assert.False(store.GetStoreBlob().CoinSwitchSettings.Enabled);
+            }
+        }
+   
+    }
+}

BTCPayServer.Tests/CrowdfundTests.cs

@@ -0,0 +1,304 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Controllers;
+using BTCPayServer.Data;
+using BTCPayServer.Events;
+using BTCPayServer.Models;
+using BTCPayServer.Models.AppViewModels;
+using BTCPayServer.Models.StoreViewModels;
+using BTCPayServer.Payments.Changelly;
+using BTCPayServer.Payments.Changelly.Models;
+using BTCPayServer.Services.Apps;
+using BTCPayServer.Services.Invoices;
+using BTCPayServer.Services.Rates;
+using BTCPayServer.Services.Stores;
+using BTCPayServer.Tests.Logging;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using NBitcoin;
+using NBitpayClient;
+using Xunit;
+using Xunit.Abstractions;
+using static BTCPayServer.Tests.UnitTest1;
+
+namespace BTCPayServer.Tests
+{
+    public class CrowdfundTests
+    {
+        public CrowdfundTests(ITestOutputHelper helper)
+        {
+            Logs.Tester = new XUnitLog(helper) {Name = "Tests"};
+            Logs.LogProvider = new XUnitLogProvider(helper);
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public void CanCreateAndDeleteCrowdfundApp()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var user2 = tester.NewAccount();
+                user2.GrantAccess();
+                var apps = user.GetController<AppsController>();
+                var apps2 = user2.GetController<AppsController>();
+                var vm = Assert.IsType<CreateAppViewModel>(Assert.IsType<ViewResult>(apps.CreateApp().Result).Model);
+                Assert.NotNull(vm.SelectedAppType);
+                Assert.Null(vm.Name);
+                vm.Name = "test";
+                vm.SelectedAppType = AppType.Crowdfund.ToString();
+                var redirectToAction = Assert.IsType<RedirectToActionResult>(apps.CreateApp(vm).Result);
+                Assert.Equal(nameof(apps.UpdateCrowdfund), redirectToAction.ActionName);
+                var appList = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps().Result).Model);
+                var appList2 =
+                    Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps2.ListApps().Result).Model);
+                Assert.Single(appList.Apps);
+                Assert.Empty(appList2.Apps);
+                Assert.Equal("test", appList.Apps[0].AppName);
+                Assert.Equal(apps.CreatedAppId, appList.Apps[0].Id);
+                Assert.True(appList.Apps[0].IsOwner);
+                Assert.Equal(user.StoreId, appList.Apps[0].StoreId);
+                Assert.IsType<NotFoundResult>(apps2.DeleteApp(appList.Apps[0].Id).Result);
+                Assert.IsType<ViewResult>(apps.DeleteApp(appList.Apps[0].Id).Result);
+                redirectToAction = Assert.IsType<RedirectToActionResult>(apps.DeleteAppPost(appList.Apps[0].Id).Result);
+                Assert.Equal(nameof(apps.ListApps), redirectToAction.ActionName);
+                appList = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps().Result).Model);
+                Assert.Empty(appList.Apps);
+            }
+        }
+        
+        
+        
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async Task CanContributeOnlyWhenAllowed()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                user.RegisterDerivationScheme("BTC");
+                var apps = user.GetController<AppsController>();
+                var vm = Assert.IsType<CreateAppViewModel>(Assert.IsType<ViewResult>(apps.CreateApp().Result).Model);
+                vm.Name = "test";
+                vm.SelectedAppType = AppType.Crowdfund.ToString();
+                Assert.IsType<RedirectToActionResult>(apps.CreateApp(vm).Result);
+                var appId = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps().Result).Model)
+                    .Apps[0].Id;
+                
+                //Scenario 1: Not Enabled - Not Allowed
+                var crowdfundViewModel = Assert.IsType<UpdateCrowdfundViewModel>(Assert
+                    .IsType<ViewResult>(apps.UpdateCrowdfund(appId).Result).Model);
+                crowdfundViewModel.TargetCurrency = "BTC";
+                crowdfundViewModel.Enabled = false;
+                crowdfundViewModel.EndDate = null;
+                
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                
+                var anonAppPubsController = tester.PayTester.GetController<AppsPublicController>();
+                var publicApps = user.GetController<AppsPublicController>();
+
+
+                Assert.IsType<NotFoundObjectResult>(await anonAppPubsController.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
+                {
+                    Amount = new decimal(0.01)
+                }, default));
+                
+                Assert.IsType<NotFoundResult>(await anonAppPubsController.ViewCrowdfund(appId, string.Empty));
+                
+                //Scenario 2: Not Enabled But Admin - Allowed
+                Assert.IsType<OkObjectResult>(await publicApps.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
+                {
+                    RedirectToCheckout = false,
+                    Amount = new decimal(0.01)
+                }, default));
+                Assert.IsType<ViewResult>(await publicApps.ViewCrowdfund(appId, string.Empty));
+                Assert.IsType<NotFoundResult>(await anonAppPubsController.ViewCrowdfund(appId, string.Empty));
+                
+                //Scenario 3: Enabled But Start Date > Now - Not Allowed
+                crowdfundViewModel.StartDate= DateTime.Today.AddDays(2);
+                crowdfundViewModel.Enabled = true;
+                
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                Assert.IsType<NotFoundObjectResult>(await anonAppPubsController.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
+                {
+                    Amount = new decimal(0.01)
+                }, default));
+                
+                //Scenario 4: Enabled But End Date < Now - Not Allowed
+                
+                crowdfundViewModel.StartDate= DateTime.Today.AddDays(-2);
+                crowdfundViewModel.EndDate= DateTime.Today.AddDays(-1);
+                crowdfundViewModel.Enabled = true;
+                
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                Assert.IsType<NotFoundObjectResult>(await anonAppPubsController.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
+                {
+                    Amount = new decimal(0.01)
+                }, default));
+                
+                
+                //Scenario 5: Enabled and within correct timeframe, however target is enforced and Amount is Over - Not Allowed
+                crowdfundViewModel.StartDate= DateTime.Today.AddDays(-2);
+                crowdfundViewModel.EndDate= DateTime.Today.AddDays(2);
+                crowdfundViewModel.Enabled = true;
+                crowdfundViewModel.TargetAmount = 1;
+                crowdfundViewModel.TargetCurrency = "BTC";
+                crowdfundViewModel.EnforceTargetAmount = true;
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                Assert.IsType<NotFoundObjectResult>(await anonAppPubsController.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
+                {
+                    Amount = new decimal(1.01)
+                }, default));
+                
+                //Scenario 6: Allowed
+                Assert.IsType<OkObjectResult>(await anonAppPubsController.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
+                {
+                    Amount = new decimal(0.05)
+                }, default));
+                
+            }
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public void CanComputeCrowdfundModel()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                user.RegisterDerivationScheme("BTC");
+                user.ModifyStore(s => s.NetworkFeeMode = NetworkFeeMode.Never);
+                var apps = user.GetController<AppsController>();
+                var vm = Assert.IsType<CreateAppViewModel>(Assert.IsType<ViewResult>(apps.CreateApp().Result).Model);
+                vm.Name = "test";
+                vm.SelectedAppType = AppType.Crowdfund.ToString();
+                Assert.IsType<RedirectToActionResult>(apps.CreateApp(vm).Result);
+                var appId = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps().Result).Model)
+                    .Apps[0].Id;
+
+                Logs.Tester.LogInformation("We create an invoice with a hardcap");
+                var crowdfundViewModel = Assert.IsType<UpdateCrowdfundViewModel>(Assert
+                    .IsType<ViewResult>(apps.UpdateCrowdfund(appId).Result).Model);
+                crowdfundViewModel.Enabled = true;
+                crowdfundViewModel.EndDate = null;
+                crowdfundViewModel.TargetAmount = 100;
+                crowdfundViewModel.TargetCurrency = "BTC";
+                crowdfundViewModel.UseAllStoreInvoices = true;
+                crowdfundViewModel.EnforceTargetAmount = true;
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                
+                var anonAppPubsController = tester.PayTester.GetController<AppsPublicController>();
+                var publicApps = user.GetController<AppsPublicController>();
+
+                var model = Assert.IsType<ViewCrowdfundViewModel>(Assert
+                    .IsType<ViewResult>(publicApps.ViewCrowdfund(appId, String.Empty).Result).Model);
+                
+                
+                Assert.Equal(crowdfundViewModel.TargetAmount, model.TargetAmount );
+                Assert.Equal(crowdfundViewModel.EndDate, model.EndDate );
+                Assert.Equal(crowdfundViewModel.StartDate, model.StartDate );
+                Assert.Equal(crowdfundViewModel.TargetCurrency, model.TargetCurrency );
+                Assert.Equal(0m, model.Info.CurrentAmount );
+                Assert.Equal(0m, model.Info.CurrentPendingAmount);
+                Assert.Equal(0m, model.Info.ProgressPercentage);
+
+
+                Logs.Tester.LogInformation("Unpaid invoices should show as pending contribution because it is hardcap");
+                Logs.Tester.LogInformation("Because UseAllStoreInvoices is true, we can manually create an invoice and it should show as contribution");
+                var invoice = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Buyer = new Buyer() { email = "test@fwf.com" },
+                    Price = 1m,
+                    Currency = "BTC",
+                    PosData = "posData",
+                    ItemDesc = "Some description",
+                    TransactionSpeed = "high",
+                    FullNotifications = true
+                }, Facade.Merchant);
+
+                
+                model = Assert.IsType<ViewCrowdfundViewModel>(Assert
+                    .IsType<ViewResult>(publicApps.ViewCrowdfund(appId, String.Empty).Result).Model);
+                
+                Assert.Equal(0m ,model.Info.CurrentAmount);
+                Assert.Equal(1m, model.Info.CurrentPendingAmount);
+                Assert.Equal(0m, model.Info.ProgressPercentage);
+                Assert.Equal(1m, model.Info.PendingProgressPercentage);
+
+                Logs.Tester.LogInformation("Let's check current amount change once payment is confirmed");
+                var invoiceAddress = BitcoinAddress.Create(invoice.CryptoInfo[0].Address, tester.ExplorerNode.Network);
+                tester.ExplorerNode.SendToAddress(invoiceAddress, invoice.BtcDue);
+                tester.ExplorerNode.Generate(1); // By default invoice confirmed at 1 block
+                TestUtils.Eventually(() =>
+                {
+                    model = Assert.IsType<ViewCrowdfundViewModel>(Assert
+                    .IsType<ViewResult>(publicApps.ViewCrowdfund(appId, String.Empty).Result).Model);
+                    Assert.Equal(1m, model.Info.CurrentAmount);
+                    Assert.Equal(0m, model.Info.CurrentPendingAmount);
+                });
+
+                Logs.Tester.LogInformation("Because UseAllStoreInvoices is true, let's make sure the invoice is tagged");
+                var invoiceEntity = tester.PayTester.InvoiceRepository.GetInvoice(invoice.Id).GetAwaiter().GetResult();
+                Assert.True(invoiceEntity.Version >= InvoiceEntity.InternalTagSupport_Version);
+                Assert.Contains(AppService.GetAppInternalTag(appId), invoiceEntity.InternalTags);
+
+                crowdfundViewModel.UseAllStoreInvoices = false;
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+
+                Logs.Tester.LogInformation("Because UseAllStoreInvoices is false, let's make sure the invoice is not tagged");
+                invoice = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Buyer = new Buyer() { email = "test@fwf.com" },
+                    Price = 1m,
+                    Currency = "BTC",
+                    PosData = "posData",
+                    ItemDesc = "Some description",
+                    TransactionSpeed = "high",
+                    FullNotifications = true
+                }, Facade.Merchant);
+                invoiceEntity = tester.PayTester.InvoiceRepository.GetInvoice(invoice.Id).GetAwaiter().GetResult();
+                Assert.DoesNotContain(AppService.GetAppInternalTag(appId), invoiceEntity.InternalTags);
+
+                Logs.Tester.LogInformation("After turning setting a softcap, let's check that only actual payments are counted");
+                crowdfundViewModel.EnforceTargetAmount = false;
+                crowdfundViewModel.UseAllStoreInvoices = true;
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                invoice = user.BitPay.CreateInvoice(new Invoice()
+                {
+                    Buyer = new Buyer() { email = "test@fwf.com" },
+                    Price = 1m,
+                    Currency = "BTC",
+                    PosData = "posData",
+                    ItemDesc = "Some description",
+                    TransactionSpeed = "high",
+                    FullNotifications = true
+                }, Facade.Merchant);
+                Assert.Equal(0m, model.Info.CurrentPendingAmount);
+                invoiceAddress = BitcoinAddress.Create(invoice.CryptoInfo[0].Address, tester.ExplorerNode.Network);
+                tester.ExplorerNode.SendToAddress(invoiceAddress, Money.Coins(0.5m));
+                tester.ExplorerNode.SendToAddress(invoiceAddress, Money.Coins(0.2m));
+                TestUtils.Eventually(() =>
+                {
+                    model = Assert.IsType<ViewCrowdfundViewModel>(Assert
+                    .IsType<ViewResult>(publicApps.ViewCrowdfund(appId, String.Empty).Result).Model);
+                    Assert.Equal(0.7m, model.Info.CurrentPendingAmount);
+                });
+            }
+
+            
+        }
+        
+    }
+
+
+}

BTCPayServer.Tests/CustomerHttpServer.cs

@@ -8,30 +8,27 @@ using Microsoft.AspNetCore.Builder;
 using System.Threading.Tasks;
 using System.Threading;
 using Microsoft.AspNetCore.Hosting.Server.Features;
+using System.Threading.Channels;
+using System.IO;
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json;
 
 namespace BTCPayServer.Tests
 {
     public class CustomServer : IDisposable
     {
-        TaskCompletionSource<bool> _Evt = null;
         IWebHost _Host = null;
         CancellationTokenSource _Closed = new CancellationTokenSource();
+        Channel<JObject> _Requests = Channel.CreateUnbounded<JObject>();
         public CustomServer()
-        {
+        { 
             var port = Utils.FreeTcpPort();
             _Host = new WebHostBuilder()
                 .Configure(app =>
                 {
                     app.Run(req =>
                     {
-                        while (_Act == null)
-                        {
-                            Thread.Sleep(10);
-                            _Closed.Token.ThrowIfCancellationRequested();
-                        }
-                        _Act(req);
-                        _Act = null;
-                        _Evt.TrySetResult(true);
+                        _Requests.Writer.WriteAsync(JsonConvert.DeserializeObject<JObject>(new StreamReader(req.Request.Body).ReadToEnd()), _Closed.Token);
                         req.Response.StatusCode = 200;
                         return Task.CompletedTask;
                     });
@@ -47,22 +44,24 @@ namespace BTCPayServer.Tests
             return new Uri(_Host.ServerFeatures.Get<IServerAddressesFeature>().Addresses.First());
         }
 
-        Action<HttpContext> _Act;
-        public void ProcessNextRequest(Action<HttpContext> act)
+        public async Task<JObject> GetNextRequest()
         {
-            var source = new TaskCompletionSource<bool>();
-            CancellationTokenSource cancellation = new CancellationTokenSource(20000);
-            cancellation.Token.Register(() => source.TrySetCanceled());
-            source = new TaskCompletionSource<bool>();
-            _Evt = source;
-            _Act = act;
-            try
+            using (CancellationTokenSource cancellation = new CancellationTokenSource(2000000))
             {
-                _Evt.Task.GetAwaiter().GetResult();
-            }
-            catch (TaskCanceledException)
-            {
-                throw new Xunit.Sdk.XunitException("Callback to the webserver was expected, check if the callback url is accessible from internet");
+                try
+                {
+                    JObject req = null;
+                    while(!await _Requests.Reader.WaitToReadAsync(cancellation.Token) || 
+                        !_Requests.Reader.TryRead(out req))
+                    {
+
+                    }
+                    return req;
+                }
+                catch (TaskCanceledException)
+                {
+                    throw new Xunit.Sdk.XunitException("Callback to the webserver was expected, check if the callback url is accessible from internet");
+                }
             }
         }
 

BTCPayServer.Tests/Dockerfile

@@ -1,12 +1,28 @@
-FROM microsoft/dotnet:2.0.5-sdk-2.1.4
-WORKDIR /app
- # caches restore result by copying csproj file separately
-COPY BTCPayServer.Tests/BTCPayServer.Tests.csproj BTCPayServer.Tests/BTCPayServer.Tests.csproj
+FROM mcr.microsoft.com/dotnet/core/sdk:2.1.505-alpine3.7 AS builder
+ENV DOTNET_SYSTEM_GLOBALIZATION_INVARIANT false
+RUN apk add --no-cache icu-libs
+ENV LC_ALL en_US.UTF-8
+ENV LANG en_US.UTF-8
+
+WORKDIR /source
+COPY Common.csproj 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
 
-WORKDIR /app/BTCPayServer.Tests
-RUN dotnet restore
-# copies the rest of your code
-COPY . ../.
+ENV DOTNET_SYSTEM_GLOBALIZATION_INVARIANT false
 
-ENTRYPOINT ["dotnet", "test"]
+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 cd BTCPayServer.Tests && dotnet build
+WORKDIR /source/BTCPayServer.Tests
+ENTRYPOINT ["./docker-entrypoint.sh"]

BTCPayServer.Tests/EclairTester.cs

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

BTCPayServer.Tests/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/LightningDTester.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using BTCPayServer.Lightning.CLightning;
+using NBitcoin;
+
+namespace BTCPayServer.Tests
+{
+    public class LightningDTester
+    {
+        ServerTester parent;
+        public LightningDTester(ServerTester parent, string environmentName, string defaultRPC, string defaultHost, Network network)
+        {
+            this.parent = parent;
+            RPC = new CLightningClient(new Uri(parent.GetEnvironment(environmentName, defaultRPC)), network);
+        }
+
+        public CLightningClient RPC { get; }
+        public string P2PHost { get; }
+        
+    }
+}

BTCPayServer.Tests/Lnd/LndMockTester.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using BTCPayServer.Lightning.LND;
+using NBitcoin;
+
+namespace BTCPayServer.Tests.Lnd
+{
+    public class LndMockTester
+    {
+        private ServerTester _Parent;
+
+        public LndMockTester(ServerTester serverTester, string environmentName, string defaultValue, string defaultHost, Network network)
+        {
+            this._Parent = serverTester;
+            var url = serverTester.GetEnvironment(environmentName, defaultValue);
+
+            Swagger = new LndSwaggerClient(new LndRestSettings(new Uri(url)) { AllowInsecure = true });
+            Client = new LndClient(Swagger, network);
+            P2PHost = _Parent.GetEnvironment(environmentName + "_HOST", defaultHost);
+        }
+
+        public LndSwaggerClient Swagger { get; set; }
+        public LndClient Client { get; set; }
+        public string P2PHost { get; }
+    }
+}

BTCPayServer.Tests/MockDelay.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Tests
+{
+    public class MockDelay : IDelay
+    {
+        class WaitObj
+        {
+            public DateTimeOffset Expiration;
+            public TaskCompletionSource<bool> CTS;
+        }
+
+        List<WaitObj> waits = new List<WaitObj>();
+        DateTimeOffset _Now = new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero);
+        public async Task Wait(TimeSpan delay, CancellationToken cancellation)
+        {
+            WaitObj w = new WaitObj();
+            w.Expiration = _Now + delay;
+            w.CTS = new TaskCompletionSource<bool>();
+            using (cancellation.Register(() =>
+             {
+                 w.CTS.TrySetCanceled();
+             }))
+            {
+                lock (waits)
+                {
+                    waits.Add(w);
+                }
+                await w.CTS.Task;
+            }
+        }
+
+        public async Task Advance(TimeSpan time)
+        {
+            _Now += time;
+            List<WaitObj> overdue = new List<WaitObj>();
+            lock (waits)
+            {
+                foreach (var wait in waits.ToArray())
+                {
+                    if (_Now >= wait.Expiration)
+                    {
+                        overdue.Add(wait);
+                        waits.Remove(wait);
+                    }
+                }
+            }
+            foreach (var o in overdue)
+                o.CTS.TrySetResult(true);
+            try
+            {
+                await Task.WhenAll(overdue.Select(o => o.CTS.Task).ToArray());
+            }
+            catch { }
+        }
+        public override string ToString()
+        {
+            return _Now.Millisecond.ToString(CultureInfo.InvariantCulture);
+        }
+    }
+}

BTCPayServer.Tests/Mocks/MockRateProvider.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Rating;
+using BTCPayServer.Services.Rates;
+
+namespace BTCPayServer.Tests.Mocks
+{
+    public class MockRateProvider : IRateProvider
+    {
+        public ExchangeRates ExchangeRates { get; set; } = new ExchangeRates();
+        public Task<ExchangeRates> GetRatesAsync(CancellationToken cancellationToken)
+        {
+            return Task.FromResult(ExchangeRates);
+        }
+    }
+}

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

@@ -0,0 +1,216 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Controllers;
+using BTCPayServer.Data;
+using BTCPayServer.Events;
+using BTCPayServer.Models;
+using BTCPayServer.Models.AppViewModels;
+using BTCPayServer.Models.PaymentRequestViewModels;
+using BTCPayServer.Models.StoreViewModels;
+using BTCPayServer.Payments.Changelly;
+using BTCPayServer.Payments.Changelly.Models;
+using BTCPayServer.Services.Apps;
+using BTCPayServer.Services.Invoices;
+using BTCPayServer.Services.Rates;
+using BTCPayServer.Services.Stores;
+using BTCPayServer.Tests.Logging;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using NBitcoin;
+using NBitpayClient;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace BTCPayServer.Tests
+{
+    public class PaymentRequestTests
+    {
+        public PaymentRequestTests(ITestOutputHelper helper)
+        {
+            Logs.Tester = new XUnitLog(helper) {Name = "Tests"};
+            Logs.LogProvider = new XUnitLogProvider(helper);
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public void CanCreateViewUpdateAndDeletePaymentRequest()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                user.RegisterDerivationScheme("BTC");
+
+                var user2 = tester.NewAccount();
+                user2.GrantAccess();
+
+                var paymentRequestController = user.GetController<PaymentRequestController>();
+                var guestpaymentRequestController = user2.GetController<PaymentRequestController>();
+
+                var request = new UpdatePaymentRequestViewModel()
+                {
+                    Title = "original juice",
+                    Currency = "BTC",
+                    Amount = 1,
+                    StoreId = user.StoreId,
+                    Description = "description"
+                };
+                var id = (Assert
+                    .IsType<RedirectToActionResult>(paymentRequestController.EditPaymentRequest(null, request).Result).RouteValues.Values.First().ToString());
+
+                
+
+                //permission guard for guests editing 
+                Assert
+                    .IsType<NotFoundResult>(guestpaymentRequestController.EditPaymentRequest(id).Result);
+
+                request.Title = "update";
+               Assert.IsType<RedirectToActionResult>(paymentRequestController.EditPaymentRequest(id, request).Result);
+               
+               Assert.Equal(request.Title, Assert.IsType<ViewPaymentRequestViewModel>( Assert.IsType<ViewResult>(paymentRequestController.ViewPaymentRequest(id).Result).Model).Title);
+
+                Assert.False(string.IsNullOrEmpty(id));
+
+                Assert.IsType<ViewPaymentRequestViewModel>(Assert
+                    .IsType<ViewResult>(paymentRequestController.ViewPaymentRequest(id).Result).Model);
+
+                //Delete
+
+                Assert.IsType<ConfirmModel>(Assert
+                    .IsType<ViewResult>(paymentRequestController.RemovePaymentRequestPrompt(id).Result).Model);
+
+
+                Assert.IsType<RedirectToActionResult>(paymentRequestController.RemovePaymentRequest(id).Result);
+
+                Assert
+                    .IsType<NotFoundResult>(paymentRequestController.ViewPaymentRequest(id).Result);
+            }
+        }
+
+        [Fact(Timeout = 60 * 2 * 1000)]
+        [Trait("Integration", "Integration")]
+        public async Task CanPayPaymentRequestWhenPossible()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                user.RegisterDerivationScheme("BTC");
+
+                var paymentRequestController = user.GetController<PaymentRequestController>();
+
+                Assert.IsType<NotFoundResult>(await paymentRequestController.PayPaymentRequest(Guid.NewGuid().ToString()));
+
+
+                var request = new UpdatePaymentRequestViewModel()
+                {
+                    Title = "original juice",
+                    Currency = "BTC",
+                    Amount = 1,
+                    StoreId = user.StoreId,
+                    Description = "description"
+                };
+                var response = Assert
+                    .IsType<RedirectToActionResult>(paymentRequestController.EditPaymentRequest(null, request).Result)
+                    .RouteValues.First();
+
+                var invoiceId = Assert
+                    .IsType<OkObjectResult>(await paymentRequestController.PayPaymentRequest(response.Value.ToString(), false)).Value
+                    .ToString();
+
+                var actionResult = Assert
+                    .IsType<RedirectToActionResult>(await paymentRequestController.PayPaymentRequest(response.Value.ToString()));
+
+                Assert.Equal("Checkout", actionResult.ActionName);
+                Assert.Equal("Invoice", actionResult.ControllerName);
+                Assert.Contains(actionResult.RouteValues, pair => pair.Key == "Id" && pair.Value.ToString() == invoiceId);
+
+                var invoice = user.BitPay.GetInvoice(invoiceId, Facade.Merchant);
+                Assert.Equal(1, invoice.Price);
+                
+                request = new UpdatePaymentRequestViewModel()
+                {
+                    Title = "original juice with expiry",
+                    Currency = "BTC",
+                    Amount = 1,
+                    ExpiryDate = DateTime.Today.Subtract( TimeSpan.FromDays(2)),
+                    StoreId = user.StoreId,
+                    Description = "description"
+                };
+                
+                response = Assert
+                    .IsType<RedirectToActionResult>(paymentRequestController.EditPaymentRequest(null, request).Result)
+                    .RouteValues.First();
+
+                Assert
+                    .IsType<BadRequestObjectResult>(await paymentRequestController.PayPaymentRequest(response.Value.ToString(), false));               
+                
+            }
+        }
+        
+        [Fact(Timeout = 60 * 2 * 1000)]
+        [Trait("Integration", "Integration")]
+        public async Task CanCancelPaymentWhenPossible()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                user.RegisterDerivationScheme("BTC");
+
+                var paymentRequestController = user.GetController<PaymentRequestController>();
+                
+                
+                Assert.IsType<NotFoundResult>(await 
+                    paymentRequestController.CancelUnpaidPendingInvoice(Guid.NewGuid().ToString(), false));
+
+
+                var request = new UpdatePaymentRequestViewModel()
+                {
+                    Title = "original juice",
+                    Currency = "BTC",
+                    Amount = 1,
+                    StoreId = user.StoreId,
+                    Description = "description"
+                };
+                var response = Assert
+                    .IsType<RedirectToActionResult>(paymentRequestController.EditPaymentRequest(null, request).Result)
+                    .RouteValues.First();
+
+                var paymentRequestId = response.Value.ToString();
+                
+                var invoiceId = Assert
+                    .IsType<OkObjectResult>(await paymentRequestController.PayPaymentRequest(paymentRequestId, false)).Value
+                    .ToString();
+
+                var actionResult = Assert
+                    .IsType<RedirectToActionResult>(await paymentRequestController.PayPaymentRequest(response.Value.ToString()));
+
+                Assert.Equal("Checkout", actionResult.ActionName);
+                Assert.Equal("Invoice", actionResult.ControllerName);
+                Assert.Contains(actionResult.RouteValues, pair => pair.Key == "Id" && pair.Value.ToString() == invoiceId);
+
+                var invoice = user.BitPay.GetInvoice(invoiceId, Facade.Merchant);
+Assert.Equal(InvoiceState.ToString(InvoiceStatus.New), invoice.Status);
+                Assert.IsType<OkObjectResult>(await 
+                    paymentRequestController.CancelUnpaidPendingInvoice(paymentRequestId, false));
+                
+                invoice = user.BitPay.GetInvoice(invoiceId, Facade.Merchant);
+                Assert.Equal(InvoiceState.ToString(InvoiceStatus.Invalid), invoice.Status);
+                
+                
+                Assert.IsType<BadRequestObjectResult>(await 
+                    paymentRequestController.CancelUnpaidPendingInvoice(paymentRequestId, false));
+                          
+                
+            }
+        }
+    }
+}

BTCPayServer.Tests/README.md

@@ -26,28 +26,53 @@ docker-compose down
 If you want to stop, and remove all existing data
 
 ```
-docker-compose down -v
+docker-compose down --v
 ```
 
-You can run the tests inside a container by running
+You can run tests on `MySql` database instead of `Postgres` by setting environnement variable `TESTS_DB` equals to `MySql`.
 
-```
-docker-compose run --rm tests
-```
+## How to manually test payments
 
-## Send commands to bitcoind
+### Using the test bitcoin-cli
 
 You can call bitcoin-cli inside the container with `docker exec`, for example, if you want to send `0.23111090` to `mohu16LH66ptoWGEL1GtP6KHTBJYXMWhEf`:
 ```
-docker exec -ti btcpayserver_dev_bitcoind bitcoin-cli -regtest -conf="/data/bitcoin.conf" -datadir="/data" sendtoaddress "mohu16LH66ptoWGEL1GtP6KHTBJYXMWhEf" 0.23111090
+./docker-bitcoin-cli.sh sendtoaddress "mohu16LH66ptoWGEL1GtP6KHTBJYXMWhEf" 0.23111090
+```
+
+If you are using Powershell:
+```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. 
+
+### Using the test lightning-cli
+
+If you are using Linux:
+```
+./docker-customer-lightning-cli.sh pay lnbcrt100u1pd2e6uspp5ajnadvhazjrz55twd5k6yeg9u87wpw0q2fdr7g960yl5asv5fmnqdq9d3hkccqpxmedyrk0ehw5ueqx5e0r4qrrv74cewddfcvsxaawqz7634cmjj39sqwy5tvhz0hasktkk6t9pqfdh3edmf3z09zst5y7khv3rvxh8ctqqw6mwhh
 ```
 
 If you are using Powershell:
 ```
-.\docker-bitcoin-cli.ps1 sendtoaddress "mohu16LH66ptoWGEL1GtP6KHTBJYXMWhEf" 0.23111090
+.\docker-customer-lightning-cli.ps1 pay lnbcrt100u1pd2e6uspp5ajnadvhazjrz55twd5k6yeg9u87wpw0q2fdr7g960yl5asv5fmnqdq9d3hkccqpxmedyrk0ehw5ueqx5e0r4qrrv74cewddfcvsxaawqz7634cmjj39sqwy5tvhz0hasktkk6t9pqfdh3edmf3z09zst5y7khv3rvxh8ctqqw6mwhh
 ```
 
-For sending to litecoin, use .\docker-litecoin-cli.ps1 instead.
+If you get this message:
+
+```
+{ "code" : 205, "message" : "Could not find a route", "data" : { "getroute_tries" : 1, "sendpay_tries" : 0 } }
+```
+
+Please, run the test `CanSetLightningServer`, this will establish a channel between the customer and the merchant, then, retry.
 
 ## FAQ
 

BTCPayServer.Tests/RateRulesTest.cs

@@ -0,0 +1,194 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Text;
+using BTCPayServer.Rating;
+using Xunit;
+using System.Globalization;
+
+namespace BTCPayServer.Tests
+{
+    public class RateRulesTest
+    {
+        [Fact]
+        [Trait("Fast", "Fast")]
+        public void SecondDuplicatedRuleIsIgnored()
+        {
+            StringBuilder builder = new StringBuilder();
+            builder.AppendLine("DOGE_X = 1.1");
+            builder.AppendLine("DOGE_X = 1.2");
+            Assert.True(RateRules.TryParse(builder.ToString(), out var rules));
+            var rule = rules.GetRuleFor(new CurrencyPair("DOGE", "BTC"));
+            rule.Reevaluate();
+            Assert.True(!rule.HasError);
+            Assert.Equal(1.1m, rule.BidAsk.Ask);
+        }
+
+        [Fact]
+        [Trait("Fast", "Fast")]
+        public void CanParseRateRules()
+        {
+            // Check happy path
+            StringBuilder builder = new StringBuilder();
+            builder.AppendLine("// Some cool comments");
+            builder.AppendLine("DOGE_X = DOGE_BTC * BTC_X * 1.1");
+            builder.AppendLine("DOGE_BTC = Bittrex(DOGE_BTC)");
+            builder.AppendLine("// Some other cool comments");
+            builder.AppendLine("BTC_usd = GDax(BTC_USD)");
+            builder.AppendLine("BTC_X = Coinbase(BTC_X);");
+            builder.AppendLine("X_X = CoinAverage(X_X) * 1.02");
+
+            Assert.False(RateRules.TryParse("DPW*&W&#hdi&#&3JJD", out var rules));
+            Assert.True(RateRules.TryParse(builder.ToString(), out rules));
+            Assert.Equal(
+                "// Some cool comments\n" +
+                "DOGE_X = DOGE_BTC * BTC_X * 1.1;\n" +
+                "DOGE_BTC = bittrex(DOGE_BTC);\n" +
+                "// Some other cool comments\n" +
+                "BTC_USD = gdax(BTC_USD);\n" +
+                "BTC_X = coinbase(BTC_X);\n" +
+                "X_X = coinaverage(X_X) * 1.02;",
+                rules.ToString());
+            var tests = new[]
+            {
+                (Pair: "DOGE_USD", Expected: "bittrex(DOGE_BTC) * gdax(BTC_USD) * 1.1"),
+                (Pair: "BTC_USD", Expected: "gdax(BTC_USD)"),
+                (Pair: "BTC_CAD", Expected: "coinbase(BTC_CAD)"),
+                (Pair: "DOGE_CAD", Expected: "bittrex(DOGE_BTC) * coinbase(BTC_CAD) * 1.1"),
+                (Pair: "LTC_CAD", Expected: "coinaverage(LTC_CAD) * 1.02"),
+            };
+            foreach (var test in tests)
+            {
+                Assert.Equal(test.Expected, rules.GetRuleFor(CurrencyPair.Parse(test.Pair)).ToString());
+            }
+            rules.Spread = 0.2m;
+            Assert.Equal("(bittrex(DOGE_BTC) * gdax(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("LTC_CHF = LTC_CHF * 1.01");
+            builder.AppendLine("BTC_X = Coinbase(BTC_X)");
+            Assert.True(RateRules.TryParse(builder.ToString(), out rules));
+
+            tests = new[]
+            {
+                (Pair: "LTC_CAD", Expected: "ERR_NO_RULE_MATCH(LTC_CAD)"),
+                (Pair: "DOGE_USD", Expected: "ERR_NO_RULE_MATCH(LTC_CAD) * gdax(BTC_USD) * 1.1"),
+                (Pair: "LTC_CHF", Expected: "ERR_TOO_MUCH_NESTED_CALLS(LTC_CHF) * 1.01"),
+            };
+            foreach (var test in tests)
+            {
+                Assert.Equal(test.Expected, rules.GetRuleFor(CurrencyPair.Parse(test.Pair)).ToString());
+            }
+            //////////////////
+
+            // Check if we can resolve exchange rates
+            builder = new StringBuilder();
+            builder.AppendLine("DOGE_X = DOGE_BTC * BTC_X * 1.1");
+            builder.AppendLine("DOGE_BTC = Bittrex(DOGE_BTC)");
+            builder.AppendLine("BTC_usd = GDax(BTC_USD)");
+            builder.AppendLine("BTC_X = Coinbase(BTC_X)");
+            builder.AppendLine("X_X = CoinAverage(X_X) * 1.02");
+            Assert.True(RateRules.TryParse(builder.ToString(), out rules));
+
+            var tests2 = new[]
+            {
+                (Pair: "DOGE_USD", Expected: "bittrex(DOGE_BTC) * gdax(BTC_USD) * 1.1", ExpectedExchangeRates: "bittrex(DOGE_BTC),gdax(BTC_USD)"),
+                (Pair: "BTC_USD", Expected: "gdax(BTC_USD)", ExpectedExchangeRates: "gdax(BTC_USD)"),
+                (Pair: "BTC_CAD", Expected: "coinbase(BTC_CAD)", ExpectedExchangeRates: "coinbase(BTC_CAD)"),
+                (Pair: "DOGE_CAD", Expected: "bittrex(DOGE_BTC) * coinbase(BTC_CAD) * 1.1", ExpectedExchangeRates: "bittrex(DOGE_BTC),coinbase(BTC_CAD)"),
+                (Pair: "LTC_CAD", Expected: "coinaverage(LTC_CAD) * 1.02", ExpectedExchangeRates: "coinaverage(LTC_CAD)"),
+            };
+            foreach (var test in tests2)
+            {
+                var rule = rules.GetRuleFor(CurrencyPair.Parse(test.Pair));
+                Assert.Equal(test.Expected, rule.ToString());
+                Assert.Equal(test.ExpectedExchangeRates, string.Join(',', rule.ExchangeRates.OfType<object>().ToArray()));
+            }
+            var rule2 = rules.GetRuleFor(CurrencyPair.Parse("DOGE_CAD"));
+            rule2.ExchangeRates.SetRate("bittrex", CurrencyPair.Parse("DOGE_BTC"), new BidAsk(5000m));
+            rule2.Reevaluate();
+            Assert.True(rule2.HasError);
+            Assert.Equal("5000 * ERR_RATE_UNAVAILABLE(coinbase, BTC_CAD) * 1.1", rule2.ToString(true));
+            Assert.Equal("bittrex(DOGE_BTC) * coinbase(BTC_CAD) * 1.1", rule2.ToString(false));
+            rule2.ExchangeRates.SetRate("coinbase", CurrencyPair.Parse("BTC_CAD"), new BidAsk(2000.4m));
+            rule2.Reevaluate();
+            Assert.False(rule2.HasError);
+            Assert.Equal("5000 * 2000.4 * 1.1", rule2.ToString(true));
+            Assert.Equal(rule2.BidAsk.Bid, 5000m * 2000.4m * 1.1m);
+            ////////
+
+            // Make sure parenthesis are correctly calculated
+            builder = new StringBuilder();
+            builder.AppendLine("DOGE_X = DOGE_BTC * BTC_X");
+            builder.AppendLine("BTC_USD = -3 + coinbase(BTC_CAD) + 50 - 5");
+            builder.AppendLine("DOGE_BTC = 2000");
+            Assert.True(RateRules.TryParse(builder.ToString(), out rules));
+            rules.Spread = 0.1m;
+
+            rule2 = rules.GetRuleFor(CurrencyPair.Parse("DOGE_USD"));
+            Assert.Equal("(2000 * (-3 + coinbase(BTC_CAD) + 50 - 5)) * (0.9, 1.1)", rule2.ToString());
+            rule2.ExchangeRates.SetRate("coinbase", CurrencyPair.Parse("BTC_CAD"), new BidAsk(1000m));
+            Assert.True(rule2.Reevaluate());
+            Assert.Equal("(2000 * (-3 + 1000 + 50 - 5)) * (0.9, 1.1)", rule2.ToString(true));
+            Assert.Equal((2000m * (-3m + 1000m + 50m - 5m)) * 0.9m, rule2.BidAsk.Bid);
+
+            // Test inverse
+            rule2 = rules.GetRuleFor(CurrencyPair.Parse("USD_DOGE"));
+            Assert.Equal("(1 / (2000 * (-3 + coinbase(BTC_CAD) + 50 - 5))) * (0.9, 1.1)", rule2.ToString());
+            rule2.ExchangeRates.SetRate("coinbase", CurrencyPair.Parse("BTC_CAD"), new BidAsk(1000m));
+            Assert.True(rule2.Reevaluate());
+            Assert.Equal("(1 / (2000 * (-3 + 1000 + 50 - 5))) * (0.9, 1.1)", rule2.ToString(true));
+            Assert.Equal((1.0m / (2000m * (-3m + 1000m + 50m - 5m))) * 0.9m, rule2.BidAsk.Bid);
+            ////////
+
+            // Make sure kraken is not converted to CurrencyPair
+            builder = new StringBuilder();
+            builder.AppendLine("BTC_USD = kraken(BTC_USD)");
+            Assert.True(RateRules.TryParse(builder.ToString(), out rules));
+            rule2 = rules.GetRuleFor(CurrencyPair.Parse("BTC_USD"));
+            rule2.ExchangeRates.SetRate("kraken", CurrencyPair.Parse("BTC_USD"), new BidAsk(1000m));
+            Assert.True(rule2.Reevaluate());
+
+            // Make sure can handle pairs
+            builder = new StringBuilder();
+            builder.AppendLine("BTC_USD = kraken(BTC_USD)");
+            Assert.True(RateRules.TryParse(builder.ToString(), out rules));
+            rule2 = rules.GetRuleFor(CurrencyPair.Parse("BTC_USD"));
+            rule2.ExchangeRates.SetRate("kraken", CurrencyPair.Parse("BTC_USD"), new BidAsk(6000m, 6100m));
+            Assert.True(rule2.Reevaluate());
+            Assert.Equal("(6000, 6100)", rule2.ToString(true));
+            Assert.Equal(6000m, rule2.BidAsk.Bid);
+            rule2 = rules.GetRuleFor(CurrencyPair.Parse("USD_BTC"));
+            rule2.ExchangeRates.SetRate("kraken", CurrencyPair.Parse("BTC_USD"), new BidAsk(6000m, 6100m));
+            Assert.True(rule2.Reevaluate());
+            Assert.Equal("1 / (6000, 6100)", rule2.ToString(true));
+            Assert.Equal(1m / 6100m, rule2.BidAsk.Bid);
+
+            // Make sure the inverse has more priority than X_X or CDNT_X
+            builder = new StringBuilder();
+            builder.AppendLine("EUR_CDNT = 10");
+            builder.AppendLine("CDNT_BTC = CDNT_EUR * EUR_BTC;");
+            builder.AppendLine("CDNT_X = CDNT_BTC * BTC_X;");
+            builder.AppendLine("X_X = coinaverage(X_X);");
+            Assert.True(RateRules.TryParse(builder.ToString(), out rules));
+            rule2 = rules.GetRuleFor(CurrencyPair.Parse("CDNT_EUR"));
+            rule2.ExchangeRates.SetRate("coinaverage", CurrencyPair.Parse("BTC_USD"), new BidAsk(6000m, 6100m));
+            Assert.True(rule2.Reevaluate());
+            Assert.Equal("1 / 10", rule2.ToString(false));
+
+            // Make sure an inverse can be solved on an exchange
+            builder = new StringBuilder();
+            builder.AppendLine("X_X = coinaverage(X_X);");
+            Assert.True(RateRules.TryParse(builder.ToString(), out rules));
+            rule2 = rules.GetRuleFor(CurrencyPair.Parse("USD_BTC"));
+            rule2.ExchangeRates.SetRate("coinaverage", CurrencyPair.Parse("BTC_USD"), new BidAsk(6000m, 6100m));
+            Assert.True(rule2.Reevaluate());
+            Assert.Equal($"({(1m / 6100m).ToString(CultureInfo.InvariantCulture)}, {(1m / 6000m).ToString(CultureInfo.InvariantCulture)})", rule2.ToString(true));
+        }
+    }
+}

BTCPayServer.Tests/SeleniumTester.cs

@@ -0,0 +1,143 @@
+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);
+        }
+
+        internal void GoToHome()
+        {
+            Driver.Navigate().GoToUrl(Server.PayTester.ServerUri);
+        }
+
+        internal void Logout()
+        {
+            Driver.FindElement(By.Id("Logout")).Click();
+        }
+    }
+}

BTCPayServer.Tests/SeleniumTests.cs

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

@@ -17,8 +17,13 @@ using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading.Tasks;
 using System.Threading;
-using BTCPayServer.Payments.Lightning.Eclair;
 using System.Globalization;
+using BTCPayServer.Tests.Lnd;
+using BTCPayServer.Payments.Lightning;
+using BTCPayServer.Lightning.CLightning;
+using BTCPayServer.Lightning;
+using BTCPayServer.Services;
+using BTCPayServer.Tests.Logging;
 
 namespace BTCPayServer.Tests
 {
@@ -33,6 +38,39 @@ namespace BTCPayServer.Tests
         public ServerTester(string scope)
         {
             _Directory = scope;
+            if (Directory.Exists(_Directory))
+                Utils.DeleteDirectory(_Directory);
+            if (!Directory.Exists(_Directory))
+                Directory.CreateDirectory(_Directory);
+
+            NetworkProvider = new BTCPayNetworkProvider(NetworkType.Regtest);
+            ExplorerNode = new RPCClient(RPCCredentialString.Parse(GetEnvironment("TESTS_BTCRPCCONNECTION", "server=http://127.0.0.1:43782;ceiwHEbqWI83:DwubwWsoo3")), NetworkProvider.GetNetwork<BTCPayNetwork>("BTC").NBitcoinNetwork);
+            ExplorerNode.ScanRPCCapabilities();
+            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<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<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);
+
+            MerchantCharge = new ChargeTester(this, "TEST_MERCHANTCHARGE", "type=charge;server=http://127.0.0.1:54938/;api-token=foiewnccewuify", "merchant_lightningd", btc);
+
+            MerchantLnd = new LndMockTester(this, "TEST_MERCHANTLND", "https://lnd:lnd@127.0.0.1:53280/", "merchant_lnd", btc);
+
+            PayTester = new BTCPayServerTester(Path.Combine(_Directory, "pay"))
+            {
+                NBXplorerUri = ExplorerClient.Address,
+                LTCNBXplorerUri = LTCExplorerClient.Address,
+                TestDatabase = Enum.Parse<TestDatabases>(GetEnvironment("TESTS_DB", TestDatabases.Postgres.ToString()), true),
+                Postgres = GetEnvironment("TESTS_POSTGRES", "User ID=postgres;Host=127.0.0.1;Port=39372;Database=btcpayserver"),
+                MySQL = GetEnvironment("TESTS_MYSQL", "User ID=root;Host=127.0.0.1;Port=33036;Database=btcpayserver"),
+                IntegratedLightning = MerchantCharge.Client.Uri
+            };
+            PayTester.Port = int.Parse(GetEnvironment("TESTS_PORT", Utils.FreeTcpPort().ToString(CultureInfo.InvariantCulture)), CultureInfo.InvariantCulture);
+            PayTester.HostName = GetEnvironment("TESTS_HOSTNAME", "127.0.0.1");
+            PayTester.InContainer = bool.Parse(GetEnvironment("TESTS_INCONTAINER", "false"));
         }
 
         public bool Dockerized
@@ -42,88 +80,29 @@ namespace BTCPayServer.Tests
 
         public void Start()
         {
-            if (Directory.Exists(_Directory))
-                Utils.DeleteDirectory(_Directory);
-            if (!Directory.Exists(_Directory))
-                Directory.CreateDirectory(_Directory);
-
-
-            NetworkProvider = new BTCPayNetworkProvider(ChainType.Regtest);
-            ExplorerNode = new RPCClient(RPCCredentialString.Parse(GetEnvironment("TESTS_BTCRPCCONNECTION", "server=http://127.0.0.1:43782;ceiwHEbqWI83:DwubwWsoo3")), NetworkProvider.GetNetwork("BTC").NBitcoinNetwork);
-            LTCExplorerNode = new RPCClient(RPCCredentialString.Parse(GetEnvironment("TESTS_LTCRPCCONNECTION", "server=http://127.0.0.1:43783;ceiwHEbqWI83:DwubwWsoo3")), NetworkProvider.GetNetwork("LTC").NBitcoinNetwork);
-
-            ExplorerClient = new ExplorerClient(NetworkProvider.GetNetwork("BTC").NBXplorerNetwork, new Uri(GetEnvironment("TESTS_BTCNBXPLORERURL", "http://127.0.0.1:32838/")));
-            LTCExplorerClient = new ExplorerClient(NetworkProvider.GetNetwork("LTC").NBXplorerNetwork, new Uri(GetEnvironment("TESTS_LTCNBXPLORERURL", "http://127.0.0.1:32838/")));
-
-            var btc = NetworkProvider.GetNetwork("BTC").NBitcoinNetwork;
-            CustomerEclair = new EclairTester(this, "TEST_ECLAIR", "http://eclair-cli:gpwefwmmewci@127.0.0.1:30992/", "eclair", btc);
-            MerchantCharge = new ChargeTester(this, "TEST_CHARGE", "http://api-token:foiewnccewuify@127.0.0.1:54938/", "lightning-charged", btc);
-
-            PayTester = new BTCPayServerTester(Path.Combine(_Directory, "pay"))
-            {
-                NBXplorerUri = ExplorerClient.Address,
-                LTCNBXplorerUri = LTCExplorerClient.Address,
-                Postgres = GetEnvironment("TESTS_POSTGRES", "User ID=postgres;Host=127.0.0.1;Port=39372;Database=btcpayserver"),
-                IntegratedLightning = MerchantCharge.Client.Uri
-            };
-            PayTester.Port = int.Parse(GetEnvironment("TESTS_PORT", Utils.FreeTcpPort().ToString(CultureInfo.InvariantCulture)), CultureInfo.InvariantCulture);
-            PayTester.HostName = GetEnvironment("TESTS_HOSTNAME", "127.0.0.1");
             PayTester.Start();
         }
 
-
         /// <summary>
-        /// This will setup a channel going from customer to merchant
+        /// Connect a customer LN node to the merchant LN node
         /// </summary>
-        public void PrepareLightning()
+        /// <returns></returns>
+        public async Task EnsureChannelsSetup()
         {
-            PrepareLightningAsync().GetAwaiter().GetResult();
+            Logs.Tester.LogInformation("Connecting channels");
+            await BTCPayServer.Lightning.Tests.ConnectChannels.ConnectAll(ExplorerNode, GetLightningSenderClients(), GetLightningDestClients()).ConfigureAwait(false);
+            Logs.Tester.LogInformation("Channels connected");
         }
 
-        public async Task PrepareLightningAsync()
+        private IEnumerable<ILightningClient> GetLightningSenderClients()
         {
-            // Activate segwit
-            var blockCount = ExplorerNode.GetBlockCountAsync();
-            // Fetch node info, but that in cache
-            var merchantInfo = MerchantCharge.Client.GetInfoAsync();
-            var customer = CustomerEclair.GetNodeInfoAsync();
-            var channels = CustomerEclair.RPC.ChannelsAsync();
+            yield return CustomerLightningD;
+        }
 
-            var info = await merchantInfo;
-            var clightning = new NodeInfo(info.Id, MerchantCharge.P2PHost, info.Port);
-            var connect = CustomerEclair.RPC.ConnectAsync(clightning);
-            await Task.WhenAll(blockCount, customer, channels, connect);
-
-            // If the channel is not created, let's do it
-            if (channels.Result.Length == 0)
-            {
-                var c = (await CustomerEclair.RPC.ChannelsAsync());
-                bool generated = false;
-                bool createdChannel = false;
-                CancellationTokenSource timeout = new CancellationTokenSource();
-                timeout.CancelAfter(10000);
-                while (c.Length == 0 || c[0].State != "NORMAL")
-                {
-                    if (timeout.IsCancellationRequested)
-                    {
-                        timeout = new CancellationTokenSource();
-                        timeout.CancelAfter(10000);
-                        createdChannel = c.Length == 0;
-                        generated = false;
-                    }
-                    if (!createdChannel)
-                    {
-                        await CustomerEclair.RPC.OpenAsync(clightning, Money.Satoshis(16777215));
-                        createdChannel = true;
-                    }
-                    if (!generated && c.Length != 0 && c[0].State == "WAIT_FOR_FUNDING_CONFIRMED")
-                    {
-                        ExplorerNode.Generate(6);
-                        generated = true;
-                    }
-                    c = (await CustomerEclair.RPC.ChannelsAsync());
-                }
-            }
+        private IEnumerable<ILightningClient> GetLightningDestClients()
+        {
+            yield return MerchantLightningD;
+            yield return MerchantLnd.Client;
         }
 
         public void SendLightningPayment(Invoice invoice)
@@ -135,12 +114,14 @@ namespace BTCPayServer.Tests
         {
             var bolt11 = invoice.CryptoInfo.Where(o => o.PaymentUrls.BOLT11 != null).First().PaymentUrls.BOLT11;
             bolt11 = bolt11.Replace("lightning:", "", StringComparison.OrdinalIgnoreCase);
-            await CustomerEclair.RPC.SendAsync(bolt11);
+            await CustomerLightningD.Pay(bolt11);
         }
 
-        public EclairTester MerchantEclair { get; set; }
-        public EclairTester CustomerEclair { get; set; }
+        public ILightningClient CustomerLightningD { get; set; }
+
+        public ILightningClient MerchantLightningD { get; private set; }
         public ChargeTester MerchantCharge { get; private set; }
+        public LndMockTester MerchantLnd { get; set; }
 
         internal string GetEnvironment(string variable, string defaultValue)
         {
@@ -172,106 +153,19 @@ namespace BTCPayServer.Tests
 
         HttpClient _Http = new HttpClient();
 
-        class MockHttpRequest : HttpRequest
-        {
-            Uri serverUri;
-            public MockHttpRequest(Uri serverUri)
-            {
-                this.serverUri = serverUri;
-            }
-            public override HttpContext HttpContext => throw new NotImplementedException();
-
-            public override string Method
-            {
-                get => throw new NotImplementedException();
-                set => throw new NotImplementedException();
-            }
-            public override string Scheme
-            {
-                get => serverUri.Scheme;
-                set => throw new NotImplementedException();
-            }
-            public override bool IsHttps
-            {
-                get => throw new NotImplementedException();
-                set => throw new NotImplementedException();
-            }
-            public override HostString Host
-            {
-                get => new HostString(serverUri.Host, serverUri.Port);
-                set => throw new NotImplementedException();
-            }
-            public override PathString PathBase
-            {
-                get => "";
-                set => throw new NotImplementedException();
-            }
-            public override PathString Path
-            {
-                get => throw new NotImplementedException();
-                set => throw new NotImplementedException();
-            }
-            public override QueryString QueryString
-            {
-                get => throw new NotImplementedException();
-                set => throw new NotImplementedException();
-            }
-            public override IQueryCollection Query
-            {
-                get => throw new NotImplementedException();
-                set => throw new NotImplementedException();
-            }
-            public override string Protocol
-            {
-                get => throw new NotImplementedException();
-                set => throw new NotImplementedException();
-            }
-
-            public override IHeaderDictionary Headers => throw new NotImplementedException();
-
-            public override IRequestCookieCollection Cookies
-            {
-                get => throw new NotImplementedException();
-                set => throw new NotImplementedException();
-            }
-            public override long? ContentLength
-            {
-                get => throw new NotImplementedException();
-                set => throw new NotImplementedException();
-            }
-            public override string ContentType
-            {
-                get => throw new NotImplementedException();
-                set => throw new NotImplementedException();
-            }
-            public override Stream Body
-            {
-                get => throw new NotImplementedException();
-                set => throw new NotImplementedException();
-            }
-
-            public override bool HasFormContentType => throw new NotImplementedException();
-
-            public override IFormCollection Form
-            {
-                get => throw new NotImplementedException();
-                set => throw new NotImplementedException();
-            }
-
-            public override Task<IFormCollection> ReadFormAsync(CancellationToken cancellationToken = default(CancellationToken))
-            {
-                throw new NotImplementedException();
-            }
-        }
-
-
         public BTCPayServerTester PayTester
         {
             get; set;
         }
 
+        public List<string> Stores { get; internal set; } = new List<string>();
+
         public void Dispose()
         {
+            foreach (var store in Stores)
+            {
+                Xunit.Assert.True(PayTester.StoreRepository.DeleteStore(store).GetAwaiter().GetResult());
+            }
             if (PayTester != null)
                 PayTester.Dispose();
         }

BTCPayServer.Tests/StorageTests.cs

@@ -0,0 +1,258 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using BTCPayServer.Controllers;
+using BTCPayServer.Models;
+using BTCPayServer.Models.ServerViewModels;
+using BTCPayServer.Storage.Models;
+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;
+using Microsoft.Extensions.Configuration;
+using Microsoft.VisualStudio.TestPlatform.CommunicationUtilities.Resources;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace BTCPayServer.Tests
+{
+    public class StorageTests
+    {
+        public StorageTests(ITestOutputHelper helper)
+        {
+            Logs.Tester = new XUnitLog(helper) {Name = "Tests"};
+            Logs.LogProvider = new XUnitLogProvider(helper);
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async void CanConfigureStorage()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var controller = tester.PayTester.GetController<ServerController>(user.UserId, user.StoreId);
+
+
+                //Once we select a provider, redirect to its view
+                var localResult = Assert
+                    .IsType<RedirectToActionResult>(controller.Storage(new StorageSettings()
+                    {
+                        Provider = StorageProvider.FileSystem
+                    }));
+                Assert.Equal(nameof(ServerController.StorageProvider), localResult.ActionName);
+                Assert.Equal(StorageProvider.FileSystem.ToString(), localResult.RouteValues["provider"]);
+
+
+                var AmazonS3result = Assert
+                    .IsType<RedirectToActionResult>(controller.Storage(new StorageSettings()
+                    {
+                        Provider = StorageProvider.AmazonS3
+                    }));
+                Assert.Equal(nameof(ServerController.StorageProvider), AmazonS3result.ActionName);
+                Assert.Equal(StorageProvider.AmazonS3.ToString(), AmazonS3result.RouteValues["provider"]);
+
+                var GoogleResult = Assert
+                    .IsType<RedirectToActionResult>(controller.Storage(new StorageSettings()
+                    {
+                        Provider = StorageProvider.GoogleCloudStorage
+                    }));
+                Assert.Equal(nameof(ServerController.StorageProvider), GoogleResult.ActionName);
+                Assert.Equal(StorageProvider.GoogleCloudStorage.ToString(), GoogleResult.RouteValues["provider"]);
+
+
+                var AzureResult = Assert
+                    .IsType<RedirectToActionResult>(controller.Storage(new StorageSettings()
+                    {
+                        Provider = StorageProvider.AzureBlobStorage
+                    }));
+                Assert.Equal(nameof(ServerController.StorageProvider), AzureResult.ActionName);
+                Assert.Equal(StorageProvider.AzureBlobStorage.ToString(), AzureResult.RouteValues["provider"]);
+
+                //Cool, we get redirected to the config pages
+                //Let's configure this stuff
+
+                //Let's try and cheat and go to an invalid storage provider config
+                Assert.Equal(nameof(Storage), (Assert
+                    .IsType<RedirectToActionResult>(await controller.StorageProvider("I am not a real provider"))
+                    .ActionName));
+
+                //ok no more messing around, let's configure this shit. 
+                var fileSystemStorageConfiguration = Assert.IsType<FileSystemStorageConfiguration>(Assert
+                    .IsType<ViewResult>(await controller.StorageProvider(StorageProvider.FileSystem.ToString()))
+                    .Model);
+
+                //local file system does not need config, easy days!
+                Assert.IsType<ViewResult>(
+                    await controller.EditFileSystemStorageProvider(fileSystemStorageConfiguration));
+
+                //ok cool, let's see if this got set right
+                var shouldBeRedirectingToLocalStorageConfigPage =
+                    Assert.IsType<RedirectToActionResult>(await controller.Storage());
+                Assert.Equal(nameof(StorageProvider), shouldBeRedirectingToLocalStorageConfigPage.ActionName);
+                Assert.Equal(StorageProvider.FileSystem,
+                    shouldBeRedirectingToLocalStorageConfigPage.RouteValues["provider"]);
+
+
+                //if we tell the settings page to force, it should allow us to select a new provider
+                Assert.IsType<ChooseStorageViewModel>(Assert.IsType<ViewResult>(await controller.Storage(true)).Model);
+
+                //awesome, now let's see if the files result says we're all set up
+                var viewFilesViewModel =
+                    Assert.IsType<ViewFilesViewModel>(Assert.IsType<ViewResult>(await controller.Files()).Model);
+                Assert.True(viewFilesViewModel.StorageConfigured);
+                Assert.Empty(viewFilesViewModel.Files);
+            }
+        }
+
+        [Fact]
+        [Trait("Integration", "Integration")]
+        public async void CanUseLocalProviderFiles()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var controller = tester.PayTester.GetController<ServerController>(user.UserId, user.StoreId);
+
+                var fileSystemStorageConfiguration = Assert.IsType<FileSystemStorageConfiguration>(Assert
+                    .IsType<ViewResult>(await controller.StorageProvider(StorageProvider.FileSystem.ToString()))
+                    .Model);
+                Assert.IsType<ViewResult>(
+                    await controller.EditFileSystemStorageProvider(fileSystemStorageConfiguration));
+                
+                var shouldBeRedirectingToLocalStorageConfigPage =
+                    Assert.IsType<RedirectToActionResult>(await controller.Storage());
+                Assert.Equal(nameof(StorageProvider), shouldBeRedirectingToLocalStorageConfigPage.ActionName);
+                Assert.Equal(StorageProvider.FileSystem,
+                    shouldBeRedirectingToLocalStorageConfigPage.RouteValues["provider"]);
+
+
+                await CanUploadRemoveFiles(controller);
+            }
+        }
+
+        [Fact]
+        [Trait("ExternalIntegration", "ExternalIntegration")]
+        public async Task CanUseAzureBlobStorage()
+        {
+            using (var tester = ServerTester.Create())
+            {
+                tester.Start();
+                var user = tester.NewAccount();
+                user.GrantAccess();
+                var controller = tester.PayTester.GetController<ServerController>(user.UserId, user.StoreId);
+                var azureBlobStorageConfiguration = Assert.IsType<AzureBlobStorageConfiguration>(Assert
+                    .IsType<ViewResult>(await controller.StorageProvider(StorageProvider.AzureBlobStorage.ToString()))
+                    .Model);
+
+                azureBlobStorageConfiguration.ConnectionString = GetFromSecrets("AzureBlobStorageConnectionString");
+                azureBlobStorageConfiguration.ContainerName = "testscontainer";
+                Assert.IsType<ViewResult>(
+                    await controller.EditAzureBlobStorageStorageProvider(azureBlobStorageConfiguration));
+
+
+                var shouldBeRedirectingToAzureStorageConfigPage =
+                    Assert.IsType<RedirectToActionResult>(await controller.Storage());
+                Assert.Equal(nameof(StorageProvider), shouldBeRedirectingToAzureStorageConfigPage.ActionName);
+                Assert.Equal(StorageProvider.AzureBlobStorage,
+                    shouldBeRedirectingToAzureStorageConfigPage.RouteValues["provider"]);
+
+                //seems like azure config worked, let's see if the conn string was actually saved
+
+                Assert.Equal(azureBlobStorageConfiguration.ConnectionString, Assert
+                    .IsType<AzureBlobStorageConfiguration>(Assert
+                        .IsType<ViewResult>(
+                            await controller.StorageProvider(StorageProvider.AzureBlobStorage.ToString()))
+                        .Model).ConnectionString);
+                
+                
+
+                await CanUploadRemoveFiles(controller);
+            }
+        }
+        
+        
+        private async Task CanUploadRemoveFiles(ServerController controller)
+        {
+            var fileContent = "content";
+            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);
+
+            Assert.NotEmpty(viewFilesViewModel.Files);
+            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);
+        }
+        
+        
+        
+
+      
+
+        private static string GetFromSecrets(string key)
+        {
+            var connStr = Environment.GetEnvironmentVariable($"TESTS_{key}");
+            if (!string.IsNullOrEmpty(connStr) && connStr != "none")
+                return connStr;
+            var builder = new ConfigurationBuilder();
+            builder.AddUserSecrets("AB0AC1DD-9D26-485B-9416-56A33F268117");
+            var config = builder.Build();
+            var token = config[key];
+            Assert.False(token == null, $"{key} is not set.\n Run \"dotnet user-secrets set {key} <value>\"");
+            return token;
+        }
+    }
+}

BTCPayServer.Tests/TestAccount.cs

@@ -1,4 +1,5 @@
 using BTCPayServer.Controllers;
+using System.Linq;
 using BTCPayServer.Models.AccountViewModels;
 using BTCPayServer.Models.StoreViewModels;
 using BTCPayServer.Services.Invoices;
@@ -11,6 +12,12 @@ using System.Text;
 using System.Threading.Tasks;
 using Xunit;
 using NBXplorer.DerivationStrategy;
+using BTCPayServer.Payments;
+using BTCPayServer.Payments.Lightning;
+using BTCPayServer.Tests.Logging;
+using BTCPayServer.Lightning;
+using BTCPayServer.Lightning.CLightning;
+using BTCPayServer.Data;
 
 namespace BTCPayServer.Tests
 {
@@ -41,47 +48,64 @@ namespace BTCPayServer.Tests
         public async Task GrantAccessAsync()
         {
             await RegisterAsync();
-            var store = await CreateStoreAsync();
+            await CreateStoreAsync();
+            var store = this.GetController<StoresController>();
             var pairingCode = BitPay.RequestClientAuthorization("test", Facade.Merchant);
             Assert.IsType<ViewResult>(await store.RequestPairing(pairingCode.ToString()));
             await store.Pair(pairingCode.ToString(), StoreId);
         }
-        public StoresController CreateStore()
+        public void CreateStore()
         {
-            return CreateStoreAsync().GetAwaiter().GetResult();
+            CreateStoreAsync().GetAwaiter().GetResult();
         }
 
-        public async Task<StoresController> CreateStoreAsync()
+        public void SetNetworkFeeMode(NetworkFeeMode mode)
         {
-            var store = parent.PayTester.GetController<StoresController>(UserId);
+            ModifyStore((store) =>
+            {
+                store.NetworkFeeMode = mode;
+            });
+        }
+        public void ModifyStore(Action<StoreViewModel> modify)
+        {
+            var storeController = GetController<StoresController>();
+            StoreViewModel store = (StoreViewModel)((ViewResult)storeController.UpdateStore()).Model;
+            modify(store);
+            storeController.UpdateStore(store).GetAwaiter().GetResult();
+        }
+
+        public T GetController<T>(bool setImplicitStore = true) where T : Controller
+        {
+            return parent.PayTester.GetController<T>(UserId, setImplicitStore ? StoreId : null);
+        }
+
+        public async Task CreateStoreAsync()
+        {
+            var store = this.GetController<UserStoresController>();
             await store.CreateStore(new CreateStoreViewModel() { Name = "Test Store" });
             StoreId = store.CreatedStoreId;
-            return store;
+            parent.Stores.Add(StoreId);
         }
 
         public BTCPayNetwork SupportedNetwork { get; set; }
 
-        public void RegisterDerivationScheme(string crytoCode)
+        public WalletId RegisterDerivationScheme(string crytoCode, bool segwit = false)
         {
-            RegisterDerivationSchemeAsync(crytoCode).GetAwaiter().GetResult();
+            return RegisterDerivationSchemeAsync(crytoCode, segwit).GetAwaiter().GetResult();
         }
-        public async Task RegisterDerivationSchemeAsync(string cryptoCode)
+        public async Task<WalletId> RegisterDerivationSchemeAsync(string cryptoCode, bool segwit = false)
         {
-            SupportedNetwork = parent.NetworkProvider.GetNetwork(cryptoCode);
-            var store = parent.PayTester.GetController<StoresController>(UserId);
+            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() + "-[legacy]");
-            var vm = (StoreViewModel)((ViewResult)await store.UpdateStore(StoreId)).Model;
-            vm.SpeedPolicy = SpeedPolicy.MediumSpeed;
-            await store.UpdateStore(StoreId, vm);
-
+            DerivationScheme = new DerivationStrategyFactory(SupportedNetwork.NBitcoinNetwork).Parse(ExtKey.Neuter().ToString() + (segwit ? "" : "-[legacy]"));
             await store.AddDerivationScheme(StoreId, new DerivationSchemeViewModel()
             {
-                CryptoCurrency = cryptoCode,
-                DerivationSchemeFormat = "BTCPay",
                 DerivationScheme = DerivationScheme.ToString(),
                 Confirmation = true
-            });
+            }, cryptoCode);
+
+            return new WalletId(StoreId, cryptoCode);
         }
 
         public DerivationStrategyBase DerivationScheme { get; set; }
@@ -89,15 +113,18 @@ namespace BTCPayServer.Tests
         private async Task RegisterAsync()
         {
             var account = parent.PayTester.GetController<AccountController>();
-            await account.Register(new RegisterViewModel()
+            RegisterDetails = new RegisterViewModel()
             {
                 Email = Guid.NewGuid() + "@toto.com",
                 ConfirmPassword = "Kitten0@",
                 Password = "Kitten0@",
-            });
+            };
+            await account.Register(RegisterDetails);
             UserId = account.RegisteredUserId;
         }
 
+        public RegisterViewModel RegisterDetails{ get; set; }
+
         public Bitpay BitPay
         {
             get; set;
@@ -112,19 +139,32 @@ namespace BTCPayServer.Tests
             get; set;
         }
 
-        public void RegisterLightningNode(string cryptoCode)
+        public void RegisterLightningNode(string cryptoCode, LightningConnectionType connectionType)
         {
-            RegisterLightningNodeAsync(cryptoCode).GetAwaiter().GetResult();
+            RegisterLightningNodeAsync(cryptoCode, connectionType).GetAwaiter().GetResult();
         }
 
-        public async Task RegisterLightningNodeAsync(string cryptoCode)
+        public async Task RegisterLightningNodeAsync(string cryptoCode, LightningConnectionType connectionType)
         {
-            var storeController = parent.PayTester.GetController<StoresController>(UserId);
+            var storeController = this.GetController<StoresController>();
+
+            string connectionString = null;
+            if (connectionType == LightningConnectionType.Charge)
+                connectionString = "type=charge;server=" + parent.MerchantCharge.Client.Uri.AbsoluteUri;
+            else if (connectionType == LightningConnectionType.CLightning)
+                connectionString = "type=clightning;server=" + ((CLightningClient)parent.MerchantLightningD).Address.AbsoluteUri;
+            else if (connectionType == LightningConnectionType.LndREST)
+                connectionString = $"type=lnd-rest;server={parent.MerchantLnd.Swagger.BaseUrl};allowinsecure=true";
+            else
+                throw new NotSupportedException(connectionType.ToString());
+
             await storeController.AddLightningNode(StoreId, new LightningNodeViewModel()
             {
-                CryptoCurrency = "BTC",
-                Url = parent.MerchantCharge.Client.Uri.AbsoluteUri
-            }, "save");
+                ConnectionString = connectionString,
+                SkipPortTest = true
+            }, "save", "BTC");
+            if (storeController.ModelState.ErrorCount != 0)
+                Assert.False(true, storeController.ModelState.FirstOrDefault().Value.Errors[0].ErrorMessage);
         }
     }
 }

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

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

BTCPayServer.Tests/UtilitiesTests.cs

@@ -0,0 +1,111 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Configuration;
+using NBitcoin.DataEncoders;
+using Newtonsoft.Json.Linq;
+using Xunit;
+using System.IO;
+
+namespace BTCPayServer.Tests
+{
+    /// <summary>
+    /// This class hold easy to run utilities for dev time
+    /// </summary>
+    public class UtilitiesTests
+    {
+        /// <summary>
+        /// Download transifex transactions and put them in BTCPayServer\wwwroot\locales
+        /// </summary>
+        [Trait("Utilities", "Utilities")]
+        [Fact]
+        public async Task PullTransifexTranslations()
+        {
+            // 1. Generate an API Token on https://www.transifex.com/user/settings/api/
+            // 2. Run "dotnet user-secrets set TransifexAPIToken <youapitoken>"
+            var client = new TransifexClient(GetTransifexAPIToken());
+            var json = await client.GetTransifexAsync("https://api.transifex.com/organizations/btcpayserver/projects/btcpayserver/resources/enjson/");
+            var langs = new[] { "en" }.Concat(((JObject)json["stats"]).Properties().Select(n => n.Name)).ToArray();
+
+            var langsDir = Path.Combine(Services.LanguageService.TryGetSolutionDirectoryInfo().FullName, "BTCPayServer", "wwwroot", "locales");
+
+            JObject sourceLang = null;
+            Task.WaitAll(langs.Select(async l =>
+            {
+                bool isSourceLang = l == "en";
+                var j = await client.GetTransifexAsync($"https://www.transifex.com/api/2/project/btcpayserver/resource/enjson/translation/{l}/");
+                if(!isSourceLang)
+                {
+                    while (sourceLang == null)
+                        await Task.Delay(10);
+                }
+                var content = j["content"].Value<string>();
+                if (l == "ne_NP")
+                    l = "np_NP";
+                if (l == "zh_CN")
+                    l = "zh-SP";
+                if (l == "kk")
+                    l = "kk-KZ";
+
+                var langCode = l.Replace("_", "-");
+                var langFile = Path.Combine(langsDir, langCode + ".json");
+                var jobj = JObject.Parse(content);
+                jobj["code"] = langCode;
+
+                if ((string)jobj["currentLanguage"] == "English" && !isSourceLang)
+                    return; // Not translated
+                if ((string)jobj["currentLanguage"] == "disable")
+                    return; // Not translated
+
+                jobj.AddFirst(new JProperty("NOTICE_WARN", "THIS CODE HAS BEEN AUTOMATICALLY GENERATED FROM TRANSIFEX, IF YOU WISH TO HELP TRANSLATION COME ON THE SLACK http://slack.btcpayserver.org TO REQUEST PERMISSION TO https://www.transifex.com/btcpayserver/btcpayserver/"));
+                if (isSourceLang)
+                {
+                    sourceLang = jobj;
+                }
+                else
+                {
+                    if(jobj["InvoiceExpired_Body_3"].Value<string>() == sourceLang["InvoiceExpired_Body_3"].Value<string>())
+                    {
+                        jobj["InvoiceExpired_Body_3"] = string.Empty;
+                    }
+                }
+                content = jobj.ToString(Newtonsoft.Json.Formatting.Indented);
+                File.WriteAllText(Path.Combine(langsDir, langFile), content);
+            }).ToArray());
+        }
+
+        private static string GetTransifexAPIToken()
+        {
+            var builder = new ConfigurationBuilder();
+            builder.AddUserSecrets("AB0AC1DD-9D26-485B-9416-56A33F268117");
+            var config = builder.Build();
+            var token = config["TransifexAPIToken"];
+            Assert.False(token == null, "TransifexAPIToken is not set.\n 1.Generate an API Token on https://www.transifex.com/user/settings/api/ \n 2.Run \"dotnet user-secrets set TransifexAPIToken <youapitoken>\"");
+            return token;
+        }
+    }
+
+    public class TransifexClient
+    {
+        public TransifexClient(string apiToken)
+        {
+            Client = new HttpClient();
+            APIToken = apiToken;
+        }
+
+        public HttpClient Client { get; }
+        public string APIToken { get; }
+
+        public async Task<JObject> GetTransifexAsync(string uri)
+        {
+            var message = new HttpRequestMessage(HttpMethod.Get, uri);
+            message.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", Encoders.Base64.EncodeData(Encoding.ASCII.GetBytes($"api:{APIToken}")));
+            message.Headers.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
+            var response = await Client.SendAsync(message);
+            return await response.Content.ReadAsAsync<JObject>();
+        }
+    }
+}

BTCPayServer.Tests/docker-bitcoin-cli.ps1

@@ -1 +1,2 @@
-docker exec -ti btcpayserver_dev_bitcoind bitcoin-cli -regtest -conf="/data/bitcoin.conf" -datadir="/data" $args
+$bitcoind_container_id=$(docker ps -q --filter label=com.docker.compose.project=btcpayservertests --filter label=com.docker.compose.service=bitcoind)
+docker exec -ti $bitcoind_container_id bitcoin-cli -datadir="/data" $args

BTCPayServer.Tests/docker-bitcoin-cli.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+bitcoind_container_id="$(docker ps -q --filter label=com.docker.compose.project=btcpayservertests --filter label=com.docker.compose.service=bitcoind)"
+docker exec -ti "$bitcoind_container_id" bitcoin-cli -datadir="/data" "$@"

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

@@ -1,8 +1,8 @@
 version: "3"    
 
 # Run `docker-compose up dev` for bootstrapping your development environment
-# Doing so will expose eclair API, NBXplorer, Bitcoind RPC and postgres port to the host so that tests can Run,
-# The Visual Studio launch setting `Docker-Regtest` is configured to use this environment.
+# Doing so will expose NBXplorer, Bitcoind RPC and postgres port to the host so that tests can Run,
+# The Visual Studio launch setting `Docker-regtest` is configured to use this environment.
 services:
 
   tests:
@@ -14,33 +14,65 @@ services:
       TESTS_LTCRPCCONNECTION: server=http://litecoind:43782;ceiwHEbqWI83:DwubwWsoo3
       TESTS_BTCNBXPLORERURL: http://nbxplorer:32838/
       TESTS_LTCNBXPLORERURL: http://nbxplorer:32838/
+      TESTS_DB: "Postgres"
       TESTS_POSTGRES: User ID=postgres;Host=postgres;Port=5432;Database=btcpayserver
+      TESTS_MYSQL: User ID=root;Host=mysql;Port=3306;Database=btcpayserver
       TESTS_PORT: 80
       TESTS_HOSTNAME: tests
-      TEST_ECLAIR: http://eclair-cli:gpwefwmmewci@eclair:8080/
-      TEST_CHARGE: http://api-token:foiewnccewuify@lightning-charged:9112/
+      TESTS_RUN_EXTERNAL_INTEGRATION: ${TESTS_RUN_EXTERNAL_INTEGRATION:-false}
+      TESTS_AzureBlobStorageConnectionString: ${TESTS_AzureBlobStorageConnectionString:-none}
+      TEST_MERCHANTLIGHTNINGD: "type=clightning;server=unix://etc/merchant_lightningd_datadir/lightning-rpc"
+      TEST_CUSTOMERLIGHTNINGD: "type=clightning;server=unix://etc/customer_lightningd_datadir/lightning-rpc"
+      TEST_MERCHANTCHARGE: "type=charge;server=http://lightning-charged:9112/;api-token=foiewnccewuify"
+      TEST_MERCHANTLND: "https://lnd:lnd@merchant_lnd:8080/"
+      TESTS_INCONTAINER: "true"
     expose:
       - "80"
     links:
       - dev
     extra_hosts: 
       - "tests:127.0.0.1"
+    volumes:
+      - "customer_lightningd_datadir:/etc/customer_lightningd_datadir"
+      - "merchant_lightningd_datadir:/etc/merchant_lightningd_datadir"
 
   # The dev container is not actually used, it is just handy to run `docker-compose up dev` to start all services
   dev: 
-    image: nicolasdorier/docker-bitcoin:0.16.0
+    image: btcpayserver/bitcoin:0.18.0
     environment:
+      BITCOIN_NETWORK: regtest
       BITCOIN_EXTRA_ARGS: |
-        regtest=1
+        deprecatedrpc=signrawtransaction
         connect=bitcoind:39388
     links:
       - nbxplorer
       - postgres
-      - eclair
+      - mysql
+      - customer_lightningd
+      - merchant_lightningd
       - lightning-charged
+      - customer_lnd
+      - merchant_lnd
+
+  devlnd: 
+    image: btcpayserver/bitcoin:0.18.0
+    environment:
+      BITCOIN_NETWORK: regtest
+      BITCOIN_EXTRA_ARGS: |
+        deprecatedrpc=signrawtransaction
+        connect=bitcoind:39388
+    links:
+      - nbxplorer
+      - postgres
+      - mysql
+      - customer_lnd
+      - merchant_lnd
+
+
 
   nbxplorer:
-    image: nicolasdorier/nbxplorer:1.0.1.18
+    image: nicolasdorier/nbxplorer:2.0.0.48
+    restart: unless-stopped
     ports:
       - "32838:32838"
     expose: 
@@ -63,40 +95,70 @@ services:
       - bitcoind
       - litecoind
 
+
   bitcoind:
-    container_name: btcpayserver_dev_bitcoind
-    image: nicolasdorier/docker-bitcoin:0.16.0
+    restart: unless-stopped
+    image: btcpayserver/bitcoin:0.18.0
     environment:
-      BITCOIN_EXTRA_ARGS: |
+      BITCOIN_NETWORK: regtest
+      BITCOIN_EXTRA_ARGS: |-
         rpcuser=ceiwHEbqWI83
         rpcpassword=DwubwWsoo3
-        regtest=1
-        server=1
         rpcport=43782
+        rpcbind=0.0.0.0:43782
         port=39388
         whitelist=0.0.0.0/0
-        zmqpubrawblock=tcp://0.0.0.0:29000
-        zmqpubrawtx=tcp://0.0.0.0:29000
-        txindex=1
-        # Eclair is still using addwitnessaddress
-        deprecatedrpc=addwitnessaddress 
+        zmqpubrawblock=tcp://0.0.0.0:28332
+        zmqpubrawtx=tcp://0.0.0.0:28333
+        deprecatedrpc=signrawtransaction
     ports: 
       - "43782:43782"
     expose:
       - "43782" # RPC
       - "39388" # P2P
+      - "28332" # ZMQ
+      - "28333" # ZMQ
     volumes:
       - "bitcoin_datadir:/data"
 
+  customer_lightningd:
+    image: btcpayserver/lightning:v0.7.0-1-dev
+    stop_signal: SIGKILL
+    restart: unless-stopped
+    environment: 
+      EXPOSE_TCP: "true"
+      LIGHTNINGD_OPT: |
+        bitcoin-datadir=/etc/bitcoin
+        bitcoin-rpcconnect=bitcoind
+        network=regtest
+        bind-addr=0.0.0.0
+        announce-addr=customer_lightningd
+        log-level=debug
+        funding-confirms=1
+        dev-broadcast-interval=1000
+        dev-bitcoind-poll=1
+    ports:
+      - "30992:9835" # api port
+    expose:
+      - "9735" # server port
+      - "9835" # api port
+    volumes:
+      - "bitcoin_datadir:/etc/bitcoin"
+      - "customer_lightningd_datadir:/root/.lightning"
+    links:
+      - bitcoind
+
   lightning-charged:
-    image: shesek/lightning-charge:0.3.1
+    image: shesek/lightning-charge:0.4.6-standalone
+    restart: unless-stopped
     environment:
       NETWORK: regtest
       API_TOKEN: foiewnccewuify
-      SKIP_BITCOIND: 1
       BITCOIND_RPCCONNECT: bitcoind
     volumes:
       - "bitcoin_datadir:/etc/bitcoin"
+      - "lightning_charge_datadir:/data"
+      - "merchant_lightningd_datadir:/etc/lightning"
     expose:
       - "9112" # Charge
       - "9735" # Lightning
@@ -104,39 +166,41 @@ services:
       - "54938:9112" # Charge
     links:
       - bitcoind
+      - merchant_lightningd
 
-  eclair:
-    image: acinq/eclair@sha256:758eaf02683046a096ee03390d3a54df8fcfca50883f7560ab946a36ee4e81d8
-    environment:
-      JAVA_OPTS: >
-        -Xmx512m 
-        -Declair.printToConsole 
-        -Declair.bitcoind.host=bitcoind 
-        -Declair.bitcoind.rpcport=43782 
-        -Declair.bitcoind.rpcuser=ceiwHEbqWI83 
-        -Declair.bitcoind.rpcpassword=DwubwWsoo3 
-        -Declair.bitcoind.zmq=tcp://bitcoind:29000
-        -Declair.api.enabled=true
-        -Declair.api.password=gpwefwmmewci
-        -Declair.chain=regtest
-        -Declair.api.binding-ip=0.0.0.0
-    links:
-      - bitcoind
+  merchant_lightningd:
+    image: btcpayserver/lightning:v0.7.0-1-dev
+    stop_signal: SIGKILL
+    environment: 
+      EXPOSE_TCP: "true"
+      LIGHTNINGD_OPT: |
+        bitcoin-datadir=/etc/bitcoin
+        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
     ports:
-      - "30992:8080" # api port
+      - "30993:9835" # api port
     expose:
       - "9735" # server port
-      - "8080" # api port
+      - "9835" # api port
+    volumes:
+      - "bitcoin_datadir:/etc/bitcoin"
+      - "merchant_lightningd_datadir:/root/.lightning"
+    links:
+      - bitcoind
 
   litecoind:
-    container_name: btcpayserver_dev_litecoind
-    image: nicolasdorier/docker-litecoin:0.14.2
+    restart: unless-stopped
+    image: nicolasdorier/docker-litecoin:0.16.3
     environment:
-      BITCOIN_EXTRA_ARGS: |
+      BITCOIN_EXTRA_ARGS: |-
         rpcuser=ceiwHEbqWI83
         rpcpassword=DwubwWsoo3
         regtest=1
-        server=1
         rpcport=43782
         port=39388
         whitelist=0.0.0.0/0
@@ -152,6 +216,83 @@ services:
       - "39372:5432"
     expose:
       - "5432"
+      
+  mysql:
+    image:  mysql:8.0.12
+    expose:
+      - "3306"
+    ports:
+      - "33036:3306"
+    environment:
+      - MYSQL_ALLOW_EMPTY_PASSWORD=yes
+
+  merchant_lnd:
+    image: btcpayserver/lnd:v0.6-beta
+    restart: unless-stopped
+    environment:
+      LND_CHAIN: "btc"
+      LND_ENVIRONMENT: "regtest"
+      LND_EXPLORERURL: "http://nbxplorer:32838/"
+      LND_EXTRA_ARGS: |
+        restlisten=0.0.0.0:8080
+        rpclisten=127.0.0.1:10008
+        rpclisten=0.0.0.0:10009
+        bitcoin.node=bitcoind
+        bitcoind.rpchost=bitcoind:43782
+        bitcoind.zmqpubrawblock=tcp://bitcoind:28332
+        bitcoind.zmqpubrawtx=tcp://bitcoind:28333
+        externalip=merchant_lnd:9735
+        bitcoin.defaultchanconfs=1
+        no-macaroons=1
+        debuglevel=debug
+        noseedbackup=1
+        trickledelay=1000
+    ports:
+      - "53280:8080"
+    expose:
+      - "9735"
+    volumes:
+      - "merchant_lnd_datadir:/data"
+      - "bitcoin_datadir:/deps/.bitcoin"
+    links:
+      - bitcoind
+
+  customer_lnd:
+    image: btcpayserver/lnd:v0.6-beta
+    restart: unless-stopped
+    environment:
+      LND_CHAIN: "btc"
+      LND_ENVIRONMENT: "regtest"
+      LND_EXPLORERURL: "http://nbxplorer:32838/"
+      LND_EXTRA_ARGS: |
+        restlisten=0.0.0.0:8080
+        rpclisten=127.0.0.1:10008
+        rpclisten=0.0.0.0:10009
+        bitcoin.node=bitcoind
+        bitcoind.rpchost=bitcoind:43782
+        bitcoind.zmqpubrawblock=tcp://bitcoind:28332
+        bitcoind.zmqpubrawtx=tcp://bitcoind:28333
+        externalip=customer_lnd:10009
+        bitcoin.defaultchanconfs=1
+        no-macaroons=1
+        debuglevel=debug
+        noseedbackup=1
+        trickledelay=1000
+    ports:
+      - "53281:8080"
+    expose:
+      - "8080"
+      - "10009"
+    volumes:
+      - "customer_lnd_datadir:/root/.lnd"
+      - "bitcoin_datadir:/deps/.bitcoin"
+    links:
+      - bitcoind
 
 volumes:
     bitcoin_datadir:
+    customer_lightningd_datadir:
+    merchant_lightningd_datadir:
+    lightning_charge_datadir:
+    customer_lnd_datadir:
+    merchant_lnd_datadir:

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

@@ -0,0 +1,2 @@
+$customer_lightning_container_id=$(docker ps -q --filter label=com.docker.compose.project=btcpayservertests --filter label=com.docker.compose.service=customer_lightningd)
+docker exec -ti $customer_lightning_container_id lightning-cli $args

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

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+customer_lightning_container_id="$(docker ps -q --filter label=com.docker.compose.project=btcpayservertests --filter label=com.docker.compose.service=customer_lightningd)"
+docker exec -ti $customer_lightning_container_id lightning-cli "$@"

BTCPayServer.Tests/docker-entrypoint.sh

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

BTCPayServer.Tests/docker-litecoin-cli.ps1

@@ -1 +1,2 @@
-docker exec -ti btcpayserver_dev_litecoind litecoin-cli -regtest -conf="/data/litecoin.conf" -datadir="/data" $args
+$litecoind_container_id=$(docker ps -q --filter label=com.docker.compose.project=btcpayservertests --filter label=com.docker.compose.service=litecoind)
+docker exec -ti $litecoind_container_id litecoin-cli -datadir="/data" $args

BTCPayServer.Tests/docker-litecoin-cli.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+litecoind_container_id="$(docker ps -q --filter label=com.docker.compose.project=btcpayservertests --filter label=com.docker.compose.service=litecoind)"
+docker exec -ti "$litecoind_container_id" litecoin-cli -datadir="/data" "$@"

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

@@ -0,0 +1,2 @@
+$merchant_lightning_container_id=$(docker ps -q --filter label=com.docker.compose.project=btcpayservertests --filter label=com.docker.compose.service=merchant_lightningd)
+docker exec -ti $merchant_lightning_container_id lightning-cli $args

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

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+merchant_lightning_container_id="$(docker ps -q --filter label=com.docker.compose.project=btcpayservertests --filter label=com.docker.compose.service=merchant_lightningd)"
+docker exec -ti $merchant_lightning_container_id lightning-cli "$@"

BTCPayServer.Tests/xunit.runner.json

@@ -0,0 +1,5 @@
+{
+    "parallelizeTestCollections": false,
+    "longRunningTestSeconds": 60,
+    "diagnosticMessages": true
+}

BTCPayServer/Authentication/BitIdentity.cs

@@ -1,35 +0,0 @@
-using NBitcoin;
-using NBitcoin.DataEncoders;
-using System;
-using System.Collections.Generic;
-using System.Security.Principal;
-using System.Text;
-
-namespace BTCPayServer.Authentication
-{
-    public class BitIdentity : IIdentity
-    {
-        public BitIdentity(PubKey key)
-        {
-            PubKey = key;
-            _Name = Encoders.Base58Check.EncodeData(Encoders.Hex.DecodeData("0f02" + key.Hash.ToString()));
-            SIN = NBitpayClient.Extensions.BitIdExtensions.GetBitIDSIN(key);
-        }
-        string _Name;
-
-        public string SIN
-        {
-            get;
-        }
-        public PubKey PubKey
-        {
-            get;
-        }
-
-        public string AuthenticationType => "BitID";
-
-        public bool IsAuthenticated => true;
-
-        public string Name => _Name;
-    }
-}

BTCPayServer/Authentication/BitToken.cs

@@ -8,10 +8,6 @@ namespace BTCPayServer.Authentication
 {
     public class BitTokenEntity
     {
-        public string Facade
-        {
-            get; set;
-        }
         public string Value
         {
             get; set;
@@ -39,7 +35,6 @@ namespace BTCPayServer.Authentication
             return new BitTokenEntity()
             {
                 Label = Label,
-                Facade = Facade,
                 StoreId = StoreId,
                 PairingTime = PairingTime,
                 SIN = SIN,

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

@@ -11,11 +11,6 @@ namespace BTCPayServer.Authentication
             get;
             set;
         }
-        public string Facade
-        {
-            get;
-            set;
-        }
         public string Label
         {
             get;

BTCPayServer/Authentication/TokenRepository.cs

@@ -1,5 +1,5 @@
 using BTCPayServer.Data;
-using DBreeze;
+using DBriize;
 using NBitcoin;
 using NBitcoin.DataEncoders;
 using Newtonsoft.Json;
@@ -33,6 +33,8 @@ namespace BTCPayServer.Authentication
 
         public async Task<BitTokenEntity[]> GetTokens(string sin)
         {
+            if (sin == null)
+                return Array.Empty<BitTokenEntity>();
             using (var ctx = _Factory.CreateContext())
             {
                 return (await ctx.PairedSINData
@@ -43,12 +45,51 @@ namespace BTCPayServer.Authentication
             }
         }
 
+        public async Task<String> GetStoreIdFromAPIKey(string apiKey)
+        {
+            using (var ctx = _Factory.CreateContext())
+            {
+                return await ctx.ApiKeys.Where(o => o.Id == apiKey).Select(o => o.StoreId).FirstOrDefaultAsync();
+            }
+        }
+
+        public async Task GenerateLegacyAPIKey(string storeId)
+        {
+            // It is legacy support and Bitpay generate string of unknown format, trying to replicate them
+            // as good as possible. The string below got generated for me.
+            var chars = "ERo0vkBMOYhyU0ZHvirCplbLDIGWPdi1ok77VnW7QdE";
+            var rand = new Random(Math.Abs(RandomUtils.GetInt32()));
+            var generated = new char[chars.Length];
+            for (int i = 0; i < generated.Length; i++)
+            {
+                generated[i] = chars[rand.Next(0, generated.Length)];
+            }
+
+            using (var ctx = _Factory.CreateContext())
+            {
+                var existing = await ctx.ApiKeys.Where(o => o.StoreId == storeId).FirstOrDefaultAsync();
+                if (existing != null)
+                {
+                    ctx.ApiKeys.Remove(existing);
+                }
+                ctx.ApiKeys.Add(new APIKeyData() { Id = new string(generated), StoreId = storeId });
+                await ctx.SaveChangesAsync().ConfigureAwait(false);
+            }
+        }
+
+        public async Task<string[]> GetLegacyAPIKeys(string storeId)
+        {
+            using (var ctx = _Factory.CreateContext())
+            {
+                return await ctx.ApiKeys.Where(o => o.StoreId == storeId).Select(c => c.Id).ToArrayAsync();
+            }
+        }
+
         private BitTokenEntity CreateTokenEntity(PairedSINData data)
         {
             return new BitTokenEntity()
             {
                 Label = data.Label,
-                Facade = data.Facade,
                 Value = data.Id,
                 SIN = data.SIN,
                 PairingTime = data.PairingTime,
@@ -87,7 +128,6 @@ namespace BTCPayServer.Authentication
             {
                 var pairingCode = await ctx.PairingCodes.FindAsync(pairingCodeEntity.Id);
                 pairingCode.Label = pairingCodeEntity.Label;
-                pairingCode.Facade = pairingCodeEntity.Facade;
                 await ctx.SaveChangesAsync();
                 return CreatePairingCodeEntity(pairingCode);
             }
@@ -136,7 +176,6 @@ namespace BTCPayServer.Authentication
                 {
                     Id = pairingCode.TokenValue,
                     PairingTime = DateTime.UtcNow,
-                    Facade = pairingCode.Facade,
                     Label = pairingCode.Label,
                     StoreDataId = pairingCode.StoreDataId,
                     SIN = pairingCode.SIN
@@ -171,7 +210,6 @@ namespace BTCPayServer.Authentication
                 return null;
             return new PairingCodeEntity()
             {
-                Facade = data.Facade,
                 Id = data.Id,
                 Label = data.Label,
                 Expiration = data.Expiration,
@@ -200,6 +238,8 @@ namespace BTCPayServer.Authentication
             using (var ctx = _Factory.CreateContext())
             {
                 var token = await ctx.PairedSINData.FindAsync(tokenId);
+                if (token == null)
+                    return null;
                 return CreateTokenEntity(token);
             }
         }

BTCPayServer/BTCPayNetwork.cs

@@ -1,78 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using BTCPayServer.Services.Invoices;
-using BTCPayServer.Services.Rates;
-using NBitcoin;
-using NBXplorer;
-
-namespace BTCPayServer
-{
-    public class BTCPayDefaultSettings
-    {
-        static BTCPayDefaultSettings()
-        {
-            _Settings = new Dictionary<ChainType, BTCPayDefaultSettings>();
-            foreach (var chainType in new[] { ChainType.Main, ChainType.Test, ChainType.Regtest })
-            {
-                var btcNetwork = (chainType == ChainType.Main ? Network.Main :
-                                  chainType == ChainType.Regtest ? Network.RegTest :
-                                  chainType == ChainType.Test ? Network.TestNet : throw new NotSupportedException(chainType.ToString()));
-
-                var settings = new BTCPayDefaultSettings();
-                _Settings.Add(chainType, settings);
-                settings.ChainType = chainType;
-                settings.DefaultDataDirectory = StandardConfiguration.DefaultDataDirectory.GetDirectory("BTCPayServer", btcNetwork.Name);
-                settings.DefaultConfigurationFile = Path.Combine(settings.DefaultDataDirectory, "settings.config");
-                settings.DefaultPort = (chainType == ChainType.Main ? 23000 :
-                                                      chainType == ChainType.Regtest ? 23002 :
-                                                      chainType == ChainType.Test ? 23001 : throw new NotSupportedException(chainType.ToString()));
-            }
-        }
-
-        static Dictionary<ChainType, BTCPayDefaultSettings> _Settings;
-
-        public static BTCPayDefaultSettings GetDefaultSettings(ChainType chainType)
-        {
-            return _Settings[chainType];
-        }
-
-        public string DefaultDataDirectory { get; set; }
-        public string DefaultConfigurationFile { get; set; }
-        public ChainType ChainType { get; internal set; }
-        public int DefaultPort { get; set; }
-    }
-    public class BTCPayNetwork
-    {
-        public Network NBitcoinNetwork { get; set; }
-        public string CryptoCode { get; internal set; }
-        public string BlockExplorerLink { get; internal set; }
-        public string UriScheme { get; internal set; }
-        public IRateProvider DefaultRateProvider { get; set; }
-
-        [Obsolete("Should not be needed")]
-        public bool IsBTC
-        {
-            get
-            {
-                return CryptoCode == "BTC";
-            }
-        }
-
-        public string CryptoImagePath { get; set; }
-        public string LightningImagePath { get; set; }
-        public NBXplorer.NBXplorerNetwork NBXplorerNetwork { get; set; }
-
-        public BTCPayDefaultSettings DefaultSettings { get; set; }
-        public KeyPath CoinType { get; internal set; }
-        public int MaxTrackedConfirmation { get; internal set; } = 6;
-        public string CLightningNetworkName { get; internal set; }
-
-        public override string ToString()
-        {
-            return CryptoCode;
-        }        
-    }
-}

BTCPayServer/BTCPayNetworkProvider.Bitcoin.cs

@@ -1,38 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using BTCPayServer.Services.Rates;
-using NBitcoin;
-using NBitpayClient;
-using NBXplorer;
-
-namespace BTCPayServer
-{
-    public partial class BTCPayNetworkProvider
-    {
-        public void InitBitcoin()
-        {
-            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("BTC");
-            var coinaverage = new CoinAverageRateProvider("BTC");
-            var bitpay = new BitpayRateProvider(new Bitpay(new Key(), new Uri("https://bitpay.com/")));
-            var btcRate = new FallbackRateProvider(new IRateProvider[] { coinaverage, bitpay });
-            Add(new BTCPayNetwork()
-            {
-                CryptoCode = nbxplorerNetwork.CryptoCode,
-                BlockExplorerLink = NBXplorerNetworkProvider.ChainType == ChainType.Main ? "https://www.smartbit.com.au/tx/{0}" : "https://testnet.smartbit.com.au/tx/{0}",
-                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
-                NBXplorerNetwork = nbxplorerNetwork,
-                UriScheme = "bitcoin",
-                DefaultRateProvider = btcRate,
-                CryptoImagePath = "imlegacy/bitcoin-symbol.svg",
-                LightningImagePath = "imlegacy/btc-lightning.svg",
-                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NBXplorerNetworkProvider.ChainType),
-                CoinType = NBXplorerNetworkProvider.ChainType == ChainType.Main ? new KeyPath("0'") : new KeyPath("1'"),
-                CLightningNetworkName = ChainType == ChainType.Main ? "bitcoin" :
-                                        ChainType == ChainType.Test ? "testnet" :
-                                        ChainType == ChainType.Regtest ? "regtest" : null
-            });
-        }
-    }
-}

BTCPayServer/BTCPayNetworkProvider.Litecoin.cs

@@ -1,36 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using BTCPayServer.Services.Rates;
-using NBitcoin;
-using NBXplorer;
-
-namespace BTCPayServer
-{
-    public partial class BTCPayNetworkProvider
-    {
-        public void InitLitecoin()
-        {
-            NBXplorer.Altcoins.Litecoin.Networks.EnsureRegistered();
-            var ltcRate = new CoinAverageRateProvider("LTC");
-
-            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("LTC");
-            Add(new BTCPayNetwork()
-            {
-                CryptoCode = nbxplorerNetwork.CryptoCode,
-                BlockExplorerLink = NBXplorerNetworkProvider.ChainType == ChainType.Main ? "https://live.blockcypher.com/ltc/tx/{0}/" : "http://explorer.litecointools.com/tx/{0}",
-                NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
-                NBXplorerNetwork = nbxplorerNetwork,
-                UriScheme = "litecoin",
-                DefaultRateProvider = ltcRate,
-                CryptoImagePath = "imlegacy/litecoin-symbol.svg",
-                LightningImagePath = "imlegacy/ltc-lightning.svg",
-                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NBXplorerNetworkProvider.ChainType),
-                CoinType = NBXplorerNetworkProvider.ChainType == ChainType.Main ? new KeyPath("2'") : new KeyPath("3'"),
-                CLightningNetworkName = ChainType == ChainType.Main ? "litecoin" :
-                                        ChainType == ChainType.Test ? "litecoin-testnet" : null
-            });
-        }
-    }
-}

BTCPayServer/BTCPayNetworkProvider.cs

@@ -1,92 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using BTCPayServer.Services.Rates;
-using Microsoft.Extensions.Caching.Memory;
-using NBitcoin;
-using NBitpayClient;
-using NBXplorer;
-
-namespace BTCPayServer
-{
-    public partial class BTCPayNetworkProvider
-    {
-        Dictionary<string, BTCPayNetwork> _Networks = new Dictionary<string, BTCPayNetwork>();
-
-
-        private readonly NBXplorerNetworkProvider _NBXplorerNetworkProvider;
-        public NBXplorerNetworkProvider NBXplorerNetworkProvider
-        {
-            get
-            {
-                return _NBXplorerNetworkProvider;
-            }
-        }
-
-        BTCPayNetworkProvider(BTCPayNetworkProvider filtered, string[] cryptoCodes)
-        {
-            ChainType = filtered.ChainType;
-            _NBXplorerNetworkProvider = new NBXplorerNetworkProvider(filtered.ChainType);
-            _Networks = new Dictionary<string, BTCPayNetwork>();
-            cryptoCodes = cryptoCodes.Select(c => c.ToUpperInvariant()).ToArray();
-            foreach (var network in filtered._Networks)
-            {
-                if(cryptoCodes.Contains(network.Key))
-                {
-                    _Networks.Add(network.Key, network.Value);
-                }
-            }
-        }
-
-        public ChainType ChainType { get; set; }
-        public BTCPayNetworkProvider(ChainType chainType)
-        {
-            _NBXplorerNetworkProvider = new NBXplorerNetworkProvider(chainType);
-            ChainType = chainType;
-            InitBitcoin();
-            InitLitecoin();
-        }
-
-        /// <summary>
-        /// Keep only the specified crypto
-        /// </summary>
-        /// <param name="cryptoCodes">Crypto to support</param>
-        /// <returns></returns>
-        public BTCPayNetworkProvider Filter(string[] cryptoCodes)
-        {
-            return new BTCPayNetworkProvider(this, cryptoCodes);
-        }
-
-        [Obsolete("To use only for legacy stuff")]
-        public BTCPayNetwork BTC
-        {
-            get
-            {
-                return GetNetwork("BTC");
-            }
-        }
-
-        public void Add(BTCPayNetwork network)
-        {
-            _Networks.Add(network.CryptoCode.ToUpperInvariant(), network);
-        }
-
-        public IEnumerable<BTCPayNetwork> GetAll()
-        {
-            return _Networks.Values.ToArray();
-        }
-
-        public bool Support(string cryptoCode)
-        {
-            return _Networks.ContainsKey(cryptoCode.ToUpperInvariant());
-        }
-
-        public BTCPayNetwork GetNetwork(string cryptoCode)
-        {
-            _Networks.TryGetValue(cryptoCode.ToUpperInvariant(), out BTCPayNetwork network);
-            return network;
-        }
-    }
-}

BTCPayServer/BTCPayServer.csproj

@@ -1,68 +1,86 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
+<Project Sdk="Microsoft.NET.Sdk.Web">
+  <Import Project="../Version.csproj" Condition="Exists('../Version.csproj')" />
+  <Import Project="../Common.csproj" />
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp2.0</TargetFramework>
-		<Version>1.0.1.44</Version>
-    <NoWarn>NU1701,CA1816,CA1308,CA1810,CA2208</NoWarn>
   </PropertyGroup>
   <ItemGroup>
     <Compile Remove="Build\dockerfiles\**" />
     <Compile Remove="wwwroot\bundles\jqueryvalidate\**" />
+    <Compile Remove="wwwroot\css\**" />
+    <Compile Remove="wwwroot\vendor\jquery-nice-select\**" />
     <Content Remove="Build\dockerfiles\**" />
     <Content Remove="wwwroot\bundles\jqueryvalidate\**" />
+    <Content Remove="wwwroot\css\**" />
+    <Content Remove="wwwroot\vendor\jquery-nice-select\**" />
     <EmbeddedResource Remove="Build\dockerfiles\**" />
     <EmbeddedResource Remove="wwwroot\bundles\jqueryvalidate\**" />
+    <EmbeddedResource Remove="wwwroot\css\**" />
+    <EmbeddedResource Remove="wwwroot\vendor\jquery-nice-select\**" />
     <None Remove="Build\dockerfiles\**" />
     <None Remove="wwwroot\bundles\jqueryvalidate\**" />
+    <None Remove="wwwroot\css\**" />
+    <None Remove="wwwroot\vendor\jquery-nice-select\**" />
   </ItemGroup>
   <ItemGroup>
     <None Remove="Currencies.txt" />
   </ItemGroup>
   <ItemGroup>
+    <EmbeddedResource Include="bundleconfig.json" />
     <EmbeddedResource Include="Currencies.txt" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="BuildBundlerMinifier" Version="2.6.362" />
-    <PackageReference Include="Hangfire" Version="1.6.17" />
-    <PackageReference Include="Hangfire.MemoryStorage" Version="1.5.2" />
-    <PackageReference Include="Hangfire.PostgreSql" Version="1.4.8.1" />
-    <PackageReference Include="LedgerWallet" Version="1.0.1.32" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="2.6.1" />
-    <PackageReference Include="Meziantou.AspNetCore.BundleTagHelpers" Version="1.0.1" />
+    <PackageReference Include="BTCPayServer.Lightning.All" Version="1.1.0.19" />
+    <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="HtmlSanitizer" Version="4.0.207" />
+    <PackageReference Include="LedgerWallet" Version="2.0.0.3" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
     <PackageReference Include="Microsoft.Extensions.Logging.Filter" Version="1.1.2" />
-    <PackageReference Include="Microsoft.NetCore.Analyzers" Version="2.6.0" />
-    <PackageReference Include="NBitcoin" Version="4.0.0.59" />
-    <PackageReference Include="NBitpayClient" Version="1.0.0.18" />	  
-    <PackageReference Include="DBreeze" Version="1.87.0" />
-    <PackageReference Include="NBXplorer.Client" Version="1.0.1.14" />
-    <PackageReference Include="NicolasDorier.CommandLine" Version="1.0.0.1" />
-    <PackageReference Include="NicolasDorier.CommandLine.Configuration" Version="1.0.0.2" />
-    <PackageReference Include="NicolasDorier.StandardConfiguration" Version="1.0.0.13" />
-    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="2.0.1" />
-    <PackageReference Include="System.ValueTuple" Version="4.4.0" />
-    <PackageReference Include="System.Xml.XmlSerializer" Version="4.0.11" />
-    <PackageReference Include="Text.Analyzers" Version="2.6.0" />
+    <PackageReference Include="Microsoft.NetCore.Analyzers" Version="2.6.2">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="NBitpayClient" Version="1.0.0.34" />	  
+    <PackageReference Include="DBriize" Version="1.0.0.4" />
+    <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.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" />
+    <PackageReference Include="Serilog.Sinks.File" Version="4.0.0" />
+    <PackageReference Include="SSH.NET" Version="2016.1.0" />
+    <PackageReference Include="Text.Analyzers" Version="2.6.2">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
   </ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="Microsoft.AspNetCore.All" Version="2.0.5" />
-		<PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="2.0.1" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.AspNetCore.App" Version="2.1.9" />
+    <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>
 
 	<ItemGroup>
-		<DotNetCliToolReference Include="Microsoft.EntityFrameworkCore.Tools.DotNet" Version="2.0.0" />
-		<DotNetCliToolReference Include="Microsoft.Extensions.SecretManager.Tools" Version="2.0.0" />
 		<DotNetCliToolReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Tools" Version="2.0.0" />
 	</ItemGroup>
 
 	<ItemGroup>
-	  <None Include="wwwroot\js\core.js" />
-	  <None Include="wwwroot\js\creative.js" />
-	  <None Include="wwwroot\js\creative.min.js" />
-	  <None Include="wwwroot\js\site.js" />
-	  <None Include="wwwroot\js\site.min.js" />
-	  <None Include="wwwroot\vendor\bootstrap\js\bootstrap.js" />
-	  <None Include="wwwroot\vendor\bootstrap\js\bootstrap.min.js" />
+	  <None Include="wwwroot\checkout\js\core.js" />
+	  <None Include="wwwroot\vendor\bootstrap4-creativestart\creative.js" />
 	  <None Include="wwwroot\vendor\font-awesome\fonts\fontawesome-webfont.svg" />
 	  <None Include="wwwroot\vendor\font-awesome\fonts\fontawesome-webfont.woff2" />
 	  <None Include="wwwroot\vendor\font-awesome\less\animated.less" />
@@ -108,12 +126,88 @@
 
 	<ItemGroup>
 	  <Folder Include="Build\" />
+	  <Folder Include="U2F\Services" />
 	  <Folder Include="wwwroot\vendor\clipboard.js\" />
+	  <Folder Include="wwwroot\vendor\highlightjs\" />
+	  <Folder Include="wwwroot\vendor\summernote" />
+	  <Folder Include="wwwroot\vendor\u2f" />
 	</ItemGroup>
 
 	<ItemGroup>
-	  <None Update="devtest.pfx">
-	    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-	  </None>
+	  <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>
+      <Pack>$(IncludeRazorContentInPack)</Pack>
+    </Content>
+    <Content Update="Views\Home\BitpayTranslator.cshtml">
+      <Pack>$(IncludeRazorContentInPack)</Pack>
+    </Content>
+    <Content Update="Views\Server\LightningChargeServices.cshtml">
+      <Pack>$(IncludeRazorContentInPack)</Pack>
+    </Content>
+    <Content Update="Views\Server\LightningWalletServices.cshtml">
+      <Pack>$(IncludeRazorContentInPack)</Pack>
+    </Content>
+    <Content Update="Views\Server\P2PService.cshtml">
+      <Pack>$(IncludeRazorContentInPack)</Pack>
+    </Content>
+    <Content Update="Views\Server\SSHService.cshtml">
+      <Pack>$(IncludeRazorContentInPack)</Pack>
+    </Content>
+    <Content Update="Views\Stores\ShowToken.cshtml">
+      <Pack>$(IncludeRazorContentInPack)</Pack>
+    </Content>
+    <Content Update="Views\Stores\PayButtonEnable.cshtml">
+      <Pack>$(IncludeRazorContentInPack)</Pack>
+    </Content>
+	  <Content Update="Views\Stores\PayButton.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
+	  <Content Update="Views\Public\PayButtonHandle.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
+	  <Content Update="Views\Server\LndServices.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
+	  <Content Update="Views\Server\Maintenance.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
+	  <Content Update="Views\Server\Services.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
+	  <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>
+	  <Content Update="Views\Wallets\WalletSendLedger.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
+	  <Content Update="Views\Wallets\WalletTransactions.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
+	  <Content Update="Views\Wallets\_Nav.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
+	  <Content Update="Views\Wallets\_ViewImports.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
+	  <Content Update="Views\Wallets\_ViewStart.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
 	</ItemGroup>
 </Project>

BTCPayServer/Configuration/BTCPayServerOptions.cs

@@ -6,10 +6,10 @@ 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.SSH;
+using BTCPayServer.Lightning;
+using Serilog.Events;
 
 namespace BTCPayServer.Configuration
 {
@@ -22,7 +22,7 @@ namespace BTCPayServer.Configuration
 
     public class BTCPayServerOptions
     {
-        public ChainType ChainType
+        public NetworkType NetworkType
         {
             get; set;
         }
@@ -31,59 +31,230 @@ namespace BTCPayServer.Configuration
             get;
             private set;
         }
+
+        public string LogFile
+        {
+            get;
+            private set;
+        }
         public string DataDir
         {
             get;
             private set;
         }
-        public List<IPEndPoint> Listen
-        {
-            get;
-            set;
-        }
-
+        public EndPoint SocksEndpoint { get; set; }
+        
         public List<NBXplorerConnectionSetting> NBXplorerConnectionSettings
         {
             get;
             set;
         } = new List<NBXplorerConnectionSetting>();
 
+        public bool DisableRegistration
+        {
+            get;
+            private set;
+        }
+
+        public static string GetDebugLog(IConfiguration configuration)
+        {
+            return configuration.GetValue<string>("debuglog", null);
+        }
+        public static LogEventLevel GetDebugLogLevel(IConfiguration configuration)
+        {
+            var raw = configuration.GetValue("debugloglevel", nameof(LogEventLevel.Debug));
+            return (LogEventLevel)Enum.Parse(typeof(LogEventLevel), raw, true);
+        }
+
         public void LoadArgs(IConfiguration conf)
         {
-            ChainType = DefaultConfiguration.GetChainType(conf);
-            var defaultSettings = BTCPayDefaultSettings.GetDefaultSettings(ChainType);
-            DataDir = conf.GetOrDefault<string>("datadir", defaultSettings.DefaultDataDirectory);
-            Logs.Configuration.LogInformation("Network: " + ChainType.ToString());
+            NetworkType = DefaultConfiguration.GetNetworkType(conf);
+            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(ChainType).Filter(supportedChains.ToArray());
+            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;
                 setting.ExplorerUri = conf.GetOrDefault<Uri>($"{net.CryptoCode}.explorer.url", net.NBXplorerNetwork.DefaultSettings.DefaultUrl);
                 setting.CookieFile = conf.GetOrDefault<string>($"{net.CryptoCode}.explorer.cookiefile", net.NBXplorerNetwork.DefaultSettings.DefaultCookieFile);
                 NBXplorerConnectionSettings.Add(setting);
+
+                {
+                    var lightning = conf.GetOrDefault<string>($"{net.CryptoCode}.lightning", string.Empty);
+                    if (lightning.Length != 0)
+                    {
+                        if (!LightningConnectionString.TryParse(lightning, true, out var connectionString, out var error))
+                        {
+                            Logs.Configuration.LogWarning($"Invalid setting {net.CryptoCode}.lightning, " + Environment.NewLine +
+                                $"If you have a c-lightning server use: 'type=clightning;server=/root/.lightning/lightning-rpc', " + Environment.NewLine +
+                                $"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");
+                        }
+                        else
+                        {
+                            if (connectionString.IsLegacy)
+                            {
+                                Logs.Configuration.LogWarning($"Setting {net.CryptoCode}.lightning is a deprecated format, it will work now, but please replace it for future versions with '{connectionString.ToString()}'");
+                            }
+                            InternalLightningByCryptoCode.Add(net.CryptoCode, connectionString);
+                        }
+                    }
+                }
+
+                ExternalServices.Load(net.CryptoCode, conf);
             }
 
             Logs.Configuration.LogInformation("Supported chains: " + String.Join(',', supportedChains.ToArray()));
 
+            var services = conf.GetOrDefault<string>("externalservices", null);
+            if (services != null)
+            {
+                foreach (var service in services.Split(new[] { ';', ',' }, StringSplitOptions.RemoveEmptyEntries)
+                                                .Select(p => (p, SeparatorIndex: p.IndexOf(':', StringComparison.OrdinalIgnoreCase)))
+                                                .Where(p => p.SeparatorIndex != -1)
+                                                .Select(p => (Name: p.p.Substring(0, p.SeparatorIndex), 
+                                                              Link: p.p.Substring(p.SeparatorIndex + 1))))
+                {
+                    if (Uri.TryCreate(service.Link, UriKind.RelativeOrAbsolute, out var uri))
+                        OtherExternalServices.AddOrReplace(service.Name, uri);
+                }
+            }
+
             PostgresConnectionString = conf.GetOrDefault<string>("postgres", null);
+            MySQLConnectionString = conf.GetOrDefault<string>("mysql", null);
             BundleJsCss = conf.GetOrDefault<bool>("bundlejscss", true);
-            ExternalUrl = conf.GetOrDefault<Uri>("externalurl", null);
-            InternalLightningNode = conf.GetOrDefault<Uri>("internallightningnode", null);
+            AllowAdminRegistration = conf.GetOrDefault<bool>("allow-admin-registration", false);
+            TorrcFile = conf.GetOrDefault<string>("torrcfile", null);
+
+            var socksEndpointString = conf.GetOrDefault<string>("socksendpoint", null);
+            if(!string.IsNullOrEmpty(socksEndpointString))
+            {
+                if (!Utils.TryParseEndpoint(socksEndpointString, 9050, out var endpoint))
+                    throw new ConfigException("Invalid value for socksendpoint");
+                SocksEndpoint = endpoint;
+            }
+            
+
+            var sshSettings = ParseSSHConfiguration(conf);
+            if ((!string.IsNullOrEmpty(sshSettings.Password) || !string.IsNullOrEmpty(sshSettings.KeyFile)) && !string.IsNullOrEmpty(sshSettings.Server))
+            {
+                int waitTime = 0;
+                while (!string.IsNullOrEmpty(sshSettings.KeyFile) && !File.Exists(sshSettings.KeyFile))
+                {
+                    if (waitTime++ < 5)
+                        System.Threading.Thread.Sleep(1000);
+                    else
+                        throw new ConfigException($"sshkeyfile does not exist");
+                }
+
+                if (sshSettings.Port > ushort.MaxValue ||
+                   sshSettings.Port < ushort.MinValue)
+                    throw new ConfigException($"ssh port is invalid");
+                if (!string.IsNullOrEmpty(sshSettings.Password) && !string.IsNullOrEmpty(sshSettings.KeyFile))
+                    throw new ConfigException($"sshpassword or sshkeyfile should be provided, but not both");
+                try
+                {
+                    sshSettings.CreateConnectionInfo();
+                }
+                catch
+                {
+                    throw new ConfigException($"sshkeyfilepassword is invalid");
+                }
+                SSHSettings = sshSettings;
+            }
+
+            var fingerPrints = conf.GetOrDefault<string>("sshtrustedfingerprints", "");
+            if (!string.IsNullOrEmpty(fingerPrints))
+            {
+                foreach (var fingerprint in fingerPrints.Split(';', StringSplitOptions.RemoveEmptyEntries))
+                {
+                    if (!SSHFingerprint.TryParse(fingerprint, out var f))
+                        throw new ConfigException($"Invalid ssh fingerprint format {fingerprint}");
+                    TrustedFingerprints.Add(f);
+                }
+            }
+
+            RootPath = conf.GetOrDefault<string>("rootpath", "/");
+            if (!RootPath.StartsWith("/", StringComparison.InvariantCultureIgnoreCase))
+                RootPath = "/" + RootPath;
+            var old = conf.GetOrDefault<Uri>("internallightningnode", null);
+            if (old != null)
+                throw new ConfigException($"internallightningnode is deprecated and should not be used anymore, use btclightning instead");
+
+            LogFile = GetDebugLog(conf);
+            if (!string.IsNullOrEmpty(LogFile))
+            {
+                Logs.Configuration.LogInformation("LogFile: " + LogFile);
+                Logs.Configuration.LogInformation("Log Level: " + GetDebugLogLevel(conf));
+            }
+
+            DisableRegistration = conf.GetOrDefault<bool>("disable-registration", true);
         }
 
-        public Uri InternalLightningNode { get; set; }
+        private SSHSettings ParseSSHConfiguration(IConfiguration conf)
+        {
+            var settings = new SSHSettings();
+            settings.Server = conf.GetOrDefault<string>("sshconnection", null);
+            if (settings.Server != null)
+            {
+                var parts = settings.Server.Split(':');
+                if (parts.Length == 2 && int.TryParse(parts[1], out int port))
+                {
+                    settings.Port = port;
+                    settings.Server = parts[0];
+                }
+                else
+                {
+                    settings.Port = 22;
+                }
+
+                parts = settings.Server.Split('@');
+                if (parts.Length == 2)
+                {
+                    settings.Username = parts[0];
+                    settings.Server = parts[1];
+                }
+                else
+                {
+                    settings.Username = "root";
+                }
+            }
+            settings.Password = conf.GetOrDefault<string>("sshpassword", "");
+            settings.KeyFile = conf.GetOrDefault<string>("sshkeyfile", "");
+            settings.KeyFilePassword = conf.GetOrDefault<string>("sshkeyfilepassword", "");
+            return settings;
+        }
+
+        internal bool IsTrustedFingerprint(byte[] fingerPrint, byte[] hostKey)
+        {
+            return TrustedFingerprints.Any(f => f.Match(fingerPrint, hostKey));
+        }
+
+        public string RootPath { get; set; }
+        public Dictionary<string, LightningConnectionString> InternalLightningByCryptoCode { get; set; } = new Dictionary<string, LightningConnectionString>();
+
+        public Dictionary<string, Uri> OtherExternalServices { get; set; } = new Dictionary<string, Uri>();
+        public ExternalServices ExternalServices { get; set; } = new ExternalServices();
 
         public BTCPayNetworkProvider NetworkProvider { get; set; }
         public string PostgresConnectionString
@@ -91,7 +262,7 @@ namespace BTCPayServer.Configuration
             get;
             set;
         }
-        public Uri ExternalUrl
+        public string MySQLConnectionString
         {
             get;
             set;
@@ -101,5 +272,13 @@ namespace BTCPayServer.Configuration
             get;
             set;
         }
+        public bool AllowAdminRegistration { get; set; }
+        public List<SSHFingerprint> TrustedFingerprints { get; set; } = new List<SSHFingerprint>();
+        public SSHSettings SSHSettings
+        {
+            get;
+            set;
+        }
+        public string TorrcFile { get; set; }
     }
 }

BTCPayServer/Configuration/ConfigurationExtensions.cs

@@ -6,6 +6,7 @@ using System.Linq;
 using System.Net;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Primitives;
+using NBitcoin;
 
 namespace BTCPayServer.Configuration
 {
@@ -37,6 +38,8 @@ namespace BTCPayServer.Configuration
                 }
             else if (typeof(T) == typeof(string))
                 return (T)(object)str;
+            else if (typeof(T) == typeof(IPAddress))
+                return (T)(object)IPAddress.Parse(str);
             else if (typeof(T) == typeof(IPEndPoint))
             {
                 var separator = str.LastIndexOf(":", StringComparison.InvariantCulture);
@@ -55,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);
+        }
     }
 }