bump

This reverts commit 2ce0749bb6e77950b069a65296741b2ce77bd575.

.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,9 @@
+#!/bin/sh
+set -e
+
+cd ../BTCPayServer.Tests
+docker-compose -v
+docker-compose down --v
+docker-compose pull
+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.

BTCPayServer.Common/BTCPayNetwork.cs

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

BTCPayServer.Common/BTCPayNetworkProvider.Bitcoin.cs

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

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using BTCPayServer.Services.Rates;
 using NBitcoin;
 using NBXplorer;
 
@@ -10,21 +9,25 @@ namespace BTCPayServer
 {
     public partial class BTCPayNetworkProvider
     {
-        public void InitLitecoin()
+        public void InitBitcoinplus()
         {
-            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("LTC");
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("XBC");
             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}",
+                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 = "litecoin",
-                CryptoImagePath = "imlegacy/litecoin.svg",
-                LightningImagePath = "imlegacy/litecoin-lightning.svg",
+                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("2'") : new KeyPath("1'")
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("65'") : new KeyPath("1'")
             });
         }
     }

BTCPayServer.Common/BTCPayNetworkProvider.Bitcore.cs

@@ -2,30 +2,33 @@
 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()
+        public void InitBitcore()
         {
-            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("BTC");
+            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("BTX");
             Add(new BTCPayNetwork()
             {
                 CryptoCode = nbxplorerNetwork.CryptoCode,
-                DisplayName = "Bitcoin",
-                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://www.smartbit.com.au/tx/{0}" : "https://testnet.smartbit.com.au/tx/{0}",
+                DisplayName = "Bitcore",
+                BlockExplorerLink = NetworkType == NetworkType.Mainnet ? "https://insight.bitcore.cc/tx/{0}" : "https://insight.bitcore.cc/tx/{0}",
                 NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
                 NBXplorerNetwork = nbxplorerNetwork,
-                UriScheme = "bitcoin",
-                CryptoImagePath = "imlegacy/bitcoin.svg",
-                LightningImagePath = "imlegacy/bitcoin-lightning.svg",
+                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("0'") : new KeyPath("1'")
+                CoinType = NetworkType == NetworkType.Mainnet ? new KeyPath("160'") : new KeyPath("1'")
             });
         }
     }

BTCPayServer.Common/BTCPayNetworkProvider.Dash.cs

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

BTCPayServer.Common/BTCPayNetworkProvider.Dogecoin.cs

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

BTCPayServer.Common/BTCPayNetworkProvider.Feathercoin.cs

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

BTCPayServer.Common/BTCPayNetworkProvider.Groestlcoin.cs

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

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using BTCPayServer.Services.Rates;
 using NBitcoin;
 using NBXplorer;
 
@@ -24,7 +23,7 @@ namespace BTCPayServer
                 DefaultRateRules = new[] 
                 {
                                 "MONA_X = MONA_BTC * BTC_X",
-                                "MONA_BTC = zaif(MONA_BTC)"
+                                "MONA_BTC = bittrex(MONA_BTC)"
                 },
                 CryptoImagePath = "imlegacy/monacoin.png",
                 LightningImagePath = "imlegacy/mona-lightning.svg",

BTCPayServer.Common/BTCPayNetworkProvider.Polis.cs

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

BTCPayServer.Common/BTCPayNetworkProvider.Ufo.cs

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

BTCPayServer.Common/BTCPayNetworkProvider.Viacoin.cs

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

BTCPayServer.Common/BTCPayNetworkProvider.cs

@@ -3,17 +3,14 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
-using BTCPayServer.Services.Rates;
-using Microsoft.Extensions.Caching.Memory;
 using NBitcoin;
-using NBitpayClient;
 using NBXplorer;
 
 namespace BTCPayServer
 {
     public partial class BTCPayNetworkProvider
     {
-        Dictionary<string, BTCPayNetwork> _Networks = new Dictionary<string, BTCPayNetwork>();
+        Dictionary<string, BTCPayNetworkBase> _Networks = new Dictionary<string, BTCPayNetworkBase>();
 
 
         private readonly NBXplorerNetworkProvider _NBXplorerNetworkProvider;
@@ -25,13 +22,14 @@ namespace BTCPayServer
             }
         }
 
-        BTCPayNetworkProvider(BTCPayNetworkProvider filtered, string[] cryptoCodes)
+        BTCPayNetworkProvider(BTCPayNetworkProvider unfiltered, string[] cryptoCodes)
         {
-            NetworkType = filtered.NetworkType;
-            _NBXplorerNetworkProvider = new NBXplorerNetworkProvider(filtered.NetworkType);
-            _Networks = new Dictionary<string, BTCPayNetwork>();
+            UnfilteredNetworks = unfiltered.UnfilteredNetworks ?? unfiltered;
+            NetworkType = unfiltered.NetworkType;
+            _NBXplorerNetworkProvider = new NBXplorerNetworkProvider(unfiltered.NetworkType);
+            _Networks = new Dictionary<string, BTCPayNetworkBase>();
             cryptoCodes = cryptoCodes.Select(c => c.ToUpperInvariant()).ToArray();
-            foreach (var network in filtered._Networks)
+            foreach (var network in unfiltered._Networks)
             {
                 if(cryptoCodes.Contains(network.Key))
                 {
@@ -40,21 +38,43 @@ namespace BTCPayServer
             }
         }
 
+        public BTCPayNetworkProvider UnfilteredNetworks { get; }
+
         public NetworkType NetworkType { get; private set; }
         public BTCPayNetworkProvider(NetworkType networkType)
         {
+            UnfilteredNetworks = this;
             _NBXplorerNetworkProvider = new NBXplorerNetworkProvider(networkType);
             NetworkType = networkType;
             InitBitcoin();
             InitLitecoin();
+            InitBitcore();
             InitDogecoin();
             InitBitcoinGold();
             InitMonacoin();
             InitDash();
-            InitPolis();
             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();
         }
 
@@ -69,20 +89,14 @@ namespace BTCPayServer
         }
 
         [Obsolete("To use only for legacy stuff")]
-        public BTCPayNetwork BTC
-        {
-            get
-            {
-                return GetNetwork("BTC");
-            }
-        }
+        public BTCPayNetwork BTC => GetNetwork<BTCPayNetwork>("BTC");
 
-        public void Add(BTCPayNetwork network)
+        public void Add(BTCPayNetworkBase network)
         {
             _Networks.Add(network.CryptoCode.ToUpperInvariant(), network);
         }
 
-        public IEnumerable<BTCPayNetwork> GetAll()
+        public IEnumerable<BTCPayNetworkBase> GetAll()
         {
             return _Networks.Values.ToArray();
         }
@@ -91,15 +105,20 @@ namespace BTCPayServer
         {
             return _Networks.ContainsKey(cryptoCode.ToUpperInvariant());
         }
-
-        public BTCPayNetwork GetNetwork(string cryptoCode)
+        public BTCPayNetworkBase GetNetwork(string cryptoCode)
         {
-            if(!_Networks.TryGetValue(cryptoCode.ToUpperInvariant(), out BTCPayNetwork network))
+            return GetNetwork<BTCPayNetworkBase>(cryptoCode);
+        }
+        public T GetNetwork<T>(string cryptoCode) where T: BTCPayNetworkBase
+        {
+            if (cryptoCode == null)
+                throw new ArgumentNullException(nameof(cryptoCode));
+            if(!_Networks.TryGetValue(cryptoCode.ToUpperInvariant(), out BTCPayNetworkBase network))
             {
                 if (cryptoCode == "XBT")
-                    return GetNetwork("BTC");
+                    return GetNetwork<T>("BTC");
             }
-            return network;
+            return network as T;
         }
     }
 }

BTCPayServer.Common/BTCPayServer.Common.csproj

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

BTCPayServer.Common/CustomThreadPool.cs

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

BTCPayServer.Common/Extensions.cs

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

BTCPayServer.Common/ZipUtils.cs

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

BTCPayServer.Data/BTCPayServer.Data.csproj

@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <Import Project="../Build/Common.csproj" />
+  <ItemGroup>
+     <PackageReference Include="Microsoft.AspNetCore.App" Version="2.1.9" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
+    <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="2.1.2" />
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="2.1.2" />
+    <PackageReference Include="OpenIddict.EntityFrameworkCore" Version="2.0.0" />
+  </ItemGroup>
+</Project>

BTCPayServer.Data/Data/AddressInvoiceData.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Data
+{
+    public class AddressInvoiceData
+    {
+        /// <summary>
+        /// Some crypto currencies share same address prefix
+        /// For not having exceptions thrown by two address on different network, we suffix by "#CRYPTOCODE" 
+        /// </summary>
+        [Obsolete("Use GetHash instead")]
+        public string Address
+        {
+            get; set;
+        }
+
+        public InvoiceData InvoiceData
+        {
+            get; set;
+        }
+
+        public string InvoiceDataId
+        {
+            get; set;
+        }
+
+        public DateTimeOffset? CreatedTime
+        {
+            get; set;
+        }
+
+    }
+}

BTCPayServer.Data/Data/AppData.cs

@@ -23,6 +23,7 @@ namespace BTCPayServer.Data
         {
             get; set;
         }
+        public bool TagAllInvoices { get; set; }
         public string Settings { get; set; }
 
         public T GetSettings<T>() where T : class, new()

BTCPayServer.Data/Data/ApplicationDbContext.cs

@@ -1,12 +1,9 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
-using System.Threading.Tasks;
 using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore;
-using BTCPayServer.Models;
-using Microsoft.EntityFrameworkCore.Infrastructure.Internal;
 using Microsoft.EntityFrameworkCore.Infrastructure;
+using OpenIddict.EntityFrameworkCore.Models;
 
 namespace BTCPayServer.Data
 {
@@ -54,6 +51,14 @@ namespace BTCPayServer.Data
         {
             get; set;
         }
+        
+        public DbSet<PaymentRequestData> PaymentRequests
+        {
+            get; set;
+        }
+
+        public DbSet<WalletData> Wallets { get; set; }
+        public DbSet<WalletTransactionData> WalletTransactions { get; set; }
 
         public DbSet<StoreData> Stores
         {
@@ -87,10 +92,18 @@ namespace BTCPayServer.Data
         }
 
         public DbSet<APIKeyData> ApiKeys
+        {
+            get; set;
+        } 
+        
+        public DbSet<StoredFile> Files
         {
             get; set;
         }
+       
 
+        public DbSet<U2FDevice> U2FDevices { get; set; }   
+        
         protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
         {
             var isConfigured = optionsBuilder.Options.Extensions.OfType<RelationalOptionsExtension>().Any();
@@ -204,6 +217,34 @@ namespace BTCPayServer.Data
                     o.UniqueId
 #pragma warning restore CS0618
                 });
+            
+            
+            builder.Entity<PaymentRequestData>()
+                .HasOne(o => o.StoreData)
+                .WithMany(i => i.PaymentRequests)
+                .OnDelete(DeleteBehavior.Cascade);
+            builder.Entity<PaymentRequestData>()
+                .Property(e => e.Created)
+                .HasDefaultValue(new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero));
+
+            builder.Entity<PaymentRequestData>()
+                .HasIndex(o => o.Status);
+
+            builder.Entity<WalletTransactionData>()
+                .HasKey(o => new
+                {
+                    o.WalletDataId,
+#pragma warning disable CS0618
+                    o.TransactionId
+#pragma warning restore CS0618
+                });
+            builder.Entity<WalletTransactionData>()
+                .HasOne(o => o.WalletData)
+                .WithMany(w => w.WalletTransactions).OnDelete(DeleteBehavior.Cascade);
+
+            builder.UseOpenIddict<BTCPayOpenIdClient, BTCPayOpenIdAuthorization, OpenIddictScope<string>, BTCPayOpenIdToken, string>();
+
         }
     }
+
 }

BTCPayServer.Data/Data/ApplicationDbContextFactory.cs

@@ -3,9 +3,6 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using Hangfire;
-using Hangfire.MemoryStorage;
-using Hangfire.PostgreSql;
 using Microsoft.EntityFrameworkCore.Migrations;
 using Npgsql.EntityFrameworkCore.PostgreSQL.Migrations;
 using JetBrains.Annotations;
@@ -17,7 +14,8 @@ namespace BTCPayServer.Data
     public enum DatabaseType
     {
         Sqlite,
-        Postgres
+        Postgres,
+        MySQL,
     }
     public class ApplicationDbContextFactory
     {
@@ -90,21 +88,13 @@ namespace BTCPayServer.Data
         public void ConfigureBuilder(DbContextOptionsBuilder builder)
         {
             if (_Type == DatabaseType.Sqlite)
-                builder.UseSqlite(_ConnectionString);
+                builder.UseSqlite(_ConnectionString, o => o.MigrationsAssembly("BTCPayServer.Data"));
             else if (_Type == DatabaseType.Postgres)
                 builder
-                    .UseNpgsql(_ConnectionString)
+                    .UseNpgsql(_ConnectionString, o => o.MigrationsAssembly("BTCPayServer.Data").EnableRetryOnFailure(10))
                     .ReplaceService<IMigrationsSqlGenerator, CustomNpgsqlMigrationsSqlGenerator>();
-        }
-
-        public void ConfigureHangfireBuilder(IGlobalConfiguration builder)
-        {
-            builder.UseMemoryStorage();
-            //We always use memory storage because of incompatibilities with the latest postgres in 2.1
-            //if (_Type == DatabaseType.Sqlite)
-            //    builder.UseMemoryStorage(); //Sqlite provider does not support multiple workers
-            //else if (_Type == DatabaseType.Postgres)
-            //    builder.UsePostgreSqlStorage(_ConnectionString);
+            else if (_Type == DatabaseType.MySQL)
+                builder.UseMySql(_ConnectionString, o => o.MigrationsAssembly("BTCPayServer.Data").EnableRetryOnFailure(10));
         }
     }
 }

BTCPayServer.Data/Data/ApplicationUser.cs

@@ -5,7 +5,7 @@ using System.Threading.Tasks;
 using Microsoft.AspNetCore.Identity;
 using BTCPayServer.Data;
 
-namespace BTCPayServer.Models
+namespace BTCPayServer.Data
 {
     // Add profile data for application users by adding properties to the ApplicationUser class
     public class ApplicationUser : IdentityUser
@@ -20,5 +20,15 @@ namespace BTCPayServer.Models
         {
             get; set;
         }
+        
+        public List<BTCPayOpenIdClient> OpenIdClients { get; set; }
+        
+        public List<StoredFile> StoredFiles
+        {
+            get;
+            set;
+        }
+        
+        public List<U2FDevice> U2FDevices { get; set; }
     }
 }

BTCPayServer.Data/Data/BTCPayOpenIdAuthorization.cs

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

BTCPayServer.Data/Data/BTCPayOpenIdClient.cs

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

BTCPayServer.Data/Data/BTCPayOpenIdToken.cs

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

BTCPayServer.Data/Data/HistoricalAddressInvoiceData.cs

@@ -31,29 +31,6 @@ namespace BTCPayServer.Data
         [Obsolete("Use GetCryptoCode instead")]
         public string CryptoCode { get; set; }
 
-#pragma warning disable CS0618
-        public Payments.PaymentMethodId GetPaymentMethodId()
-        {
-            return string.IsNullOrEmpty(CryptoCode) ? new Payments.PaymentMethodId("BTC", Payments.PaymentTypes.BTCLike)
-                                                    : Payments.PaymentMethodId.Parse(CryptoCode);
-        }
-        public string GetAddress()
-        {
-            if (Address == null)
-                return null;
-            var index = Address.IndexOf("#", StringComparison.InvariantCulture);
-            if (index == -1)
-                return Address;
-            return Address.Substring(0, index);
-        }
-        public HistoricalAddressInvoiceData SetAddress(string depositAddress, string cryptoCode)
-        {
-            Address = depositAddress + "#" + cryptoCode;
-            CryptoCode = cryptoCode;
-            return this;
-        }
-#pragma warning restore CS0618
-
         public DateTimeOffset Assigned
         {
             get; set;

BTCPayServer.Data/Data/InvoiceData.cs

@@ -1,5 +1,4 @@
-using BTCPayServer.Models;
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;

BTCPayServer.Data/Data/InvoiceEventData.cs

@@ -15,7 +15,7 @@ namespace BTCPayServer.Data
         {
             get; set;
         }
-        public string UniqueId { get; internal set; }
+        public string UniqueId { get; set; }
         public DateTimeOffset Timestamp
         {
             get; set;

BTCPayServer.Data/Data/PairedSINData.cs

@@ -12,11 +12,6 @@ namespace BTCPayServer.Data
             get; set;
         }
 
-        public string Facade
-        {
-            get; set;
-        }
-
         public string StoreDataId
         {
             get; set;

BTCPayServer.Data/Data/PairingCodeData.cs

@@ -11,7 +11,7 @@ namespace BTCPayServer.Data
         {
             get; set;
         }
-
+        [Obsolete("Unused")]
         public string Facade
         {
             get; set;

BTCPayServer.Data/Data/PaymentRequestData.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace BTCPayServer.Data
+{
+    public class PaymentRequestData
+    {
+        public string Id { get; set; }
+        public DateTimeOffset Created
+        {
+            get; set;
+        }
+        public string StoreDataId { get; set; }
+
+        public StoreData StoreData { get; set; }
+
+        public PaymentRequestStatus Status { get; set; }
+
+        public byte[] Blob { get; set; }
+
+        public class PaymentRequestBlob
+        {
+            public decimal Amount { get; set; }
+            public string Currency { get; set; }
+
+            public DateTime? ExpiryDate { get; set; }
+
+            public string Title { get; set; }
+            public string Description { get; set; }
+            public string Email { get; set; }
+
+            public string EmbeddedCSS { get; set; }
+            public string CustomCSSLink { get; set; }
+            public bool AllowCustomPaymentAmounts { get; set; }
+        }
+
+        public enum PaymentRequestStatus
+        {
+            Pending = 0,
+            Completed = 1,
+            Expired = 2
+        }
+    }
+}

BTCPayServer.Data/Data/StoreData.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Linq;
+using System.Text;
+using Newtonsoft.Json.Linq;
+using System.Security.Claims;
+
+namespace BTCPayServer.Data
+{
+    public enum SpeedPolicy
+    {
+        HighSpeed = 0,
+        MediumSpeed = 1,
+        LowSpeed = 2,
+        LowMediumSpeed = 3
+    }
+    public class StoreData
+    {
+        public string Id
+        {
+            get;
+            set;
+        }
+
+        public List<UserStore> UserStores
+        {
+            get; set;
+        }
+        public List<AppData> Apps
+        {
+            get; set;
+        }
+        
+        public List<PaymentRequestData> PaymentRequests
+        {
+            get; set;
+        }
+
+        public List<InvoiceData> Invoices { get; set; }
+
+        [Obsolete("Use GetDerivationStrategies instead")]
+        public string DerivationStrategy
+        {
+            get; set;
+        }
+
+        [Obsolete("Use GetDerivationStrategies instead")]
+        public string DerivationStrategies
+        {
+            get;
+            set;
+        }
+
+        public string StoreName
+        {
+            get; set;
+        }
+
+        public SpeedPolicy SpeedPolicy
+        {
+            get; set;
+        }
+
+        public string StoreWebsite
+        {
+            get; set;
+        }
+
+        public byte[] StoreCertificate
+        {
+            get; set;
+        }
+
+        [NotMapped]
+        [Obsolete]
+        public string Role
+        {
+            get; set;
+        }
+
+        public byte[] StoreBlob
+        {
+            get;
+            set;
+        }
+        [Obsolete("Use GetDefaultPaymentId instead")]
+        public string DefaultCrypto { get; set; }
+        public List<PairedSINData> PairedSINs { get; set; }
+        public IEnumerable<APIKeyData> APIKeys { get; set; }
+
+        [NotMapped]
+        public List<Claim> AdditionalClaims { get; set; } = new List<Claim>();
+    }
+
+    public enum NetworkFeeMode
+    {
+        MultiplePaymentsOnly,
+        Always,
+        Never
+    }
+}

BTCPayServer.Data/Data/StoredFile.cs

@@ -0,0 +1,20 @@
+using System;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace BTCPayServer.Data
+{
+    public class StoredFile
+    {
+        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+        public string Id { get; set; }
+
+        public string FileName { get; set; }
+        public string StorageFileName { get; set; }
+        public DateTime Timestamp { get; set; }
+        public string ApplicationUserId { get; set; }
+        public ApplicationUser ApplicationUser
+        {
+            get; set;
+        }
+    }
+}

BTCPayServer.Data/Data/U2FDevice.cs

@@ -0,0 +1,23 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+
+namespace BTCPayServer.Data
+{
+    public class U2FDevice
+    {
+        public string Id { get; set; }
+
+        public string Name { get; set; }
+
+        [Required] public byte[] KeyHandle { get; set; }
+
+        [Required] public byte[] PublicKey { get; set; }
+
+        [Required] public byte[] AttestationCert { get; set; }
+
+        [Required] public int Counter { get; set; }
+
+        public string ApplicationUserId { get; set; }
+        public ApplicationUser ApplicationUser { get; set; }
+    }
+}

BTCPayServer.Data/Data/UserStore.cs

@@ -1,5 +1,4 @@
-using BTCPayServer.Models;
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;

BTCPayServer.Data/Data/WalletData.cs

@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Data
+{
+    public class WalletData
+    {
+        [System.ComponentModel.DataAnnotations.Key]
+        public string Id { get; set; }
+
+        public List<WalletTransactionData> WalletTransactions { get; set; }
+
+        public byte[] Blob { get; set; }
+    }
+
+    public class Label
+    {
+        public Label(string value, string color)
+        {
+            if (value == null)
+                throw new ArgumentNullException(nameof(value));
+            if (color == null)
+                throw new ArgumentNullException(nameof(color));
+            Value = value;
+            Color = color;
+        }
+
+        public string Value { get; }
+        public string Color { get; }
+
+        public override bool Equals(object obj)
+        {
+            Label item = obj as Label;
+            if (item == null)
+                return false;
+            return Value.Equals(item.Value, StringComparison.OrdinalIgnoreCase);
+        }
+        public static bool operator ==(Label a, Label b)
+        {
+            if (System.Object.ReferenceEquals(a, b))
+                return true;
+            if (((object)a == null) || ((object)b == null))
+                return false;
+            return a.Value == b.Value;
+        }
+
+        public static bool operator !=(Label a, Label b)
+        {
+            return !(a == b);
+        }
+
+        public override int GetHashCode()
+        {
+            return Value.GetHashCode(StringComparison.OrdinalIgnoreCase);
+        }
+    }
+
+    public class WalletBlobInfo
+    {
+        public Dictionary<string, string> LabelColors { get; set; } = new Dictionary<string, string>();
+
+        public IEnumerable<Label> GetLabels(WalletTransactionInfo transactionInfo)
+        {
+            foreach (var label in transactionInfo.Labels)
+            {
+                if (LabelColors.TryGetValue(label, out var color))
+                {
+                    yield return new Label(label, color);
+                }
+            }
+        }
+
+        public IEnumerable<Label> GetLabels()
+        {
+            foreach (var kv in LabelColors)
+            {
+                yield return new Label(kv.Key, kv.Value);
+            }
+        }
+    }
+}

BTCPayServer.Data/Data/WalletTransactionData.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Data
+{
+    public class WalletTransactionData
+    {
+        public string WalletDataId { get; set; }
+        public WalletData WalletData { get; set; }
+        public string TransactionId { get; set; }
+        public string Labels { get; set; }
+        public byte[] Blob { get; set; }
+    }
+
+    public class WalletTransactionInfo
+    {
+        public string Comment { get; set; } = string.Empty;
+        [JsonIgnore]
+        public HashSet<string> Labels { get; set; } = new HashSet<string>();
+    }
+}

BTCPayServer.Data/Migrations/20170913143004_Init.cs

@@ -1,9 +1,13 @@
-using Microsoft.EntityFrameworkCore.Migrations;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
 using System;
 using System.Collections.Generic;
 
 namespace BTCPayServer.Migrations
 {
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20170913143004_Init")]
     public partial class Init : Migration
     {
         protected override void Up(MigrationBuilder migrationBuilder)

BTCPayServer.Data/Migrations/20170926073744_Settings.cs

@@ -1,9 +1,13 @@
-using Microsoft.EntityFrameworkCore.Migrations;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
 using System;
 using System.Collections.Generic;
 
 namespace BTCPayServer.Migrations
 {
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20170926073744_Settings")]
     public partial class Settings : Migration
     {
         protected override void Up(MigrationBuilder migrationBuilder)

BTCPayServer.Data/Migrations/20170926084408_RequiresEmailConfirmation.cs

@@ -1,9 +1,13 @@
-using Microsoft.EntityFrameworkCore.Migrations;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
 using System;
 using System.Collections.Generic;
 
 namespace BTCPayServer.Migrations
 {
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20170926084408_RequiresEmailConfirmation")]
     public partial class RequiresEmailConfirmation : Migration
     {
         protected override void Up(MigrationBuilder migrationBuilder)

BTCPayServer.Data/Migrations/20171006013443_AddressMapping.cs

@@ -1,9 +1,13 @@
-using Microsoft.EntityFrameworkCore.Migrations;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
 using System;
 using System.Collections.Generic;
 
 namespace BTCPayServer.Migrations
 {
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20171006013443_AddressMapping")]
     public partial class AddressMapping : Migration
     {
         protected override void Up(MigrationBuilder migrationBuilder)

BTCPayServer.Data/Migrations/20171010082424_Tokens.cs

@@ -1,9 +1,13 @@
-using Microsoft.EntityFrameworkCore.Migrations;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
 using System;
 using System.Collections.Generic;
 
 namespace BTCPayServer.Migrations
 {
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20171010082424_Tokens")]
     public partial class Tokens : Migration
     {
         protected override void Up(MigrationBuilder migrationBuilder)

BTCPayServer.Data/Migrations/20171012020112_PendingInvoices.cs

@@ -1,9 +1,13 @@
-using Microsoft.EntityFrameworkCore.Migrations;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
 using System;
 using System.Collections.Generic;
 
 namespace BTCPayServer.Migrations
 {
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20171012020112_PendingInvoices")]
     public partial class PendingInvoices : Migration
     {
         protected override void Up(MigrationBuilder migrationBuilder)

BTCPayServer.Data/Migrations/20171023101754_StoreBlob.cs

@@ -1,9 +1,13 @@
-using Microsoft.EntityFrameworkCore.Migrations;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
 using System;
 using System.Collections.Generic;
 
 namespace BTCPayServer.Migrations
 {
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20171023101754_StoreBlob")]
     public partial class StoreBlob : Migration
     {
         protected override void Up(MigrationBuilder migrationBuilder)

BTCPayServer.Data/Migrations/20171024163354_RenewUsedAddresses.cs

@@ -1,9 +1,13 @@
-using Microsoft.EntityFrameworkCore.Migrations;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
 using System;
 using System.Collections.Generic;
 
 namespace BTCPayServer.Migrations
 {
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20171024163354_RenewUsedAddresses")]
     public partial class RenewUsedAddresses : Migration
     {
         protected override void Up(MigrationBuilder migrationBuilder)

BTCPayServer.Data/Migrations/20171105235734_PaymentAccounted.cs

@@ -1,9 +1,13 @@
-using Microsoft.EntityFrameworkCore.Migrations;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
 using System;
 using System.Collections.Generic;
 
 namespace BTCPayServer.Migrations
 {
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20171105235734_PaymentAccounted")]
     public partial class PaymentAccounted : Migration
     {
         protected override void Up(MigrationBuilder migrationBuilder)

BTCPayServer.Data/Migrations/20171221054550_AltcoinSupport.cs

@@ -1,9 +1,13 @@
-using Microsoft.EntityFrameworkCore.Migrations;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
 using System;
 using System.Collections.Generic;
 
 namespace BTCPayServer.Migrations
 {
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20171221054550_AltcoinSupport")]
     public partial class AltcoinSupport : Migration
     {
         protected override void Up(MigrationBuilder migrationBuilder)

BTCPayServer.Data/Migrations/20180106095215_DerivationStrategies.cs

@@ -1,9 +1,13 @@
-using Microsoft.EntityFrameworkCore.Migrations;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
 using System;
 using System.Collections.Generic;
 
 namespace BTCPayServer.Migrations
 {
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20180106095215_DerivationStrategies")]
     public partial class DerivationStrategies : Migration
     {
         protected override void Up(MigrationBuilder migrationBuilder)

BTCPayServer.Data/Migrations/20180109021122_defaultcrypto.cs

@@ -1,9 +1,13 @@
-using Microsoft.EntityFrameworkCore.Migrations;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
 using System;
 using System.Collections.Generic;
 
 namespace BTCPayServer.Migrations
 {
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20180109021122_defaultcrypto")]
     public partial class defaultcrypto : Migration
     {
         protected override void Up(MigrationBuilder migrationBuilder)

BTCPayServer.Data/Migrations/20180114123253_events.cs

@@ -1,9 +1,13 @@
-using Microsoft.EntityFrameworkCore.Migrations;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
 using System;
 using System.Collections.Generic;
 
 namespace BTCPayServer.Migrations
 {
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20180114123253_events")]
     public partial class events : Migration
     {
         protected override void Up(MigrationBuilder migrationBuilder)

BTCPayServer.Data/Migrations/20180402095640_appdata.cs

@@ -1,9 +1,13 @@
-using Microsoft.EntityFrameworkCore.Migrations;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
 using System;
 using System.Collections.Generic;
 
 namespace BTCPayServer.Migrations
 {
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20180402095640_appdata")]
     public partial class appdata : Migration
     {
         protected override void Up(MigrationBuilder migrationBuilder)

BTCPayServer.Data/Migrations/20180429083930_legacyapikey.cs

@@ -1,9 +1,13 @@
-using Microsoft.EntityFrameworkCore.Migrations;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
 using System;
 using System.Collections.Generic;
 
 namespace BTCPayServer.Migrations
 {
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20180429083930_legacyapikey")]
     public partial class legacyapikey : Migration
     {
         protected override void Up(MigrationBuilder migrationBuilder)

BTCPayServer.Data/Migrations/20180719095626_CanDeleteStores.cs

@@ -1,7 +1,11 @@
-using Microsoft.EntityFrameworkCore.Migrations;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
 
 namespace BTCPayServer.Migrations
 {
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20180719095626_CanDeleteStores")]
     public partial class CanDeleteStores : Migration
     {
         protected override void Up(MigrationBuilder migrationBuilder)

BTCPayServer.Data/Migrations/20190121133309_AddPaymentRequests.cs

@@ -0,0 +1,51 @@
+using System;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace BTCPayServer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20190121133309_AddPaymentRequests")]
+    public partial class AddPaymentRequests : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "PaymentRequests",
+                columns: table => new
+                {
+                    Id = table.Column<string>(nullable: false),
+                    StoreDataId = table.Column<string>(nullable: true),
+                    Status = table.Column<int>(nullable: false),
+                    Blob = table.Column<byte[]>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_PaymentRequests", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_PaymentRequests_Stores_StoreDataId",
+                        column: x => x.StoreDataId,
+                        principalTable: "Stores",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_PaymentRequests_Status",
+                table: "PaymentRequests",
+                column: "Status");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_PaymentRequests_StoreDataId",
+                table: "PaymentRequests",
+                column: "StoreDataId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "PaymentRequests");
+        }
+    }
+}

BTCPayServer.Data/Migrations/20190219032533_AppsTagging.cs

@@ -0,0 +1,27 @@
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace BTCPayServer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20190219032533_AppsTagging")]
+    public partial class AppsTagging : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "TagAllInvoices",
+                table: "Apps",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "TagAllInvoices",
+                table: "Apps");
+        }
+    }
+}

BTCPayServer.Data/Migrations/20190225091644_AddOpenIddict.cs

@@ -0,0 +1,171 @@
+using System;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace BTCPayServer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20190225091644_AddOpenIddict")]
+    public partial class AddOpenIddict : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "OpenIddictApplications",
+                columns: table => new
+                {
+                    ClientId = table.Column<string>(maxLength: 100, nullable: false),
+                    ClientSecret = table.Column<string>(nullable: true),
+                    ConcurrencyToken = table.Column<string>(maxLength: 50, nullable: true),
+                    ConsentType = table.Column<string>(nullable: true),
+                    DisplayName = table.Column<string>(nullable: true),
+                    Id = table.Column<string>(nullable: false),
+                    Permissions = table.Column<string>(nullable: true),
+                    PostLogoutRedirectUris = table.Column<string>(nullable: true),
+                    Properties = table.Column<string>(nullable: true),
+                    RedirectUris = table.Column<string>(nullable: true),
+                    Type = table.Column<string>(maxLength: 25, nullable: false),
+                    ApplicationUserId = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_OpenIddictApplications", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_OpenIddictApplications_AspNetUsers_ApplicationUserId",
+                        column: x => x.ApplicationUserId,
+                        principalTable: "AspNetUsers",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "OpenIddictScopes",
+                columns: table => new
+                {
+                    ConcurrencyToken = table.Column<string>(maxLength: 50, nullable: true),
+                    Description = table.Column<string>(nullable: true),
+                    DisplayName = table.Column<string>(nullable: true),
+                    Id = table.Column<string>(nullable: false),
+                    Name = table.Column<string>(maxLength: 200, nullable: false),
+                    Properties = table.Column<string>(nullable: true),
+                    Resources = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_OpenIddictScopes", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "OpenIddictAuthorizations",
+                columns: table => new
+                {
+                    ApplicationId = table.Column<string>(nullable: true),
+                    ConcurrencyToken = table.Column<string>(maxLength: 50, nullable: true),
+                    Id = table.Column<string>(nullable: false),
+                    Properties = table.Column<string>(nullable: true),
+                    Scopes = table.Column<string>(nullable: true),
+                    Status = table.Column<string>(maxLength: 25, nullable: false),
+                    Subject = table.Column<string>(maxLength: 450, nullable: false),
+                    Type = table.Column<string>(maxLength: 25, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_OpenIddictAuthorizations", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_OpenIddictAuthorizations_OpenIddictApplications_ApplicationId",
+                        column: x => x.ApplicationId,
+                        principalTable: "OpenIddictApplications",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "OpenIddictTokens",
+                columns: table => new
+                {
+                    ApplicationId = table.Column<string>(nullable: true),
+                    AuthorizationId = table.Column<string>(nullable: true),
+                    ConcurrencyToken = table.Column<string>(maxLength: 50, nullable: true),
+                    CreationDate = table.Column<DateTimeOffset>(nullable: true),
+                    ExpirationDate = table.Column<DateTimeOffset>(nullable: true),
+                    Id = table.Column<string>(nullable: false),
+                    Payload = table.Column<string>(nullable: true),
+                    Properties = table.Column<string>(nullable: true),
+                    ReferenceId = table.Column<string>(maxLength: 100, nullable: true),
+                    Status = table.Column<string>(maxLength: 25, nullable: false),
+                    Subject = table.Column<string>(maxLength: 450, nullable: false),
+                    Type = table.Column<string>(maxLength: 25, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_OpenIddictTokens", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_OpenIddictTokens_OpenIddictApplications_ApplicationId",
+                        column: x => x.ApplicationId,
+                        principalTable: "OpenIddictApplications",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_OpenIddictTokens_OpenIddictAuthorizations_AuthorizationId",
+                        column: x => x.AuthorizationId,
+                        principalTable: "OpenIddictAuthorizations",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_OpenIddictApplications_ApplicationUserId",
+                table: "OpenIddictApplications",
+                column: "ApplicationUserId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_OpenIddictApplications_ClientId",
+                table: "OpenIddictApplications",
+                column: "ClientId",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_OpenIddictAuthorizations_ApplicationId_Status_Subject_Type",
+                table: "OpenIddictAuthorizations",
+                columns: new[] { "ApplicationId", "Status", "Subject", "Type" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_OpenIddictScopes_Name",
+                table: "OpenIddictScopes",
+                column: "Name",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_OpenIddictTokens_AuthorizationId",
+                table: "OpenIddictTokens",
+                column: "AuthorizationId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_OpenIddictTokens_ReferenceId",
+                table: "OpenIddictTokens",
+                column: "ReferenceId",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_OpenIddictTokens_ApplicationId_Status_Subject_Type",
+                table: "OpenIddictTokens",
+                columns: new[] { "ApplicationId", "Status", "Subject", "Type" });
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "OpenIddictScopes");
+
+            migrationBuilder.DropTable(
+                name: "OpenIddictTokens");
+
+            migrationBuilder.DropTable(
+                name: "OpenIddictAuthorizations");
+
+            migrationBuilder.DropTable(
+                name: "OpenIddictApplications");
+        }
+    }
+}

BTCPayServer.Data/Migrations/20190324141717_AddFiles.cs

@@ -0,0 +1,47 @@
+using System;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace BTCPayServer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20190324141717_AddFiles")]
+    public partial class AddFiles : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Files",
+                columns: table => new
+                {
+                    Id = table.Column<string>(nullable: false),
+                    FileName = table.Column<string>(nullable: true),
+                    StorageFileName = table.Column<string>(nullable: true),
+                    Timestamp = table.Column<DateTime>(nullable: false),
+                    ApplicationUserId = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Files", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Files_AspNetUsers_ApplicationUserId",
+                        column: x => x.ApplicationUserId,
+                        principalTable: "AspNetUsers",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Files_ApplicationUserId",
+                table: "Files",
+                column: "ApplicationUserId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "Files");
+        }
+    }
+}

BTCPayServer.Data/Migrations/20190425081749_AddU2fDevices.cs

@@ -0,0 +1,64 @@
+using System;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace BTCPayServer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20190425081749_AddU2fDevices")]
+    public partial class AddU2fDevices : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            if (this.SupportDropColumn(migrationBuilder.ActiveProvider))
+            {
+                migrationBuilder.DropColumn(
+                    name: "Facade",
+                    table: "PairedSINData");
+            }
+
+            migrationBuilder.CreateTable(
+                name: "U2FDevices",
+                columns: table => new
+                {
+                    Id = table.Column<string>(nullable: false),
+                    Name = table.Column<string>(nullable: true),
+                    KeyHandle = table.Column<byte[]>(nullable: false),
+                    PublicKey = table.Column<byte[]>(nullable: false),
+                    AttestationCert = table.Column<byte[]>(nullable: false),
+                    Counter = table.Column<int>(nullable: false),
+                    ApplicationUserId = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_U2FDevices", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_U2FDevices_AspNetUsers_ApplicationUserId",
+                        column: x => x.ApplicationUserId,
+                        principalTable: "AspNetUsers",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_U2FDevices_ApplicationUserId",
+                table: "U2FDevices",
+                column: "ApplicationUserId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "U2FDevices");
+            //if it did not support dropping it, then it is still here and re-adding it would throw
+            if (this.SupportDropColumn(migrationBuilder.ActiveProvider))
+            {
+                migrationBuilder.AddColumn<string>(
+                    name: "Facade",
+                    table: "PairedSINData",
+                    nullable: true);
+            }
+        }
+    }
+}

BTCPayServer.Data/Migrations/20190701082105_sort_paymentrequests.cs

@@ -0,0 +1,28 @@
+using System;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace BTCPayServer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20190701082105_sort_paymentrequests")]
+    public partial class sort_paymentrequests : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<DateTimeOffset>(
+                name: "Created",
+                table: "PaymentRequests",
+                nullable: false,
+                defaultValue: new DateTimeOffset(new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)));
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Created",
+                table: "PaymentRequests");
+        }
+    }
+}

BTCPayServer.Data/Migrations/20190802142637_WalletData.cs

@@ -0,0 +1,56 @@
+using System;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace BTCPayServer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20190802142637_WalletData")]
+    public partial class WalletData : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Wallets",
+                columns: table => new
+                {
+                    Id = table.Column<string>(nullable: false),
+                    Blob = table.Column<byte[]>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Wallets", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "WalletTransactions",
+                columns: table => new
+                {
+                    WalletDataId = table.Column<string>(nullable: false),
+                    TransactionId = table.Column<string>(nullable: false),
+                    Labels = table.Column<string>(nullable: true),
+                    Blob = table.Column<byte[]>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_WalletTransactions", x => new { x.WalletDataId, x.TransactionId });
+                    table.ForeignKey(
+                        name: "FK_WalletTransactions_Wallets_WalletDataId",
+                        column: x => x.WalletDataId,
+                        principalTable: "Wallets",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "WalletTransactions");
+
+            migrationBuilder.DropTable(
+                name: "Wallets");
+        }
+    }
+}

BTCPayServer.Data/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -0,0 +1,883 @@
+// <auto-generated />
+using System;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace BTCPayServer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    partial class ApplicationDbContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "2.1.11-servicing-32099");
+
+            modelBuilder.Entity("BTCPayServer.Data.AddressInvoiceData", b =>
+            {
+                b.Property<string>("Address")
+                    .ValueGeneratedOnAdd();
+
+                b.Property<DateTimeOffset?>("CreatedTime");
+
+                b.Property<string>("InvoiceDataId");
+
+                b.HasKey("Address");
+
+                b.HasIndex("InvoiceDataId");
+
+                b.ToTable("AddressInvoices");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.APIKeyData", b =>
+            {
+                b.Property<string>("Id")
+                    .ValueGeneratedOnAdd()
+                    .HasMaxLength(50);
+
+                b.Property<string>("StoreId")
+                    .HasMaxLength(50);
+
+                b.HasKey("Id");
+
+                b.HasIndex("StoreId");
+
+                b.ToTable("ApiKeys");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.AppData", b =>
+            {
+                b.Property<string>("Id")
+                    .ValueGeneratedOnAdd();
+
+                b.Property<string>("AppType");
+
+                b.Property<DateTimeOffset>("Created");
+
+                b.Property<string>("Name");
+
+                b.Property<string>("Settings");
+
+                b.Property<string>("StoreDataId");
+
+                b.Property<bool>("TagAllInvoices");
+
+                b.HasKey("Id");
+
+                b.HasIndex("StoreDataId");
+
+                b.ToTable("Apps");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.ApplicationUser", b =>
+            {
+                b.Property<string>("Id")
+                    .ValueGeneratedOnAdd();
+
+                b.Property<int>("AccessFailedCount");
+
+                b.Property<string>("ConcurrencyStamp")
+                    .IsConcurrencyToken();
+
+                b.Property<string>("Email")
+                    .HasMaxLength(256);
+
+                b.Property<bool>("EmailConfirmed");
+
+                b.Property<bool>("LockoutEnabled");
+
+                b.Property<DateTimeOffset?>("LockoutEnd");
+
+                b.Property<string>("NormalizedEmail")
+                    .HasMaxLength(256);
+
+                b.Property<string>("NormalizedUserName")
+                    .HasMaxLength(256);
+
+                b.Property<string>("PasswordHash");
+
+                b.Property<string>("PhoneNumber");
+
+                b.Property<bool>("PhoneNumberConfirmed");
+
+                b.Property<bool>("RequiresEmailConfirmation");
+
+                b.Property<string>("SecurityStamp");
+
+                b.Property<bool>("TwoFactorEnabled");
+
+                b.Property<string>("UserName")
+                    .HasMaxLength(256);
+
+                b.HasKey("Id");
+
+                b.HasIndex("NormalizedEmail")
+                    .HasName("EmailIndex");
+
+                b.HasIndex("NormalizedUserName")
+                    .IsUnique()
+                    .HasName("UserNameIndex");
+
+                b.ToTable("AspNetUsers");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.BTCPayOpenIdAuthorization", b =>
+            {
+                b.Property<string>("Id")
+                    .ValueGeneratedOnAdd();
+
+                b.Property<string>("ApplicationId");
+
+                b.Property<string>("ConcurrencyToken")
+                    .IsConcurrencyToken()
+                    .HasMaxLength(50);
+
+                b.Property<string>("Properties");
+
+                b.Property<string>("Scopes");
+
+                b.Property<string>("Status")
+                    .IsRequired()
+                    .HasMaxLength(25);
+
+                b.Property<string>("Subject")
+                    .IsRequired()
+                    .HasMaxLength(450);
+
+                b.Property<string>("Type")
+                    .IsRequired()
+                    .HasMaxLength(25);
+
+                b.HasKey("Id");
+
+                b.HasIndex("ApplicationId", "Status", "Subject", "Type");
+
+                b.ToTable("OpenIddictAuthorizations");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.BTCPayOpenIdClient", b =>
+            {
+                b.Property<string>("Id")
+                    .ValueGeneratedOnAdd();
+
+                b.Property<string>("ApplicationUserId");
+
+                b.Property<string>("ClientId")
+                    .IsRequired()
+                    .HasMaxLength(100);
+
+                b.Property<string>("ClientSecret");
+
+                b.Property<string>("ConcurrencyToken")
+                    .IsConcurrencyToken()
+                    .HasMaxLength(50);
+
+                b.Property<string>("ConsentType");
+
+                b.Property<string>("DisplayName");
+
+                b.Property<string>("Permissions");
+
+                b.Property<string>("PostLogoutRedirectUris");
+
+                b.Property<string>("Properties");
+
+                b.Property<string>("RedirectUris");
+
+                b.Property<string>("Type")
+                    .IsRequired()
+                    .HasMaxLength(25);
+
+                b.HasKey("Id");
+
+                b.HasIndex("ApplicationUserId");
+
+                b.HasIndex("ClientId")
+                    .IsUnique();
+
+                b.ToTable("OpenIddictApplications");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.BTCPayOpenIdToken", b =>
+            {
+                b.Property<string>("Id")
+                    .ValueGeneratedOnAdd();
+
+                b.Property<string>("ApplicationId");
+
+                b.Property<string>("AuthorizationId");
+
+                b.Property<string>("ConcurrencyToken")
+                    .IsConcurrencyToken()
+                    .HasMaxLength(50);
+
+                b.Property<DateTimeOffset?>("CreationDate");
+
+                b.Property<DateTimeOffset?>("ExpirationDate");
+
+                b.Property<string>("Payload");
+
+                b.Property<string>("Properties");
+
+                b.Property<string>("ReferenceId")
+                    .HasMaxLength(100);
+
+                b.Property<string>("Status")
+                    .IsRequired()
+                    .HasMaxLength(25);
+
+                b.Property<string>("Subject")
+                    .IsRequired()
+                    .HasMaxLength(450);
+
+                b.Property<string>("Type")
+                    .IsRequired()
+                    .HasMaxLength(25);
+
+                b.HasKey("Id");
+
+                b.HasIndex("AuthorizationId");
+
+                b.HasIndex("ReferenceId")
+                    .IsUnique();
+
+                b.HasIndex("ApplicationId", "Status", "Subject", "Type");
+
+                b.ToTable("OpenIddictTokens");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.HistoricalAddressInvoiceData", b =>
+            {
+                b.Property<string>("InvoiceDataId");
+
+                b.Property<string>("Address");
+
+                b.Property<DateTimeOffset>("Assigned");
+
+                b.Property<string>("CryptoCode");
+
+                b.Property<DateTimeOffset?>("UnAssigned");
+
+                b.HasKey("InvoiceDataId", "Address");
+
+                b.ToTable("HistoricalAddressInvoices");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceData", b =>
+            {
+                b.Property<string>("Id")
+                    .ValueGeneratedOnAdd();
+
+                b.Property<byte[]>("Blob");
+
+                b.Property<DateTimeOffset>("Created");
+
+                b.Property<string>("CustomerEmail");
+
+                b.Property<string>("ExceptionStatus");
+
+                b.Property<string>("ItemCode");
+
+                b.Property<string>("OrderId");
+
+                b.Property<string>("Status");
+
+                b.Property<string>("StoreDataId");
+
+                b.HasKey("Id");
+
+                b.HasIndex("StoreDataId");
+
+                b.ToTable("Invoices");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceEventData", b =>
+            {
+                b.Property<string>("InvoiceDataId");
+
+                b.Property<string>("UniqueId");
+
+                b.Property<string>("Message");
+
+                b.Property<DateTimeOffset>("Timestamp");
+
+                b.HasKey("InvoiceDataId", "UniqueId");
+
+                b.ToTable("InvoiceEvents");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.PairedSINData", b =>
+            {
+                b.Property<string>("Id")
+                    .ValueGeneratedOnAdd();
+
+                b.Property<string>("Label");
+
+                b.Property<DateTimeOffset>("PairingTime");
+
+                b.Property<string>("SIN");
+
+                b.Property<string>("StoreDataId");
+
+                b.HasKey("Id");
+
+                b.HasIndex("SIN");
+
+                b.HasIndex("StoreDataId");
+
+                b.ToTable("PairedSINData");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.PairingCodeData", b =>
+            {
+                b.Property<string>("Id")
+                    .ValueGeneratedOnAdd();
+
+                b.Property<DateTime>("DateCreated");
+
+                b.Property<DateTimeOffset>("Expiration");
+
+                b.Property<string>("Facade");
+
+                b.Property<string>("Label");
+
+                b.Property<string>("SIN");
+
+                b.Property<string>("StoreDataId");
+
+                b.Property<string>("TokenValue");
+
+                b.HasKey("Id");
+
+                b.ToTable("PairingCodes");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.PaymentData", b =>
+            {
+                b.Property<string>("Id")
+                    .ValueGeneratedOnAdd();
+
+                b.Property<bool>("Accounted");
+
+                b.Property<byte[]>("Blob");
+
+                b.Property<string>("InvoiceDataId");
+
+                b.HasKey("Id");
+
+                b.HasIndex("InvoiceDataId");
+
+                b.ToTable("Payments");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.PaymentRequestData", b =>
+            {
+                b.Property<string>("Id")
+                    .ValueGeneratedOnAdd();
+
+                b.Property<byte[]>("Blob");
+
+                b.Property<DateTimeOffset>("Created")
+                    .ValueGeneratedOnAdd()
+                    .HasDefaultValue(new DateTimeOffset(new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)));
+
+                b.Property<int>("Status");
+
+                b.Property<string>("StoreDataId");
+
+                b.HasKey("Id");
+
+                b.HasIndex("Status");
+
+                b.HasIndex("StoreDataId");
+
+                b.ToTable("PaymentRequests");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.PendingInvoiceData", b =>
+            {
+                b.Property<string>("Id");
+
+                b.HasKey("Id");
+
+                b.ToTable("PendingInvoices");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.RefundAddressesData", b =>
+            {
+                b.Property<string>("Id")
+                    .ValueGeneratedOnAdd();
+
+                b.Property<byte[]>("Blob");
+
+                b.Property<string>("InvoiceDataId");
+
+                b.HasKey("Id");
+
+                b.HasIndex("InvoiceDataId");
+
+                b.ToTable("RefundAddresses");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.SettingData", b =>
+            {
+                b.Property<string>("Id")
+                    .ValueGeneratedOnAdd();
+
+                b.Property<string>("Value");
+
+                b.HasKey("Id");
+
+                b.ToTable("Settings");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.StoreData", b =>
+            {
+                b.Property<string>("Id")
+                    .ValueGeneratedOnAdd();
+
+                b.Property<string>("DefaultCrypto");
+
+                b.Property<string>("DerivationStrategies");
+
+                b.Property<string>("DerivationStrategy");
+
+                b.Property<int>("SpeedPolicy");
+
+                b.Property<byte[]>("StoreBlob");
+
+                b.Property<byte[]>("StoreCertificate");
+
+                b.Property<string>("StoreName");
+
+                b.Property<string>("StoreWebsite");
+
+                b.HasKey("Id");
+
+                b.ToTable("Stores");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.StoredFile", b =>
+            {
+                b.Property<string>("Id")
+                    .ValueGeneratedOnAdd();
+
+                b.Property<string>("ApplicationUserId");
+
+                b.Property<string>("FileName");
+
+                b.Property<string>("StorageFileName");
+
+                b.Property<DateTime>("Timestamp");
+
+                b.HasKey("Id");
+
+                b.HasIndex("ApplicationUserId");
+
+                b.ToTable("Files");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.U2FDevice", b =>
+            {
+                b.Property<string>("Id")
+                    .ValueGeneratedOnAdd();
+
+                b.Property<string>("ApplicationUserId");
+
+                b.Property<byte[]>("AttestationCert")
+                    .IsRequired();
+
+                b.Property<int>("Counter");
+
+                b.Property<byte[]>("KeyHandle")
+                    .IsRequired();
+
+                b.Property<string>("Name");
+
+                b.Property<byte[]>("PublicKey")
+                    .IsRequired();
+
+                b.HasKey("Id");
+
+                b.HasIndex("ApplicationUserId");
+
+                b.ToTable("U2FDevices");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.UserStore", b =>
+            {
+                b.Property<string>("ApplicationUserId");
+
+                b.Property<string>("StoreDataId");
+
+                b.Property<string>("Role");
+
+                b.HasKey("ApplicationUserId", "StoreDataId");
+
+                b.HasIndex("StoreDataId");
+
+                b.ToTable("UserStore");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.WalletData", b =>
+            {
+                b.Property<string>("Id")
+                    .ValueGeneratedOnAdd();
+
+                b.Property<byte[]>("Blob");
+
+                b.HasKey("Id");
+
+                b.ToTable("Wallets");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.WalletTransactionData", b =>
+            {
+                b.Property<string>("WalletDataId");
+
+                b.Property<string>("TransactionId");
+
+                b.Property<byte[]>("Blob");
+
+                b.Property<string>("Labels");
+
+                b.HasKey("WalletDataId", "TransactionId");
+
+                b.ToTable("WalletTransactions");
+            });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+            {
+                b.Property<string>("Id")
+                    .ValueGeneratedOnAdd();
+
+                b.Property<string>("ConcurrencyStamp")
+                    .IsConcurrencyToken();
+
+                b.Property<string>("Name")
+                    .HasMaxLength(256);
+
+                b.Property<string>("NormalizedName")
+                    .HasMaxLength(256);
+
+                b.HasKey("Id");
+
+                b.HasIndex("NormalizedName")
+                    .IsUnique()
+                    .HasName("RoleNameIndex");
+
+                b.ToTable("AspNetRoles");
+            });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+            {
+                b.Property<int>("Id")
+                    .ValueGeneratedOnAdd();
+
+                b.Property<string>("ClaimType");
+
+                b.Property<string>("ClaimValue");
+
+                b.Property<string>("RoleId")
+                    .IsRequired();
+
+                b.HasKey("Id");
+
+                b.HasIndex("RoleId");
+
+                b.ToTable("AspNetRoleClaims");
+            });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+            {
+                b.Property<int>("Id")
+                    .ValueGeneratedOnAdd();
+
+                b.Property<string>("ClaimType");
+
+                b.Property<string>("ClaimValue");
+
+                b.Property<string>("UserId")
+                    .IsRequired();
+
+                b.HasKey("Id");
+
+                b.HasIndex("UserId");
+
+                b.ToTable("AspNetUserClaims");
+            });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+            {
+                b.Property<string>("LoginProvider");
+
+                b.Property<string>("ProviderKey");
+
+                b.Property<string>("ProviderDisplayName");
+
+                b.Property<string>("UserId")
+                    .IsRequired();
+
+                b.HasKey("LoginProvider", "ProviderKey");
+
+                b.HasIndex("UserId");
+
+                b.ToTable("AspNetUserLogins");
+            });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+            {
+                b.Property<string>("UserId");
+
+                b.Property<string>("RoleId");
+
+                b.HasKey("UserId", "RoleId");
+
+                b.HasIndex("RoleId");
+
+                b.ToTable("AspNetUserRoles");
+            });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+            {
+                b.Property<string>("UserId");
+
+                b.Property<string>("LoginProvider");
+
+                b.Property<string>("Name");
+
+                b.Property<string>("Value");
+
+                b.HasKey("UserId", "LoginProvider", "Name");
+
+                b.ToTable("AspNetUserTokens");
+            });
+
+            modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictScope<string>", b =>
+            {
+                b.Property<string>("Id")
+                    .ValueGeneratedOnAdd();
+
+                b.Property<string>("ConcurrencyToken")
+                    .IsConcurrencyToken()
+                    .HasMaxLength(50);
+
+                b.Property<string>("Description");
+
+                b.Property<string>("DisplayName");
+
+                b.Property<string>("Name")
+                    .IsRequired()
+                    .HasMaxLength(200);
+
+                b.Property<string>("Properties");
+
+                b.Property<string>("Resources");
+
+                b.HasKey("Id");
+
+                b.HasIndex("Name")
+                    .IsUnique();
+
+                b.ToTable("OpenIddictScopes");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.AddressInvoiceData", b =>
+            {
+                b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                    .WithMany("AddressInvoices")
+                    .HasForeignKey("InvoiceDataId")
+                    .OnDelete(DeleteBehavior.Cascade);
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.APIKeyData", b =>
+            {
+                b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                    .WithMany("APIKeys")
+                    .HasForeignKey("StoreId")
+                    .OnDelete(DeleteBehavior.Cascade);
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.AppData", b =>
+            {
+                b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                    .WithMany("Apps")
+                    .HasForeignKey("StoreDataId")
+                    .OnDelete(DeleteBehavior.Cascade);
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.BTCPayOpenIdAuthorization", b =>
+            {
+                b.HasOne("BTCPayServer.Data.BTCPayOpenIdClient", "Application")
+                    .WithMany("Authorizations")
+                    .HasForeignKey("ApplicationId");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.BTCPayOpenIdClient", b =>
+            {
+                b.HasOne("BTCPayServer.Data.ApplicationUser", "ApplicationUser")
+                    .WithMany("OpenIdClients")
+                    .HasForeignKey("ApplicationUserId");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.BTCPayOpenIdToken", b =>
+            {
+                b.HasOne("BTCPayServer.Data.BTCPayOpenIdClient", "Application")
+                    .WithMany("Tokens")
+                    .HasForeignKey("ApplicationId");
+
+                b.HasOne("BTCPayServer.Data.BTCPayOpenIdAuthorization", "Authorization")
+                    .WithMany("Tokens")
+                    .HasForeignKey("AuthorizationId");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.HistoricalAddressInvoiceData", b =>
+            {
+                b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                    .WithMany("HistoricalAddressInvoices")
+                    .HasForeignKey("InvoiceDataId")
+                    .OnDelete(DeleteBehavior.Cascade);
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceData", b =>
+            {
+                b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                    .WithMany("Invoices")
+                    .HasForeignKey("StoreDataId")
+                    .OnDelete(DeleteBehavior.Cascade);
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.InvoiceEventData", b =>
+            {
+                b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                    .WithMany("Events")
+                    .HasForeignKey("InvoiceDataId")
+                    .OnDelete(DeleteBehavior.Cascade);
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.PairedSINData", b =>
+            {
+                b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                    .WithMany("PairedSINs")
+                    .HasForeignKey("StoreDataId")
+                    .OnDelete(DeleteBehavior.Cascade);
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.PaymentData", b =>
+            {
+                b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                    .WithMany("Payments")
+                    .HasForeignKey("InvoiceDataId")
+                    .OnDelete(DeleteBehavior.Cascade);
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.PaymentRequestData", b =>
+            {
+                b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                    .WithMany("PaymentRequests")
+                    .HasForeignKey("StoreDataId")
+                    .OnDelete(DeleteBehavior.Cascade);
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.PendingInvoiceData", b =>
+            {
+                b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                    .WithMany("PendingInvoices")
+                    .HasForeignKey("Id")
+                    .OnDelete(DeleteBehavior.Cascade);
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.RefundAddressesData", b =>
+            {
+                b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
+                    .WithMany("RefundAddresses")
+                    .HasForeignKey("InvoiceDataId")
+                    .OnDelete(DeleteBehavior.Cascade);
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.StoredFile", b =>
+            {
+                b.HasOne("BTCPayServer.Data.ApplicationUser", "ApplicationUser")
+                    .WithMany("StoredFiles")
+                    .HasForeignKey("ApplicationUserId");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.U2FDevice", b =>
+            {
+                b.HasOne("BTCPayServer.Data.ApplicationUser", "ApplicationUser")
+                    .WithMany("U2FDevices")
+                    .HasForeignKey("ApplicationUserId");
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.UserStore", b =>
+            {
+                b.HasOne("BTCPayServer.Data.ApplicationUser", "ApplicationUser")
+                    .WithMany("UserStores")
+                    .HasForeignKey("ApplicationUserId")
+                    .OnDelete(DeleteBehavior.Cascade);
+
+                b.HasOne("BTCPayServer.Data.StoreData", "StoreData")
+                    .WithMany("UserStores")
+                    .HasForeignKey("StoreDataId")
+                    .OnDelete(DeleteBehavior.Cascade);
+            });
+
+            modelBuilder.Entity("BTCPayServer.Data.WalletTransactionData", b =>
+            {
+                b.HasOne("BTCPayServer.Data.WalletData", "WalletData")
+                    .WithMany("WalletTransactions")
+                    .HasForeignKey("WalletDataId")
+                    .OnDelete(DeleteBehavior.Cascade);
+            });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+            {
+                b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
+                    .WithMany()
+                    .HasForeignKey("RoleId")
+                    .OnDelete(DeleteBehavior.Cascade);
+            });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+            {
+                b.HasOne("BTCPayServer.Data.ApplicationUser")
+                    .WithMany()
+                    .HasForeignKey("UserId")
+                    .OnDelete(DeleteBehavior.Cascade);
+            });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+            {
+                b.HasOne("BTCPayServer.Data.ApplicationUser")
+                    .WithMany()
+                    .HasForeignKey("UserId")
+                    .OnDelete(DeleteBehavior.Cascade);
+            });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+            {
+                b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
+                    .WithMany()
+                    .HasForeignKey("RoleId")
+                    .OnDelete(DeleteBehavior.Cascade);
+
+                b.HasOne("BTCPayServer.Data.ApplicationUser")
+                    .WithMany()
+                    .HasForeignKey("UserId")
+                    .OnDelete(DeleteBehavior.Cascade);
+            });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+            {
+                b.HasOne("BTCPayServer.Data.ApplicationUser")
+                    .WithMany()
+                    .HasForeignKey("UserId")
+                    .OnDelete(DeleteBehavior.Cascade);
+            });
+#pragma warning restore 612, 618
+        }
+    }
+}

BTCPayServer.Data/MigrationsExtensions.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+
+namespace BTCPayServer.Migrations
+{
+    public static class MigrationsExtensions
+    {
+        public static bool SupportDropColumn(this Microsoft.EntityFrameworkCore.Migrations.Migration migration, string activeProvider)
+        {
+            return activeProvider != "Microsoft.EntityFrameworkCore.Sqlite";
+        }
+
+        public static bool SupportDropForeignKey(this Microsoft.EntityFrameworkCore.Migrations.Migration migration, string activeProvider)
+        {
+            return activeProvider != "Microsoft.EntityFrameworkCore.Sqlite";
+        }
+        public static bool SupportDropForeignKey(this DatabaseFacade facade)
+        {
+            return facade.ProviderName != "Microsoft.EntityFrameworkCore.Sqlite";
+        }
+    }
+}

BTCPayServer.Rating/BTCPayServer.Rating.csproj

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

BTCPayServer.Rating/CurrencyPair.cs

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

BTCPayServer.Rating/ExchangeRates.cs

@@ -221,6 +221,16 @@ namespace BTCPayServer.Rating
     }
     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; }

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,35 @@
+using System.Linq;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using BTCPayServer.Rating;
+using System.Threading;
+using System.Net.Http;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Services.Rates
+{
+    public class BitpayRateProvider : IRateProvider, IHasExchangeName
+    {
+        public const string BitpayName = "bitpay";
+        private readonly HttpClient _httpClient;
+        public BitpayRateProvider(HttpClient httpClient)
+        {
+            _httpClient = httpClient ?? new HttpClient();
+        }
+
+        public string ExchangeName => BitpayName;
+
+        public async Task<ExchangeRates> GetRatesAsync(CancellationToken cancellationToken)
+        {
+            var response = await _httpClient.GetAsync("https://bitpay.com/rates", cancellationToken);
+            var jarray = (JArray)(await response.Content.ReadAsAsync<JObject>(cancellationToken))["data"];
+            return new ExchangeRates(jarray
+                .Children<JObject>()
+                .Select(jobj => new ExchangeRate(ExchangeName, new CurrencyPair("BTC", jobj["code"].Value<string>()), new BidAsk(jobj["rate"].Value<decimal>())))
+                .Where(o => o.CurrencyPair.Right != "BTC")
+                .ToArray());
+        }
+    }
+}

BTCPayServer.Rating/Providers/ByllsRateProvider.cs

@@ -0,0 +1,27 @@
+using System;
+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

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Rating;
 using BTCPayServer.Services.Rates;
@@ -7,7 +8,7 @@ using Microsoft.Extensions.Caching.Memory;
 
 namespace BTCPayServer.Services.Rates
 {
-    public class CachedRateProvider : IRateProvider
+    public class CachedRateProvider : IRateProvider, IHasExchangeName
     {
         private IRateProvider _Inner;
         private IMemoryCache _MemoryCache;
@@ -31,21 +32,21 @@ namespace BTCPayServer.Services.Rates
             }
         }
 
-        public string ExchangeName { get; set; }
+        public string ExchangeName { get; }
 
         public TimeSpan CacheSpan
         {
             get;
             set;
         } = TimeSpan.FromMinutes(1.0);
-        public IMemoryCache MemoryCache { get => _MemoryCache; private set => _MemoryCache = value; }
+        public IMemoryCache MemoryCache { get => _MemoryCache; set => _MemoryCache = value; }
         
-        public Task<ExchangeRates> GetRatesAsync()
+        public Task<ExchangeRates> GetRatesAsync(CancellationToken cancellationToken)
         {
             return MemoryCache.GetOrCreateAsync("EXCHANGE_RATES_" + ExchangeName, (ICacheEntry entry) =>
             {
                 entry.AbsoluteExpiration = DateTimeOffset.UtcNow + CacheSpan;
-                return _Inner.GetRatesAsync();
+                return _Inner.GetRatesAsync(cancellationToken);
             });
         }
     }

BTCPayServer.Rating/Providers/CoinAverageRateProvider.cs

@@ -11,6 +11,7 @@ using System.Text;
 using System.Threading.Tasks;
 using System.ComponentModel;
 using BTCPayServer.Rating;
+using System.Threading;
 
 namespace BTCPayServer.Services.Rates
 {
@@ -49,13 +50,26 @@ namespace BTCPayServer.Services.Rates
         Task AddHeader(HttpRequestMessage message);
     }
 
-    public class CoinAverageRateProvider : IRateProvider
+    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;
@@ -69,6 +83,8 @@ namespace BTCPayServer.Services.Rates
 
         public ICoinAverageAuthenticator Authenticator { get; set; }
 
+        public string ExchangeName => Exchange ?? CoinAverageName;
+
         private bool TryToBidAsk(JProperty p, out BidAsk bidAsk)
         {
             bidAsk = null;
@@ -96,7 +112,7 @@ namespace BTCPayServer.Services.Rates
             }
         }
 
-        public async Task<ExchangeRates> GetRatesAsync()
+        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}";
@@ -107,7 +123,7 @@ namespace BTCPayServer.Services.Rates
             {
                 await auth.AddHeader(request);
             }
-            var resp = await _Client.SendAsync(request);
+            var resp = await HttpClient.SendAsync(request, cancellationToken);
             using (resp)
             {
 
@@ -150,7 +166,7 @@ namespace BTCPayServer.Services.Rates
             {
                 await auth.AddHeader(request);
             }
-            var resp = await _Client.SendAsync(request);
+            var resp = await HttpClient.SendAsync(request);
             resp.EnsureSuccessStatusCode();
         }
 
@@ -162,7 +178,7 @@ namespace BTCPayServer.Services.Rates
             {
                 await auth.AddHeader(request);
             }
-            var resp = await _Client.SendAsync(request);
+            var resp = await HttpClient.SendAsync(request);
             resp.EnsureSuccessStatusCode();
             var jobj = JObject.Parse(await resp.Content.ReadAsStringAsync());
             var response = new GetRateLimitsResponse();
@@ -193,7 +209,7 @@ namespace BTCPayServer.Services.Rates
             {
                 await auth.AddHeader(request);
             }
-            var resp = await _Client.SendAsync(request);
+            var resp = await HttpClient.SendAsync(request);
             resp.EnsureSuccessStatusCode();
             var jobj = JObject.Parse(await resp.Content.ReadAsStringAsync());
             var response = new GetExchangeTickersResponse();

BTCPayServer.Rating/Providers/CoinAverageSettings.cs

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

BTCPayServer.Rating/Providers/ExchangeSharpRateProvider.cs

@@ -1,15 +1,17 @@
 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
+    public class ExchangeSharpRateProvider : IRateProvider, IHasExchangeName
     {
         readonly ExchangeAPI _ExchangeAPI;
         readonly string _ExchangeName;
@@ -28,14 +30,18 @@ namespace BTCPayServer.Services.Rates
             get; set;
         }
 
-        public async Task<ExchangeRates> GetRatesAsync()
+        public string ExchangeName => _ExchangeName;
+
+        public async Task<ExchangeRates> GetRatesAsync(CancellationToken cancellationToken)
         {
             await new SynchronizationContextRemover();
             var rates = await _ExchangeAPI.GetTickersAsync();
             lock (notFoundSymbols)
             {
                 var exchangeRates =
-                    rates.Select(t => CreateExchangeRate(t))
+                    rates
+                    .Where(t => t.Value.Ask != 0m && t.Value.Bid != 0m)
+                    .Select(t => CreateExchangeRate(t))
                     .Where(t => t != null)
                     .ToArray();
                 return new ExchangeRates(exchangeRates);
@@ -43,17 +49,17 @@ namespace BTCPayServer.Services.Rates
         }
 
         // ExchangeSymbolToGlobalSymbol throws exception which would kill perf
-        HashSet<string> notFoundSymbols = new HashSet<string>();
+        ConcurrentDictionary<string, string> notFoundSymbols = new ConcurrentDictionary<string, string>();
         private ExchangeRate CreateExchangeRate(KeyValuePair<string, ExchangeTicker> ticker)
         {
-            if (notFoundSymbols.Contains(ticker.Key))
+            if (notFoundSymbols.ContainsKey(ticker.Key))
                 return null;
             try
             {
                 var tickerName = _ExchangeAPI.ExchangeSymbolToGlobalSymbol(ticker.Key);
                 if (!CurrencyPair.TryParse(tickerName, out var pair))
                 {
-                    notFoundSymbols.Add(ticker.Key);
+                    notFoundSymbols.TryAdd(ticker.Key, ticker.Key);
                     return null;
                 }
                 if(ReverseCurrencyPair)
@@ -66,7 +72,7 @@ namespace BTCPayServer.Services.Rates
             }
             catch (ArgumentException)
             {
-                notFoundSymbols.Add(ticker.Key);
+                notFoundSymbols.TryAdd(ticker.Key, ticker.Key);
                 return null;
             }
         }

BTCPayServer.Rating/Providers/FallbackRateProvider.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Rating;
 
@@ -9,7 +10,6 @@ namespace BTCPayServer.Services.Rates
     public class FallbackRateProvider : IRateProvider
     {
         IRateProvider[] _Providers;
-        public bool Used { get; set; }
         public FallbackRateProvider(IRateProvider[] providers)
         {
             if (providers == null)
@@ -17,14 +17,17 @@ namespace BTCPayServer.Services.Rates
             _Providers = providers;
         }
 
-        public async Task<ExchangeRates> GetRatesAsync()
+        public async Task<ExchangeRates> GetRatesAsync(CancellationToken cancellationToken)
         {
-            Used = true;
             foreach (var p in _Providers)
             {
                 try
                 {
-                    return await p.GetRatesAsync().ConfigureAwait(false);
+                    return await p.GetRatesAsync(cancellationToken).ConfigureAwait(false);
+                }
+                catch when (cancellationToken.IsCancellationRequested)
+                {
+                    throw;
                 }
                 catch(Exception ex) { Exceptions.Add(ex); }
             }

BTCPayServer.Rating/Providers/IHasExchangeName.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Services.Rates
+{
+    public interface IHasExchangeName
+    {
+        string ExchangeName { get; }
+    }
+}

BTCPayServer.Rating/Providers/IRateProvider.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Rating;
 
@@ -8,6 +9,6 @@ namespace BTCPayServer.Services.Rates
 {
     public interface IRateProvider
     {
-        Task<ExchangeRates> GetRatesAsync();
+        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/NdaxRateProvider.cs

@@ -0,0 +1,36 @@
+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 NdaxRateProvider : IRateProvider, IHasExchangeName
+    {
+        private readonly HttpClient _httpClient;
+
+        public NdaxRateProvider(HttpClient httpClient)
+        {
+            _httpClient = httpClient ?? new HttpClient();
+        }
+
+        public string ExchangeName => "ndax";
+
+        public async Task<ExchangeRates> GetRatesAsync(CancellationToken cancellationToken)
+        {
+            var response = await _httpClient.GetAsync("https://ndax.io/api/returnTicker", cancellationToken);
+            var jobj = await response.Content.ReadAsAsync<Dictionary<string, JObject>>(cancellationToken);
+            return new ExchangeRates(jobj.Select(pair => new ExchangeRate(ExchangeName, CurrencyPair.Parse(pair.Key),
+                new BidAsk(GetValue(pair.Value["highestBid"]), GetValue(pair.Value["lowestAsk"])))));
+        }
+
+        private static decimal GetValue(JToken jobj)
+        {
+            return string.IsNullOrEmpty(jobj.ToString()) ? 0 : jobj.Value<decimal>();
+        }
+
+    }
+}

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

@@ -77,7 +77,7 @@ namespace BTCPayServer.Rating
                     if (CurrencyPair.TryParse(id.Identifier.ValueText, out var currencyPair))
                     {
                         expression = expression.WithTriviaFrom(expression);
-                        ExpressionsByPair.Add(currencyPair, (expression, id));
+                        ExpressionsByPair.TryAdd(currencyPair, (expression, id));
                     }
                 }
                 base.VisitAssignmentExpression(node);

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,196 @@
+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("ndax", new NdaxRateProvider(_httpClientFactory?.CreateClient("EXCHANGE_NDAX")));
+            Providers.Add("bitbank", new BitbankRateProvider(_httpClientFactory?.CreateClient("EXCHANGE_BITBANK")));
+            Providers.Add("bitpay", new BitpayRateProvider(_httpClientFactory?.CreateClient("EXCHANGE_BITPAY")));
+
+            // Those exchanges make multiple requests when calling GetTickers so we remove them
+            //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("ndax", "NDAX", "https://ndax.io/api/returnTicker"));
+            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/AuthenticationTests.cs

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

BTCPayServer.Tests/BTCPayServer.Tests.csproj

@@ -6,16 +6,18 @@
     <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.7.2" />
-    <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.2.0" />
+    <PackageReference Include="Selenium.WebDriver" Version="3.141.0" />
+    <PackageReference Include="Selenium.WebDriver.ChromeDriver" Version="76.0.3809.6801" />
+    <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>
@@ -25,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>