update translation

Add hardware support via BTCPayServer Vault

.circleci/config.yml

@@ -2,7 +2,7 @@ version: 2
 jobs:
   fast_tests:
     machine:
-        docker_layer_caching: true
+        enabled: true
     steps:
       - checkout
       - run:
@@ -10,7 +10,7 @@ jobs:
             cd .circleci && ./run-tests.sh "Fast=Fast"
   selenium_tests:
     machine:
-        docker_layer_caching: true
+        enabled: true
     steps:
       - checkout
       - run:
@@ -18,7 +18,7 @@ jobs:
             cd .circleci && ./run-tests.sh "Selenium=Selenium"
   integration_tests:
     machine:
-        docker_layer_caching: true
+        enabled: true
     steps:
       - checkout
       - run:
@@ -26,18 +26,22 @@ jobs:
             cd .circleci && ./run-tests.sh "Integration=Integration"
   external_tests:
     machine:
-        docker_layer_caching: true
+        enabled: true
     steps:
       - checkout
       - run:
           command: |
-            cd .circleci && ./run-tests.sh "ExternalIntegration=ExternalIntegration"
+            if [ "$CIRCLE_PROJECT_USERNAME" == "btcpayserver" ] && [ "$CIRCLE_PROJECT_REPONAME" == "btcpayserver" ]; then
+                cd .circleci && ./run-tests.sh "ExternalIntegration=ExternalIntegration"
+            else
+              echo "Skipping running ExternalIntegration tests outside of context of main user and repository that have access to secrets"
+            fi
 
 
   # publish jobs require $DOCKERHUB_REPO, $DOCKERHUB_USER, $DOCKERHUB_PASS defined
   amd64:
     machine:
-      docker_layer_caching: true
+        enabled: true
     steps:
       - checkout  
       - run:
@@ -50,7 +54,7 @@ jobs:
 
   arm32v7:
     machine:
-      docker_layer_caching: true
+        enabled: true
     steps:
       - checkout  
       - run:
@@ -100,15 +104,16 @@ workflows:
             # ignore any commit on any branch by default
             branches:
               ignore: /.*/
-            # only act on version tags
+            # only act on version tags v1.0.0.88
+            # OR feature tags like vlndseedbackup
             tags:
-              only: /v[1-9]+(\.[0-9]+)*/
+              only: /(v[1-9]+(\.[0-9]+)*)|(v[a-z]+)/
       - arm32v7:
           filters:
             branches:
               ignore: /.*/
             tags:
-              only: /v[1-9]+(\.[0-9]+)*/
+              only: /(v[1-9]+(\.[0-9]+)*)|(v[a-z]+)/
       - multiarch:
           requires:
             - amd64
@@ -117,4 +122,4 @@ workflows:
             branches:
               ignore: /.*/
             tags:
-              only: /v[1-9]+(\.[0-9]+)*/
+              only: /(v[1-9]+(\.[0-9]+)*)|(v[a-z]+)/

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.Bitcoinplus.cs

@@ -20,7 +20,7 @@ namespace BTCPayServer
                 NBitcoinNetwork = nbxplorerNetwork.NBitcoinNetwork,
                 NBXplorerNetwork = nbxplorerNetwork,
                 UriScheme = "bitcoinplus",
-                DefaultRateRules = new[] 
+                DefaultRateRules = new[]
                 {
                                 "XBC_X = XBC_BTC * BTC_X",
                                 "XBC_BTC = cryptopia(XBC_BTC)"

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.cs

@@ -56,6 +56,8 @@ namespace BTCPayServer
             InitFeathercoin();
             InitGroestlcoin();
             InitViacoin();
+            InitMonero();
+            
             // Assume that electrum mappings are same as BTC if not specified
             foreach (var network in _Networks.Values.OfType<BTCPayNetwork>())
             {

BTCPayServer.Common/Altcoins/Monero/BTCPayNetworkProvider.Monero.cs

@@ -0,0 +1,21 @@
+using NBitcoin;
+
+namespace BTCPayServer
+{
+    public partial class BTCPayNetworkProvider
+    {
+        public void InitMonero()
+        {
+            Add(new MoneroLikeSpecificBtcPayNetwork()
+            {
+                CryptoCode = "XMR",
+                DisplayName = "Monero",
+                BlockExplorerLink =
+                    NetworkType == NetworkType.Mainnet
+                        ? "https://www.exploremonero.com/transaction/{0}"
+                        : "https://testnet.xmrchain.net/tx/{0}",
+                CryptoImagePath = "/imlegacy/monero.svg"
+            });
+        }
+    }
+}

BTCPayServer.Common/Altcoins/Monero/MoneroLikeSpecificBtcPayNetwork.cs

@@ -0,0 +1,7 @@
+namespace BTCPayServer
+{
+    public class MoneroLikeSpecificBtcPayNetwork : BTCPayNetworkBase
+    {
+        public int MaxTrackedConfirmation = 10;
+    }
+}

BTCPayServer.Common/Altcoins/Monero/RPC/JsonRpcClient.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
+
+namespace BTCPayServer.Services.Altcoins.Monero.RPC
+{
+    public class JsonRpcClient
+    {
+        private readonly Uri _address;
+        private readonly string _username;
+        private readonly string _password;
+        private readonly HttpClient _httpClient;
+
+        public JsonRpcClient(Uri address, string username, string password, HttpClient client = null)
+        {
+            _address = address;
+            _username = username;
+            _password = password;
+            _httpClient = client ?? new HttpClient();
+        }
+
+
+        public async Task<TResponse> SendCommandAsync<TRequest, TResponse>(string method, TRequest data,
+            CancellationToken cts = default(CancellationToken))
+        {
+            var jsonSerializer = new JsonSerializerSettings
+            {
+                ContractResolver = new CamelCasePropertyNamesContractResolver()
+            };
+            var httpRequest = new HttpRequestMessage()
+            {
+                Method = HttpMethod.Post,
+                RequestUri = new Uri(_address, "json_rpc"),
+                Content = new StringContent(
+                    JsonConvert.SerializeObject(new JsonRpcCommand<TRequest>(method, data), jsonSerializer),
+                    Encoding.UTF8, "application/json")
+            };
+            httpRequest.Headers.Accept.Clear();
+            httpRequest.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
+            httpRequest.Headers.Authorization = new AuthenticationHeaderValue("Basic",
+                Convert.ToBase64String(Encoding.Default.GetBytes($"{_username}:{_password}")));
+
+            var rawResult = await _httpClient.SendAsync(httpRequest, cts);
+            
+            var rawJson = await rawResult.Content.ReadAsStringAsync();
+            rawResult.EnsureSuccessStatusCode();
+            JsonRpcResult<TResponse> response;
+            try
+            {
+                response = JsonConvert.DeserializeObject<JsonRpcResult<TResponse>>(rawJson, jsonSerializer);
+            }
+            catch (Exception e)
+            {
+                Console.WriteLine(e.Message);
+                Console.WriteLine(rawJson);
+                throw;
+            }
+
+            if (response.Error != null)
+            {
+                throw new JsonRpcApiException()
+                {
+                    Error = response.Error
+                };
+            }
+            
+            return response.Result;
+        }
+
+        public class NoRequestModel
+        {
+            public static NoRequestModel Instance = new NoRequestModel();
+        }
+
+        internal class JsonRpcApiException : Exception
+        {
+            public JsonRpcResultError Error { get; set; }
+
+            public override string Message => Error?.Message;
+        }
+
+        public class JsonRpcResultError
+        {
+            [JsonProperty("code")] public int Code { get; set; }
+            [JsonProperty("message")] public string Message { get; set; }
+            [JsonProperty("data")] dynamic Data { get; set; }
+        }
+        internal class JsonRpcResult<T>
+        {
+            
+
+            [JsonProperty("result")] public T Result { get; set; }
+            [JsonProperty("error")] public JsonRpcResultError Error { get; set; }
+            [JsonProperty("id")] public string Id { get; set; }
+        }
+
+        internal class JsonRpcCommand<T>
+        {
+            [JsonProperty("jsonRpc")] public string JsonRpc { get; set; } = "2.0";
+            [JsonProperty("id")] public string Id { get; set; } = Guid.NewGuid().ToString();
+            [JsonProperty("method")] public string Method { get; set; }
+
+            [JsonProperty("params")] public T Parameters { get; set; }
+
+            public JsonRpcCommand()
+            {
+            }
+
+            public JsonRpcCommand(string method, T parameters)
+            {
+                Method = method;
+                Parameters = parameters;
+            }
+        }
+    }
+}

BTCPayServer.Common/Altcoins/Monero/RPC/Models/CreateAccountRequest.cs

@@ -0,0 +1,9 @@
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Services.Altcoins.Monero.RPC.Models
+{
+    public partial class CreateAccountRequest
+    {
+        [JsonProperty("label")] public string Label { get; set; }
+    }
+}

BTCPayServer.Common/Altcoins/Monero/RPC/Models/CreateAccountResponse.cs

@@ -0,0 +1,10 @@
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Services.Altcoins.Monero.RPC.Models
+{
+    public partial class CreateAccountResponse
+    {
+        [JsonProperty("account_index")] public long AccountIndex { get; set; }
+        [JsonProperty("address")] public string Address { get; set; }
+    }
+}

BTCPayServer.Common/Altcoins/Monero/RPC/Models/CreateAddressRequest.cs

@@ -0,0 +1,10 @@
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Services.Altcoins.Monero.RPC.Models
+{
+    public partial class CreateAddressRequest
+    {
+        [JsonProperty("account_index")] public long AccountIndex { get; set; }
+        [JsonProperty("label")] public string Label { get; set; }
+    }
+}

BTCPayServer.Common/Altcoins/Monero/RPC/Models/CreateAddressResponse.cs

@@ -0,0 +1,10 @@
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Services.Altcoins.Monero.RPC.Models
+{
+    public partial class CreateAddressResponse
+    {
+        [JsonProperty("address")] public string Address { get; set; }
+        [JsonProperty("address_index")] public long AddressIndex { get; set; }
+    }
+}

BTCPayServer.Common/Altcoins/Monero/RPC/Models/GetAccountsRequest.cs

@@ -0,0 +1,9 @@
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Services.Altcoins.Monero.RPC.Models
+{
+    public partial class GetAccountsRequest
+    {
+        [JsonProperty("tag")] public string Tag { get; set; }
+    }
+}

BTCPayServer.Common/Altcoins/Monero/RPC/Models/GetAccountsResponse.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Services.Altcoins.Monero.RPC.Models
+{
+    public partial class GetAccountsResponse
+    {
+        [JsonProperty("subaddress_accounts")] public List<SubaddressAccount> SubaddressAccounts { get; set; }
+        [JsonProperty("total_balance")] public decimal TotalBalance { get; set; }
+
+        [JsonProperty("total_unlocked_balance")]
+        public decimal TotalUnlockedBalance { get; set; }
+    }
+}

BTCPayServer.Common/Altcoins/Monero/RPC/Models/GetFeeEstimateRequest.cs

@@ -0,0 +1,9 @@
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Services.Altcoins.Monero.RPC.Models
+{
+    public class GetFeeEstimateRequest
+    {
+        [JsonProperty("grace_blocks")] public int? GraceBlocks { get; set; }
+    }
+}

BTCPayServer.Common/Altcoins/Monero/RPC/Models/GetFeeEstimateResponse.cs

@@ -0,0 +1,11 @@
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Services.Altcoins.Monero.RPC.Models
+{
+    public class GetFeeEstimateResponse
+    {
+        [JsonProperty("fee")] public long Fee { get; set; }
+        [JsonProperty("status")] public string Status { get; set; }
+        [JsonProperty("untrusted")] public bool Untrusted { get; set; }
+    }
+}

BTCPayServer.Common/Altcoins/Monero/RPC/Models/GetHeightResponse.cs

@@ -0,0 +1,9 @@
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Services.Altcoins.Monero.RPC.Models
+{
+    public partial class GetHeightResponse
+    {
+        [JsonProperty("height")] public long Height { get; set; }
+    }
+}

BTCPayServer.Common/Altcoins/Monero/RPC/Models/GetTransferByTransactionIdRequest.cs

@@ -0,0 +1,11 @@
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Services.Altcoins.Monero.RPC.Models
+{
+    public class GetTransferByTransactionIdRequest
+    {
+        [JsonProperty("txid")] public string TransactionId { get; set; }
+
+        [JsonProperty("account_index")] public long AccountIndex { get; set; }
+    }
+}

BTCPayServer.Common/Altcoins/Monero/RPC/Models/GetTransferByTransactionIdResponse.cs

@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Services.Altcoins.Monero.RPC.Models
+{
+    public partial class GetTransferByTransactionIdResponse
+    {
+        [JsonProperty("transfer")] public TransferItem Transfer { get; set; }
+        [JsonProperty("transfers")] public IEnumerable<TransferItem> Transfers { get; set; }
+
+        public partial class TransferItem
+        {
+            [JsonProperty("address")] public string Address { get; set; }
+            [JsonProperty("amount")] public long Amount { get; set; }
+            [JsonProperty("confirmations")] public long Confirmations { get; set; }
+            [JsonProperty("double_spend_seen")] public bool DoubleSpendSeen { get; set; }
+            [JsonProperty("fee")] public long Fee { get; set; }
+            [JsonProperty("height")] public long Height { get; set; }
+            [JsonProperty("note")] public string Note { get; set; }
+            [JsonProperty("payment_id")] public string PaymentId { get; set; }
+            [JsonProperty("subaddr_index")] public SubaddrIndex SubaddrIndex { get; set; }
+
+            [JsonProperty("suggested_confirmations_threshold")]
+            public long SuggestedConfirmationsThreshold { get; set; }
+
+            [JsonProperty("timestamp")] public long Timestamp { get; set; }
+            [JsonProperty("txid")] public string Txid { get; set; }
+            [JsonProperty("type")] public string Type { get; set; }
+            [JsonProperty("unlock_time")] public long UnlockTime { get; set; }
+        }
+    }
+}

BTCPayServer.Common/Altcoins/Monero/RPC/Models/GetTransfersRequest.cs

@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Services.Altcoins.Monero.RPC.Models
+{
+    public partial class GetTransfersRequest
+    {
+        [JsonProperty("in")] public bool In { get; set; }
+        [JsonProperty("out")] public bool Out { get; set; }
+        [JsonProperty("pending")] public bool Pending { get; set; }
+        [JsonProperty("failed")] public bool Failed { get; set; }
+        [JsonProperty("pool")] public bool Pool { get; set; }
+        [JsonProperty("filter_by_height ")] public bool FilterByHeight { get; set; }
+        [JsonProperty("min_height")] public long MinHeight { get; set; }
+        [JsonProperty("max_height")] public long MaxHeight { get; set; }
+        [JsonProperty("account_index")] public long AccountIndex { get; set; }
+        [JsonProperty("subaddr_indices")] public List<long> SubaddrIndices { get; set; }
+    }
+}

BTCPayServer.Common/Altcoins/Monero/RPC/Models/GetTransfersResponse.cs

@@ -0,0 +1,36 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Services.Altcoins.Monero.RPC.Models
+{
+    public partial class GetTransfersResponse
+    {
+        [JsonProperty("in")] public List<GetTransfersResponseItem> In { get; set; }
+        [JsonProperty("out")] public List<GetTransfersResponseItem> Out { get; set; }
+        [JsonProperty("pending")] public List<GetTransfersResponseItem> Pending { get; set; }
+        [JsonProperty("failed")] public List<GetTransfersResponseItem> Failed { get; set; }
+        [JsonProperty("pool")] public List<GetTransfersResponseItem> Pool { get; set; }
+
+        public partial class GetTransfersResponseItem
+
+        {
+            [JsonProperty("address")] public string Address { get; set; }
+            [JsonProperty("amount")] public long Amount { get; set; }
+            [JsonProperty("confirmations")] public long Confirmations { get; set; }
+            [JsonProperty("double_spend_seen")] public bool DoubleSpendSeen { get; set; }
+            [JsonProperty("fee")] public long Fee { get; set; }
+            [JsonProperty("height")] public long Height { get; set; }
+            [JsonProperty("note")] public string Note { get; set; }
+            [JsonProperty("payment_id")] public string PaymentId { get; set; }
+            [JsonProperty("subaddr_index")] public SubaddrIndex SubaddrIndex { get; set; }
+
+            [JsonProperty("suggested_confirmations_threshold")]
+            public long SuggestedConfirmationsThreshold { get; set; }
+
+            [JsonProperty("timestamp")] public long Timestamp { get; set; }
+            [JsonProperty("txid")] public string Txid { get; set; }
+            [JsonProperty("type")] public string Type { get; set; }
+            [JsonProperty("unlock_time")] public long UnlockTime { get; set; }
+        }
+    }
+}

BTCPayServer.Common/Altcoins/Monero/RPC/Models/Info.cs

@@ -0,0 +1,33 @@
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Services.Altcoins.Monero.RPC.Models
+{
+    public partial class Info
+    {
+        [JsonProperty("address")] public string Address { get; set; }
+        [JsonProperty("avg_download")] public long AvgDownload { get; set; }
+        [JsonProperty("avg_upload")] public long AvgUpload { get; set; }
+        [JsonProperty("connection_id")] public string ConnectionId { get; set; }
+        [JsonProperty("current_download")] public long CurrentDownload { get; set; }
+        [JsonProperty("current_upload")] public long CurrentUpload { get; set; }
+        [JsonProperty("height")] public long Height { get; set; }
+        [JsonProperty("host")] public string Host { get; set; }
+        [JsonProperty("incoming")] public bool Incoming { get; set; }
+        [JsonProperty("ip")] public string Ip { get; set; }
+        [JsonProperty("live_time")] public long LiveTime { get; set; }
+        [JsonProperty("local_ip")] public bool LocalIp { get; set; }
+        [JsonProperty("localhost")] public bool Localhost { get; set; }
+        [JsonProperty("peer_id")] public string PeerId { get; set; }
+
+        [JsonProperty("port")]
+        [JsonConverter(typeof(ParseStringConverter))]
+        public long Port { get; set; }
+
+        [JsonProperty("recv_count")] public long RecvCount { get; set; }
+        [JsonProperty("recv_idle_time")] public long RecvIdleTime { get; set; }
+        [JsonProperty("send_count")] public long SendCount { get; set; }
+        [JsonProperty("send_idle_time")] public long SendIdleTime { get; set; }
+        [JsonProperty("state")] public string State { get; set; }
+        [JsonProperty("support_flags")] public long SupportFlags { get; set; }
+    }
+}

BTCPayServer.Common/Altcoins/Monero/RPC/Models/MakeUriRequest.cs

@@ -0,0 +1,13 @@
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Services.Altcoins.Monero.RPC.Models
+{
+    public partial class MakeUriRequest
+    {
+        [JsonProperty("address")] public string Address { get; set; }
+        [JsonProperty("amount")] public long Amount { get; set; }
+        [JsonProperty("payment_id")] public string PaymentId { get; set; }
+        [JsonProperty("tx_description")] public string TxDescription { get; set; }
+        [JsonProperty("recipient_name")] public string RecipientName { get; set; }
+    }
+}

BTCPayServer.Common/Altcoins/Monero/RPC/Models/MakeUriResponse.cs

@@ -0,0 +1,9 @@
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Services.Altcoins.Monero.RPC.Models
+{
+    public partial class MakeUriResponse
+    {
+        [JsonProperty("uri")] public string Uri { get; set; }
+    }
+}

BTCPayServer.Common/Altcoins/Monero/RPC/Models/ParseStringConverter.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Globalization;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Services.Altcoins.Monero.RPC.Models
+{
+    internal class ParseStringConverter : JsonConverter
+    {
+        public override bool CanConvert(Type t) => t == typeof(long) || t == typeof(long?);
+
+        public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null) return null;
+            var value = serializer.Deserialize<string>(reader);
+            long l;
+            if (Int64.TryParse(value, out l))
+            {
+                return l;
+            }
+
+            throw new Exception("Cannot unmarshal type long");
+        }
+
+        public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
+        {
+            if (untypedValue == null)
+            {
+                serializer.Serialize(writer, null);
+                return;
+            }
+
+            var value = (long)untypedValue;
+            serializer.Serialize(writer, value.ToString(CultureInfo.InvariantCulture));
+            return;
+        }
+
+        public static readonly ParseStringConverter Singleton = new ParseStringConverter();
+    }
+}

BTCPayServer.Common/Altcoins/Monero/RPC/Models/Peer.cs

@@ -0,0 +1,9 @@
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Services.Altcoins.Monero.RPC.Models
+{
+    public partial class Peer
+    {
+        [JsonProperty("info")] public Info Info { get; set; }
+    }
+}

BTCPayServer.Common/Altcoins/Monero/RPC/Models/SubaddrIndex.cs

@@ -0,0 +1,10 @@
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Services.Altcoins.Monero.RPC.Models
+{
+    public partial class SubaddrIndex
+    {
+        [JsonProperty("major")] public long Major { get; set; }
+        [JsonProperty("minor")] public long Minor { get; set; }
+    }
+}

BTCPayServer.Common/Altcoins/Monero/RPC/Models/SubaddressAccount.cs

@@ -0,0 +1,14 @@
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Services.Altcoins.Monero.RPC.Models
+{
+    public partial class SubaddressAccount
+    {
+        [JsonProperty("account_index")] public long AccountIndex { get; set; }
+        [JsonProperty("balance")] public decimal Balance { get; set; }
+        [JsonProperty("base_address")] public string BaseAddress { get; set; }
+        [JsonProperty("label")] public string Label { get; set; }
+        [JsonProperty("tag")] public string Tag { get; set; }
+        [JsonProperty("unlocked_balance")] public decimal UnlockedBalance { get; set; }
+    }
+}

BTCPayServer.Common/Altcoins/Monero/RPC/Models/SyncInfoResponse.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Services.Altcoins.Monero.RPC.Models
+{
+    public partial class SyncInfoResponse
+    {
+        [JsonProperty("height")] public long Height { get; set; }
+        [JsonProperty("peers")] public List<Peer> Peers { get; set; }
+        [JsonProperty("status")] public string Status { get; set; }
+        [JsonProperty("target_height")] public long? TargetHeight { get; set; }
+    }
+}

BTCPayServer.Common/Altcoins/Monero/Utils/MoneroMoney.cs

@@ -0,0 +1,20 @@
+using System.Globalization;
+
+namespace BTCPayServer.Services.Altcoins.Monero.Utils
+{
+    public class MoneroMoney
+    {
+        public static decimal Convert(long piconero)
+        {
+            var amt = piconero.ToString(CultureInfo.InvariantCulture).PadLeft(12, '0');
+            amt = amt.Length == 12 ? $"0.{amt}" : amt.Insert(amt.Length - 12, ".");
+
+            return decimal.Parse(amt, CultureInfo.InvariantCulture);
+        }
+
+        public static long Convert(decimal monero)
+        {
+            return System.Convert.ToInt64(monero * 1000000000000);
+        }
+    }
+}

BTCPayServer.Common/BTCPayNetwork.cs

@@ -52,6 +52,7 @@ namespace BTCPayServer
         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 int MaxTrackedConfirmation { get; internal set; } = 6;
@@ -103,7 +104,6 @@ namespace BTCPayServer
 
     public abstract class BTCPayNetworkBase
     {
-        
         public string CryptoCode { get; internal set; }
         public string BlockExplorerLink { get; internal set; }
         public string DisplayName { get; set; }
@@ -126,12 +126,12 @@ namespace BTCPayServer
 
         public virtual T ToObject<T>(string json)
         {
-            return JsonConvert.DeserializeObject<T>(json);
+            return NBitcoin.JsonConverters.Serializer.ToObject<T>(json, null);
         }
 
         public virtual string ToString<T>(T obj)
         {
-            return JsonConvert.SerializeObject(obj);
+            return NBitcoin.JsonConverters.Serializer.ToString(obj, null);
         }
     }
 }

BTCPayServer.Common/BTCPayServer.Common.csproj

@@ -3,8 +3,8 @@
   <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" />
+    <PackageReference Include="Microsoft.AspNetCore.App" Version="2.1.9" Condition="'$(TargetFramework)' == 'netcoreapp2.1'" />
+    <FrameworkReference Include="Microsoft.AspNetCore.App" Condition="'$(TargetFramework)' != 'netcoreapp2.1'" />
+    <PackageReference Include="NBXplorer.Client" Version="2.0.0.26" />
   </ItemGroup>
 </Project>

BTCPayServer.Common/Logging/ConsoleLogger.cs

@@ -4,7 +4,6 @@ using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions.Internal;
 using Microsoft.Extensions.Logging.Console;

BTCPayServer.Common/Shims.cs

@@ -0,0 +1,259 @@
+#if !NETCOREAPP21
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.IO;
+using System.Text;
+using System.Collections;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+
+namespace Microsoft.Extensions.Logging.Console.Internal
+{
+    /// <summary>
+    /// For non-Windows platform consoles which understand the ANSI escape code sequences to represent color
+    /// </summary>
+    internal class AnsiLogConsole : IConsole
+    {
+        private readonly StringBuilder _outputBuilder;
+        private readonly IAnsiSystemConsole _systemConsole;
+
+        public AnsiLogConsole(IAnsiSystemConsole systemConsole)
+        {
+            _outputBuilder = new StringBuilder();
+            _systemConsole = systemConsole;
+        }
+
+        public void Write(string message, ConsoleColor? background, ConsoleColor? foreground)
+        {
+            // Order: backgroundcolor, foregroundcolor, Message, reset foregroundcolor, reset backgroundcolor
+            if (background.HasValue)
+            {
+                _outputBuilder.Append(GetBackgroundColorEscapeCode(background.Value));
+            }
+
+            if (foreground.HasValue)
+            {
+                _outputBuilder.Append(GetForegroundColorEscapeCode(foreground.Value));
+            }
+
+            _outputBuilder.Append(message);
+
+            if (foreground.HasValue)
+            {
+                _outputBuilder.Append("\x1B[39m\x1B[22m"); // reset to default foreground color
+            }
+
+            if (background.HasValue)
+            {
+                _outputBuilder.Append("\x1B[49m"); // reset to the background color
+            }
+        }
+
+        public void WriteLine(string message, ConsoleColor? background, ConsoleColor? foreground)
+        {
+            Write(message, background, foreground);
+            _outputBuilder.AppendLine();
+        }
+
+        public void Flush()
+        {
+            _systemConsole.Write(_outputBuilder.ToString());
+            _outputBuilder.Clear();
+        }
+
+        private static string GetForegroundColorEscapeCode(ConsoleColor color)
+        {
+            switch (color)
+            {
+                case ConsoleColor.Black:
+                    return "\x1B[30m";
+                case ConsoleColor.DarkRed:
+                    return "\x1B[31m";
+                case ConsoleColor.DarkGreen:
+                    return "\x1B[32m";
+                case ConsoleColor.DarkYellow:
+                    return "\x1B[33m";
+                case ConsoleColor.DarkBlue:
+                    return "\x1B[34m";
+                case ConsoleColor.DarkMagenta:
+                    return "\x1B[35m";
+                case ConsoleColor.DarkCyan:
+                    return "\x1B[36m";
+                case ConsoleColor.Gray:
+                    return "\x1B[37m";
+                case ConsoleColor.Red:
+                    return "\x1B[1m\x1B[31m";
+                case ConsoleColor.Green:
+                    return "\x1B[1m\x1B[32m";
+                case ConsoleColor.Yellow:
+                    return "\x1B[1m\x1B[33m";
+                case ConsoleColor.Blue:
+                    return "\x1B[1m\x1B[34m";
+                case ConsoleColor.Magenta:
+                    return "\x1B[1m\x1B[35m";
+                case ConsoleColor.Cyan:
+                    return "\x1B[1m\x1B[36m";
+                case ConsoleColor.White:
+                    return "\x1B[1m\x1B[37m";
+                default:
+                    return "\x1B[39m\x1B[22m"; // default foreground color
+            }
+        }
+
+        private static string GetBackgroundColorEscapeCode(ConsoleColor color)
+        {
+            switch (color)
+            {
+                case ConsoleColor.Black:
+                    return "\x1B[40m";
+                case ConsoleColor.Red:
+                    return "\x1B[41m";
+                case ConsoleColor.Green:
+                    return "\x1B[42m";
+                case ConsoleColor.Yellow:
+                    return "\x1B[43m";
+                case ConsoleColor.Blue:
+                    return "\x1B[44m";
+                case ConsoleColor.Magenta:
+                    return "\x1B[45m";
+                case ConsoleColor.Cyan:
+                    return "\x1B[46m";
+                case ConsoleColor.White:
+                    return "\x1B[47m";
+                default:
+                    return "\x1B[49m"; // Use default background color
+            }
+        }
+    }
+
+	internal class AnsiSystemConsole : IAnsiSystemConsole
+    {
+        private readonly TextWriter _textWriter;
+
+        /// <inheritdoc />
+        public AnsiSystemConsole(bool stdErr = false)
+        {
+            _textWriter = stdErr ? System.Console.Error : System.Console.Out;
+        }
+
+        public void Write(string message)
+        {
+            _textWriter.Write(message);
+        }
+    }
+}
+
+namespace Microsoft.Extensions.Logging.Console
+{
+    internal interface IAnsiSystemConsole
+    {
+        void Write(string message);
+    }
+	public interface IConsole
+    {
+        void Write(string message, ConsoleColor? background, ConsoleColor? foreground);
+        void WriteLine(string message, ConsoleColor? background, ConsoleColor? foreground);
+        void Flush();
+    }
+	internal class WindowsLogConsole : IConsole
+    {
+        private readonly TextWriter _textWriter;
+
+        /// <inheritdoc />
+        public WindowsLogConsole(bool stdErr = false)
+        {
+            _textWriter = stdErr ? System.Console.Error : System.Console.Out;
+        }
+
+        private bool SetColor(ConsoleColor? background, ConsoleColor? foreground)
+        {
+            if (background.HasValue)
+            {
+                System.Console.BackgroundColor = background.Value;
+            }
+
+            if (foreground.HasValue)
+            {
+                System.Console.ForegroundColor = foreground.Value;
+            }
+
+            return background.HasValue || foreground.HasValue;
+        }
+
+        private void ResetColor()
+        {
+            System.Console.ResetColor();
+        }
+
+        public void Write(string message, ConsoleColor? background, ConsoleColor? foreground)
+        {
+            var colorChanged = SetColor(background, foreground);
+            _textWriter.Write(message);
+            if (colorChanged)
+            {
+                ResetColor();
+            }
+        }
+
+        public void WriteLine(string message, ConsoleColor? background, ConsoleColor? foreground)
+        {
+            var colorChanged = SetColor(background, foreground);
+            _textWriter.WriteLine(message);
+            if (colorChanged)
+            {
+                ResetColor();
+            }
+        }
+
+        public void Flush()
+        {
+            // No action required as for every write, data is sent directly to the console
+            // output stream
+        }
+    }
+}
+
+namespace Microsoft.Extensions.Logging.Abstractions.Internal
+{
+    /// <summary>
+    /// An empty scope without any logic
+    /// </summary>
+    internal class NullScope : IDisposable
+    {
+        public static NullScope Instance { get; } = new NullScope();
+
+        private NullScope()
+        {
+        }
+
+        /// <inheritdoc />
+        public void Dispose()
+        {
+        }
+    }
+}
+
+
+#else
+using Microsoft.Extensions.Options;
+using Newtonsoft.Json;
+
+namespace Microsoft.AspNetCore.Mvc
+{
+    /// <summary>
+    /// Provides programmatic configuration for JSON formatters using Newtonsoft.JSON.
+    /// </summary>
+    public class MvcNewtonsoftJsonOptions
+    {
+		IOptions<MvcJsonOptions> jsonOptions;
+		public MvcNewtonsoftJsonOptions(IOptions<MvcJsonOptions> jsonOptions)
+		{
+			this.jsonOptions = jsonOptions;
+		}
+		public JsonSerializerSettings SerializerSettings => this.jsonOptions.Value.SerializerSettings;
+	}
+}
+#endif

BTCPayServer.Data/BTCPayServer.Data.csproj

@@ -1,11 +1,19 @@
 <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" />
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp2.1'">
+    <PackageReference Include="Microsoft.AspNetCore.App" AllowExplicitVersion="true" 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" />
+    <PackageReference Include="OpenIddict.EntityFrameworkCore" Version="3.0.0-alpha1.19515.63" />
+  </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' != 'netcoreapp2.1'">
+    <FrameworkReference Include="Microsoft.AspNetCore.App" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="3.0.0" />
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="3.0.1" />
+    <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="3.0.0-rc1.final" />
+    <PackageReference Include="OpenIddict.EntityFrameworkCore" Version="3.0.0-alpha1.19515.63" />
+    <PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="3.0.0" />
   </ItemGroup>
 </Project>

BTCPayServer.Data/Data/ApplicationDbContextFactory.cs

@@ -45,7 +45,11 @@ namespace BTCPayServer.Data
 
         class CustomNpgsqlMigrationsSqlGenerator : NpgsqlMigrationsSqlGenerator
         {
+#if NETCOREAPP21
             public CustomNpgsqlMigrationsSqlGenerator(MigrationsSqlGeneratorDependencies dependencies) : base(dependencies)
+#else
+            public CustomNpgsqlMigrationsSqlGenerator(MigrationsSqlGeneratorDependencies dependencies,  IMigrationsAnnotationProvider annotations, Npgsql.EntityFrameworkCore.PostgreSQL.Infrastructure.Internal.INpgsqlOptions opts) : base(dependencies, annotations, opts)
+#endif
             {
             }
 

BTCPayServer.Data/Data/StoreData.cs

@@ -73,7 +73,6 @@ namespace BTCPayServer.Data
         }
 
         [NotMapped]
-        [Obsolete]
         public string Role
         {
             get; set;
@@ -88,9 +87,6 @@ namespace BTCPayServer.Data
         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

BTCPayServer.Rating/BTCPayServer.Rating.csproj

@@ -1,19 +1,18 @@
 <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="Microsoft.AspNetCore.App" Version="2.1.9" Condition="'$(TargetFramework)' == 'netcoreapp2.1'" />
+    <FrameworkReference Include="Microsoft.AspNetCore.App" Condition="'$(TargetFramework)' != 'netcoreapp2.1'" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.3.1" Condition="'$(TargetFramework)' != 'netcoreapp2.1'" />
+    <PackageReference Include="Microsoft.AspNet.WebApi.Client" Version="5.2.7" Condition="'$(TargetFramework)' != 'netcoreapp2.1'" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.2" />
-    <PackageReference Include="DigitalRuby.ExchangeSharp" Version="0.5.3" />
+    <PackageReference Include="DigitalRuby.ExchangeSharp" Version="0.6.3" />
   </ItemGroup>
 
   <ItemGroup>

BTCPayServer.Rating/Providers/ExchangeSharpRateProvider.cs

@@ -36,27 +36,27 @@ namespace BTCPayServer.Services.Rates
         {
             await new SynchronizationContextRemover();
             var rates = await _ExchangeAPI.GetTickersAsync();
-            lock (notFoundSymbols)
-            {
-                var exchangeRates =
-                    rates
+
+                var exchangeRateTasks = rates
                     .Where(t => t.Value.Ask != 0m && t.Value.Bid != 0m)
-                    .Select(t => CreateExchangeRate(t))
-                    .Where(t => t != null)
-                    .ToArray();
-                return new ExchangeRates(exchangeRates);
-            }
+                    .Select(t => CreateExchangeRate(t));
+
+                var exchangeRates = await Task.WhenAll(exchangeRateTasks);
+                
+            return new ExchangeRates(exchangeRates
+                .Where(t => t != null)
+                .ToArray());
         }
 
         // ExchangeSymbolToGlobalSymbol throws exception which would kill perf
         ConcurrentDictionary<string, string> notFoundSymbols = new ConcurrentDictionary<string, string>();
-        private ExchangeRate CreateExchangeRate(KeyValuePair<string, ExchangeTicker> ticker)
+        private async Task<ExchangeRate> CreateExchangeRate(KeyValuePair<string, ExchangeTicker> ticker)
         {
-            if (notFoundSymbols.ContainsKey(ticker.Key))
+            if (notFoundSymbols.TryGetValue(ticker.Key, out _))
                 return null;
             try
             {
-                var tickerName = _ExchangeAPI.ExchangeSymbolToGlobalSymbol(ticker.Key);
+                var tickerName = await _ExchangeAPI.ExchangeMarketSymbolToGlobalMarketSymbolAsync(ticker.Key);
                 if (!CurrencyPair.TryParse(tickerName, out var pair))
                 {
                     notFoundSymbols.TryAdd(ticker.Key, ticker.Key);

BTCPayServer.Rating/Providers/KrakenExchangeRateProvider.cs

@@ -90,10 +90,10 @@ namespace BTCPayServer.Services.Rates
         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 symbols = await GetSymbolsAsync(cancellationToken);
+            var normalizedPairsList = symbols.Where(s => !notFoundSymbols.ContainsKey(s)).Select(s => _Helper.NormalizeMarketSymbol(s)).ToList();
             var csvPairsList = string.Join(",", normalizedPairsList);
-            JToken apiTickers = await MakeJsonRequestAsync<JToken>("/0/public/Ticker", null, new Dictionary<string, object> { { "pair", csvPairsList } });
+            JToken apiTickers = await MakeJsonRequestAsync<JToken>("/0/public/Ticker", null, new Dictionary<string, object> { { "pair", csvPairsList } }, cancellationToken: cancellationToken);
             var tickers = new List<KeyValuePair<string, ExchangeTicker>>();
             foreach (string symbol in symbols)
             {
@@ -114,7 +114,7 @@ namespace BTCPayServer.Services.Rates
                         }
                         else
                         {
-                            global = _Helper.ExchangeSymbolToGlobalSymbol(symbol);
+                            global = await _Helper.ExchangeMarketSymbolToGlobalMarketSymbolAsync(symbol);
                         }
                         if (CurrencyPair.TryParse(global, out var pair))
                             result.Add(new ExchangeRate("kraken", pair.Inverse(), new BidAsk(ticker.Bid, ticker.Ask)));
@@ -142,16 +142,16 @@ namespace BTCPayServer.Services.Rates
                 Last = last,
                 Volume = new ExchangeVolume
                 {
-                    BaseVolume = ticker["v"][1].ConvertInvariant<decimal>(),
-                    BaseSymbol = symbol,
-                    ConvertedVolume = ticker["v"][1].ConvertInvariant<decimal>() * last,
-                    ConvertedSymbol = symbol,
+                    BaseCurrencyVolume = ticker["v"][1].ConvertInvariant<decimal>(),
+                    BaseCurrency = symbol,
+                    QuoteCurrencyVolume = ticker["v"][1].ConvertInvariant<decimal>() * last,
+                    QuoteCurrency = symbol,
                     Timestamp = DateTime.UtcNow
                 }
             };
         }
 
-        private async Task<string[]> GetSymbolsAsync()
+        private async Task<string[]> GetSymbolsAsync(CancellationToken cancellationToken)
         {
             if (_LastSymbolUpdate != null && DateTimeOffset.UtcNow - _LastSymbolUpdate.Value < TimeSpan.FromDays(0.5))
             {
@@ -159,7 +159,7 @@ namespace BTCPayServer.Services.Rates
             }
             else
             {
-                JToken json = await MakeJsonRequestAsync<JToken>("/0/public/AssetPairs");
+                JToken json = await MakeJsonRequestAsync<JToken>("/0/public/AssetPairs", cancellationToken: cancellationToken);
                 var symbols = (from prop in json.Children<JProperty>() where !prop.Name.Contains(".d", StringComparison.OrdinalIgnoreCase) select prop.Name).ToArray();
                 _Symbols = symbols;
                 _LastSymbolUpdate = DateTimeOffset.UtcNow;

BTCPayServer.Rating/Providers/NdaxRateProvider.cs

@@ -1,36 +0,0 @@
-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/Services/RateProviderFactory.cs

@@ -9,6 +9,7 @@ using ExchangeSharp;
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
+using MemoryCache = Microsoft.Extensions.Caching.Memory.MemoryCache;
 
 namespace BTCPayServer.Services.Rates
 {
@@ -103,7 +104,8 @@ namespace BTCPayServer.Services.Rates
             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));
+            Providers.Add("hitbtc", new ExchangeSharpRateProvider("hitbtc", new ExchangeHitBTCAPI(), true));
+            Providers.Add("ndax", new ExchangeSharpRateProvider("ndax", new ExchangeNDAXAPI(), true));
 
             // Cryptopia is often not available
             // Disabled because of https://twitter.com/Cryptopia_NZ/status/1085084168852291586
@@ -113,7 +115,6 @@ namespace BTCPayServer.Services.Rates
             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")));
 

BTCPayServer.Tests/AuthenticationTests.cs

@@ -4,8 +4,9 @@ using System.IO;
 using System.Linq;
 using System.Net;
 using System.Threading.Tasks;
-using AspNet.Security.OpenIdConnect.Primitives;
+using System.Security.Claims;
 using BTCPayServer.Tests.Logging;
+using Microsoft.AspNetCore.Authentication.OpenIdConnect;
 using Microsoft.IdentityModel.Protocols.OpenIdConnect;
 using Xunit;
 using Xunit.Abstractions;
@@ -16,24 +17,26 @@ using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using OpenIddict.Abstractions;
 using OpenQA.Selenium;
+using Microsoft.AspNetCore.Identity;
 
 namespace BTCPayServer.Tests
 {
     public class AuthenticationTests
     {
+        public const int TestTimeout = TestUtils.TestTimeout;
         public AuthenticationTests(ITestOutputHelper helper)
         {
             Logs.Tester = new XUnitLog(helper) {Name = "Tests"};
             Logs.LogProvider = new XUnitLogProvider(helper);
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
         public async Task GetRedirectedToLoginPathOnChallenge()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var client = tester.PayTester.HttpClient;
                 //Wallets endpoint is protected
                 var response = await client.GetAsync("wallets");
@@ -49,13 +52,13 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
         public async Task CanGetOpenIdConfiguration()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 using (var response =
                     await tester.PayTester.HttpClient.GetAsync("/.well-known/openid-configuration"))
                 {
@@ -70,16 +73,17 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
         public async Task CanUseNonInteractiveFlows()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
 
                 var user = tester.NewAccount();
                 user.GrantAccess();
+                await user.MakeAdmin();
                 var token = await RegisterPasswordClientAndGetAccessToken(user, null, tester);
                 await TestApiAgainstAccessToken(token, tester, user);
                 token = await RegisterPasswordClientAndGetAccessToken(user, "secret", tester);
@@ -89,17 +93,18 @@ namespace BTCPayServer.Tests
             }
         }
 
+        [Fact(Timeout = TestTimeout)]
         [Trait("Selenium", "Selenium")]
-        [Fact]
         public async Task CanUseImplicitFlow()
         {
             using (var s = SeleniumTester.Create())
             {
-                s.Start();
+                await s.StartAsync();
                 var tester = s.Server;
 
                 var user = tester.NewAccount();
                 user.GrantAccess();
+                await user.MakeAdmin();
                 var id = Guid.NewGuid().ToString();
                 var redirecturi = new Uri("http://127.0.0.1/oidc-callback");
                 var openIdClient = await user.RegisterOpenIdClient(
@@ -108,10 +113,11 @@ namespace BTCPayServer.Tests
                         ClientId = id,
                         DisplayName = id,
                         Permissions = {OpenIddictConstants.Permissions.GrantTypes.Implicit},
-                        RedirectUris = {redirecturi}
+                        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()}");
+                    $"connect/authorize?response_type=token&client_id={id}&redirect_uri={redirecturi.AbsoluteUri}&scope=openid server_management store_management&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();
@@ -126,15 +132,52 @@ namespace BTCPayServer.Tests
                 results = url.Split("#").Last().Split("&").ToDictionary(s1 => s1.Split("=")[0], s1 => s1.Split("=")[1]);
                 await TestApiAgainstAccessToken(results["access_token"], tester, user);
 
+                var stores = await TestApiAgainstAccessToken<StoreData[]>(results["access_token"],
+                    $"api/test/me/stores",
+                    tester.PayTester.HttpClient);
+                Assert.NotEmpty(stores);
+
+                Assert.True(await TestApiAgainstAccessToken<bool>(results["access_token"],
+                $"api/test/me/stores/{stores[0].Id}/can-edit",
+                tester.PayTester.HttpClient));
+
+                //we dont ask for consent after acquiring it the first time for the same scopes.
                 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("&")
+                s.Driver.AssertElementNotFound(By.Id("consent-yes"));
+
+                // Let's asks without scopes
+                LogoutFlow(tester, id, s);
+                id = Guid.NewGuid().ToString();
+                openIdClient = await user.RegisterOpenIdClient(
+                    new OpenIddictApplicationDescriptor()
+                    {
+                        ClientId = id,
+                        DisplayName = id,
+                        Permissions = { OpenIddictConstants.Permissions.GrantTypes.Implicit },
+                        RedirectUris = { redirecturi },
+                    });
+                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();
+                results = s.Driver.Url.Split("#").Last().Split("&")
                     .ToDictionary(s1 => s1.Split("=")[0], s1 => s1.Split("=")[1]);
-                await TestApiAgainstAccessToken(results["access_token"], tester, user);
+
+                await Assert.ThrowsAnyAsync<HttpRequestException>(async () =>
+                {
+                    await TestApiAgainstAccessToken<StoreData[]>(results["access_token"],
+                    $"api/test/me/stores",
+                    tester.PayTester.HttpClient);
+                });
+                await Assert.ThrowsAnyAsync<HttpRequestException>(async () =>
+                {
+                    await TestApiAgainstAccessToken<bool>(results["access_token"],
+                    $"api/test/me/stores/{stores[0].Id}/can-edit",
+                    tester.PayTester.HttpClient);
+                });
             }
         }
 
@@ -148,17 +191,18 @@ namespace BTCPayServer.Tests
             
         }
 
+        [Fact(Timeout = TestTimeout)]
         [Trait("Selenium", "Selenium")]
-        [Fact]
         public async Task CanUseCodeFlow()
         {
             using (var s = SeleniumTester.Create())
             {
-                s.Start();
+                await s.StartAsync();
                 var tester = s.Server;
 
                 var user = tester.NewAccount();
                 user.GrantAccess();
+                await user.MakeAdmin();
                 var id = Guid.NewGuid().ToString();
                 var redirecturi = new Uri("http://127.0.0.1/oidc-callback");
                 var secret = "secret";
@@ -175,7 +219,7 @@ namespace BTCPayServer.Tests
                         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()}");
+                    $"connect/authorize?response_type=code&client_id={id}&redirect_uri={redirecturi.AbsoluteUri}&scope=openid offline_access server_management store_management&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();
@@ -205,7 +249,7 @@ namespace BTCPayServer.Tests
                 Assert.True(response.IsSuccessStatusCode);
 
                 string content = await response.Content.ReadAsStringAsync();
-                var result = JObject.Parse(content).ToObject<OpenIdConnectResponse>();
+                var result = JObject.Parse(content).ToObject<OpenIddictResponse>();
 
                 await TestApiAgainstAccessToken(result.AccessToken, tester, user);
 
@@ -245,7 +289,7 @@ namespace BTCPayServer.Tests
             Assert.True(response.IsSuccessStatusCode);
 
             string content = await response.Content.ReadAsStringAsync();
-            var result = JObject.Parse(content).ToObject<OpenIdConnectResponse>();
+            var result = JObject.Parse(content).ToObject<OpenIddictResponse>();
             Assert.NotEmpty(result.AccessToken);
             Assert.Null(result.Error);
             return result.AccessToken;
@@ -275,7 +319,8 @@ namespace BTCPayServer.Tests
                     new KeyValuePair<string, string>("grant_type",
                         OpenIddictConstants.GrantTypes.ClientCredentials),
                     new KeyValuePair<string, string>("client_id", openIdClient.ClientId),
-                    new KeyValuePair<string, string>("client_secret", secret)
+                    new KeyValuePair<string, string>("client_secret", secret),
+                    new KeyValuePair<string, string>("scope", "server_management store_management")
                 })
             };
 
@@ -285,7 +330,7 @@ namespace BTCPayServer.Tests
             Assert.True(response.IsSuccessStatusCode);
 
             string content = await response.Content.ReadAsStringAsync();
-            var result = JObject.Parse(content).ToObject<OpenIdConnectResponse>();
+            var result = JObject.Parse(content).ToObject<OpenIddictResponse>();
             Assert.NotEmpty(result.AccessToken);
             Assert.Null(result.Error);
             return result.AccessToken;
@@ -315,7 +360,8 @@ namespace BTCPayServer.Tests
                     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)
+                    new KeyValuePair<string, string>("client_secret", secret),
+                    new KeyValuePair<string, string>("scope", "server_management store_management")
                 })
             };
 
@@ -325,7 +371,7 @@ namespace BTCPayServer.Tests
             Assert.True(response.IsSuccessStatusCode);
 
             string content = await response.Content.ReadAsStringAsync();
-            var result = JObject.Parse(content).ToObject<OpenIdConnectResponse>();
+            var result = JObject.Parse(content).ToObject<OpenIddictResponse>();
             Assert.NotEmpty(result.AccessToken);
             Assert.Null(result.Error);
             return result.AccessToken;
@@ -353,8 +399,7 @@ namespace BTCPayServer.Tests
                 $"api/test/me/stores/{testAccount.StoreId}/can-edit",
                 tester.PayTester.HttpClient));
 
-
-            Assert.Equal(testAccount.RegisterDetails.IsAdmin, await TestApiAgainstAccessToken<bool>(accessToken,
+            Assert.True(await TestApiAgainstAccessToken<bool>(accessToken,
                 $"api/test/me/is-admin",
                 tester.PayTester.HttpClient));
 

BTCPayServer.Tests/BTCPayServer.Tests.csproj

@@ -2,17 +2,25 @@
 
   <PropertyGroup>
     <TargetFramework>netcoreapp2.1</TargetFramework>
-
+    <TargetFramework Condition="'$(TargetFrameworkOverride)' != ''">$(TargetFrameworkOverride)</TargetFramework>
     <IsPackable>false</IsPackable>
     <NoWarn>NU1701,CA1816,CA1308,CA1810,CA2208</NoWarn>
     <LangVersion>7.2</LangVersion>
     <UserSecretsId>AB0AC1DD-9D26-485B-9416-56A33F268117</UserSecretsId>
   </PropertyGroup>
 
+  <PropertyGroup Condition="'$(TargetFramework)' == 'netcoreapp2.1'">
+    <DefineConstants>$(DefineConstants);NETCOREAPP21</DefineConstants>
+  </PropertyGroup>
+  
+  <PropertyGroup Condition="'$(CI_TESTS)' == 'true'">
+    <DefineConstants>$(DefineConstants);SHORT_TIMEOUT</DefineConstants>
+  </PropertyGroup>
+
   <ItemGroup>
     <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="Selenium.WebDriver.ChromeDriver" Version="78.0.3904.7000" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1">
       <PrivateAssets>all</PrivateAssets>

BTCPayServer.Tests/BTCPayServerTester.cs

@@ -1,4 +1,4 @@
-using BTCPayServer.Configuration;
+using BTCPayServer.Configuration;
 using System.Linq;
 using BTCPayServer.HostedServices;
 using BTCPayServer.Hosting;
@@ -13,7 +13,6 @@ using BTCPayServer.Tests.Logging;
 using BTCPayServer.Tests.Mocks;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Http.Internal;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Controllers;
 using Microsoft.AspNetCore.Mvc.Routing;
@@ -33,12 +32,13 @@ using System.Security.Claims;
 using System.Security.Principal;
 using System.Text;
 using System.Threading;
-using AspNet.Security.OpenIdConnect.Primitives;
+using OpenIddict.Abstractions;
 using Xunit;
 using BTCPayServer.Services;
 using System.Net.Http;
 using Microsoft.AspNetCore.Hosting.Server.Features;
 using System.Threading.Tasks;
+using AuthenticationSchemes = BTCPayServer.Security.AuthenticationSchemes;
 
 namespace BTCPayServer.Tests
 {
@@ -93,7 +93,7 @@ namespace BTCPayServer.Tests
 
         public bool MockRates { get; set; } = true;
 
-        public void Start()
+        public async Task StartAsync()
         {
             if (!Directory.Exists(_Directory))
                 Directory.CreateDirectory(_Directory);
@@ -102,7 +102,6 @@ namespace BTCPayServer.Tests
             if (!Directory.Exists(chainDirectory))
                 Directory.CreateDirectory(chainDirectory);
 
-
             StringBuilder config = new StringBuilder();
             config.AppendLine($"{chain.ToLowerInvariant()}=1");
             if (InContainer)
@@ -118,6 +117,12 @@ namespace BTCPayServer.Tests
             config.AppendLine($"ltc.explorer.url={LTCNBXplorerUri.AbsoluteUri}");
             config.AppendLine($"ltc.explorer.cookiefile=0");
             config.AppendLine($"btc.lightning={IntegratedLightning.AbsoluteUri}");
+            config.AppendLine($"torrcfile={TestUtils.GetTestDataFullPath("Tor/torrc")}");
+            config.AppendLine($"debuglog=debug.log");
+
+            var localLndBackupFile = Path.Combine(_Directory, "walletunlock.json");
+            File.Copy(TestUtils.GetTestDataFullPath("LndSeedBackup/walletunlock.json"), localLndBackupFile, true);
+            config.AppendLine($"btc.external.lndseedbackup={localLndBackupFile}");
             if (!string.IsNullOrEmpty(SSHPassword) && string.IsNullOrEmpty(SSHKeyFile))
                 config.AppendLine($"sshpassword={SSHPassword}");
             if (!string.IsNullOrEmpty(SSHKeyFile))
@@ -130,7 +135,7 @@ namespace BTCPayServer.Tests
             else if (!String.IsNullOrEmpty(Postgres))
                 config.AppendLine($"postgres=" + Postgres);
             var confPath = Path.Combine(chainDirectory, "settings.config");
-            File.WriteAllText(confPath, config.ToString());
+            await File.WriteAllTextAsync(confPath, config.ToString());
 
             ServerUri = new Uri("http://" + HostName + ":" + Port + "/");
             HttpClient = new HttpClient();
@@ -140,6 +145,7 @@ namespace BTCPayServer.Tests
             _Host = new WebHostBuilder()
                     .UseConfiguration(conf)
                     .UseContentRoot(FindBTCPayServerDirectory())
+                    .UseWebRoot(Path.Combine(FindBTCPayServerDirectory(), "wwwroot"))
                     .ConfigureServices(s =>
                     {
                         s.AddLogging(l =>
@@ -154,7 +160,7 @@ namespace BTCPayServer.Tests
                     .UseKestrel()
                     .UseStartup<Startup>()
                     .Build();
-            _Host.StartWithTasksAsync().GetAwaiter().GetResult();
+            await _Host.StartWithTasksAsync();
 
             var urls = _Host.ServerFeatures.Get<IServerAddressesFeature>().Addresses;
             foreach (var url in urls)
@@ -227,14 +233,15 @@ namespace BTCPayServer.Tests
                 rateProvider.Providers.Add("bittrex", bittrex);
             }
 
-            
 
-            WaitSiteIsOperational().GetAwaiter().GetResult();
+            Logs.Tester.LogInformation("Waiting site is operational...");
+            await WaitSiteIsOperational();
+            Logs.Tester.LogInformation("Site is now operational");
         }
 
         private async Task WaitSiteIsOperational()
         {
-            using (var cts = new CancellationTokenSource(10_000))
+            using (var cts = new CancellationTokenSource(20_000))
             {
                 var synching = WaitIsFullySynched(cts.Token);
                 var accessingHomepage = WaitCanAccessHomepage(cts.Token);
@@ -264,7 +271,7 @@ namespace BTCPayServer.Tests
 
         private string FindBTCPayServerDirectory()
         {
-            var solutionDirectory = LanguageService.TryGetSolutionDirectoryInfo(Directory.GetCurrentDirectory());
+            var solutionDirectory = TestUtils.TryGetSolutionDirectoryInfo(Directory.GetCurrentDirectory());
             return Path.Combine(solutionDirectory.FullName, "BTCPayServer");
         }
 
@@ -291,7 +298,7 @@ namespace BTCPayServer.Tests
         public string SSHPassword { get; internal set; }
         public string SSHKeyFile { get; internal set; }
         public string SSHConnection { get; set; }
-        public T GetController<T>(string userId = null, string storeId = null, Claim[] additionalClaims = null) where T : Controller
+        public T GetController<T>(string userId = null, string storeId = null, bool isAdmin = false) where T : Controller
         {
             var context = new DefaultHttpContext();
             context.Request.Host = new HostString("127.0.0.1", Port);
@@ -300,10 +307,10 @@ namespace BTCPayServer.Tests
             if (userId != null)
             {
                 List<Claim> claims = new List<Claim>();
-                claims.Add(new Claim(OpenIdConnectConstants.Claims.Subject, userId));
-                if (additionalClaims != null)
-                    claims.AddRange(additionalClaims);
-                context.User = new ClaimsPrincipal(new ClaimsIdentity(claims.ToArray(), Policies.CookieAuthentication));
+                claims.Add(new Claim(OpenIddictConstants.Claims.Subject, userId));
+                if (isAdmin)
+                    claims.Add(new Claim(ClaimTypes.Role, Roles.ServerAdmin));
+                context.User = new ClaimsPrincipal(new ClaimsIdentity(claims.ToArray(), AuthenticationSchemes.Cookie));
             }
             if (storeId != null)
             {

BTCPayServer.Tests/ChangellyTests.cs

@@ -21,25 +21,26 @@ namespace BTCPayServer.Tests
 {
     public class ChangellyTests
     {
+        public const int TestTimeout = 60_000;
         public ChangellyTests(ITestOutputHelper helper)
         {
             Logs.Tester = new XUnitLog(helper) {Name = "Tests"};
             Logs.LogProvider = new XUnitLogProvider(helper);
         }
 
-        [Fact(Timeout = 60000)]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
         public async void CanSetChangellyPaymentMethod()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 var controller = tester.PayTester.GetController<StoresController>(user.UserId, user.StoreId);
 
 
-                var storeBlob = controller.StoreData.GetStoreBlob();
+                var storeBlob = controller.CurrentStore.GetStoreBlob();
                 Assert.Null(storeBlob.ChangellySettings);
 
                 var updateModel = new UpdateChangellySettingsViewModel()
@@ -54,7 +55,7 @@ namespace BTCPayServer.Tests
                     await controller.UpdateChangellySettings(user.StoreId, updateModel, "save")).ActionName);
 
                 var store = await tester.PayTester.StoreRepository.FindStore(user.StoreId);
-                storeBlob = controller.StoreData.GetStoreBlob();
+                storeBlob = controller.CurrentStore.GetStoreBlob();
                 Assert.NotNull(storeBlob.ChangellySettings);
                 Assert.NotNull(storeBlob.ChangellySettings);
                 Assert.IsType<ChangellySettings>(storeBlob.ChangellySettings);
@@ -68,13 +69,13 @@ namespace BTCPayServer.Tests
         }
 
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
-        public async void CanToggleChangellyPaymentMethod()
+        public async Task CanToggleChangellyPaymentMethod()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 var controller = tester.PayTester.GetController<StoresController>(user.UserId, user.StoreId);
@@ -106,13 +107,13 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
         public async void CannotUseChangellyApiWithoutChangellyPaymentMethodSet()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 var changellyController =
@@ -161,13 +162,13 @@ namespace BTCPayServer.Tests
             };
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
         public async void CanGetCurrencyListFromChangelly()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
 
@@ -194,13 +195,13 @@ namespace BTCPayServer.Tests
         }
 
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
         public async void CanCalculateToAmountForChangelly()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
 
@@ -224,7 +225,7 @@ namespace BTCPayServer.Tests
         }
 
         [Fact]
-        [Trait("Integration", "Integration")]
+        [Trait("Fast", "Fast")]
         public void CanComputeBaseAmount()
         {
             Assert.Equal(1, ChangellyCalculationHelper.ComputeBaseAmount(1, 1));
@@ -234,7 +235,7 @@ namespace BTCPayServer.Tests
         }
 
         [Fact]
-        [Trait("Integration", "Integration")]
+        [Trait("Fast", "Fast")]
         public void CanComputeCorrectAmount()
         {
             Assert.Equal(1, ChangellyCalculationHelper.ComputeCorrectAmount(0.5m, 1, 2));

BTCPayServer.Tests/CheckoutUITests.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Linq;
 using System.Net.Http;
+using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Lightning;
 using BTCPayServer.Tests.Logging;
@@ -17,79 +18,70 @@ namespace BTCPayServer.Tests
     [Trait("Selenium", "Selenium")]
     public class CheckoutUITests
     {
+        public const int TestTimeout = TestUtils.TestTimeout;
         public CheckoutUITests(ITestOutputHelper helper)
         {
-            Logs.Tester = new XUnitLog(helper) {Name = "Tests"};
+            Logs.Tester = new XUnitLog(helper) { Name = "Tests" };
             Logs.LogProvider = new XUnitLogProvider(helper);
         }
-       
-        
-        [Fact]
-        public void CanCreateInvoice()
-        {
-            using (var s = SeleniumTester.Create())
-            {
-                s.Start();
-                s.RegisterNewUser();
-                var store = s.CreateNewStore().storeName;
-                s.AddDerivationScheme();
 
-                s.CreateInvoice(store);
-
-                s.Driver.FindElement(By.ClassName("invoice-details-link")).Click();
-                s.Driver.AssertNoError();
-                s.Driver.Navigate().Back();
-                s.Driver.FindElement(By.ClassName("invoice-checkout-link")).Click();
-                Assert.NotEmpty(s.Driver.FindElements(By.Id("checkoutCtrl")));
-                s.Driver.Quit();
-            }
-        }
-        
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         public async Task CanHandleRefundEmailForm()
         {
 
             using (var s = SeleniumTester.Create())
             {
-                s.Start();
+                await s.StartAsync();
+                s.GoToRegister();
                 s.RegisterNewUser();
                 var store = s.CreateNewStore();
                 s.AddDerivationScheme("BTC");
+                s.GoToStore(store.storeId, StoreNavPages.Checkout);
+                s.Driver.FindElement(By.Id("RequiresRefundEmail")).Click();
+                s.Driver.FindElement(By.Name("command")).ForceClick();
 
-                var emailAlreadyThereInvoiceId =s.CreateInvoice(store.storeName, 100, "USD", "a@g.com");
+                var emailAlreadyThereInvoiceId = s.CreateInvoice(store.storeName, 100, "USD", "a@g.com");
                 s.GoToInvoiceCheckout(emailAlreadyThereInvoiceId);
                 s.Driver.AssertElementNotFound(By.Id("emailAddressFormInput"));
                 s.GoToHome();
                 var invoiceId = s.CreateInvoice(store.storeName);
-                s.GoToInvoiceCheckout(invoiceId);
+                s.Driver.FindElement(By.ClassName("invoice-details-link")).Click();
+                s.Driver.AssertNoError();
+                s.Driver.Navigate().Back();
+                s.Driver.FindElement(By.ClassName("invoice-checkout-link")).Click();
+                Assert.NotEmpty(s.Driver.FindElements(By.Id("checkoutCtrl")));
+
                 Assert.True(s.Driver.FindElement(By.Id("emailAddressFormInput")).Displayed);
                 s.Driver.FindElement(By.Id("emailAddressFormInput")).SendKeys("xxx");
                 s.Driver.FindElement(By.Id("emailAddressForm")).FindElement(By.CssSelector("button.action-button"))
                     .Click();
                 var formInput = s.Driver.FindElement(By.Id("emailAddressFormInput"));
-                
+
                 Assert.True(formInput.Displayed);
                 Assert.Contains("form-input-invalid", formInput.GetAttribute("class"));
                 formInput = s.Driver.FindElement(By.Id("emailAddressFormInput"));
                 formInput.SendKeys("@g.com");
-                
-                s.Driver.FindElement(By.Id("emailAddressForm")).FindElement(By.CssSelector("button.action-button"))
-                    .Click();
-                await Task.Delay(1000);
-                s.Driver.AssertElementNotFound(By.Id("emailAddressFormInput"));
-                
-                s.Driver.Navigate().Refresh();
+                var actionButton = s.Driver.FindElement(By.Id("emailAddressForm")).FindElement(By.CssSelector("button.action-button"));
+                actionButton.Click();
+                try // Sometimes the click only take the focus, without actually really clicking on it...
+                {
+                    actionButton.Click();
+                }
+                catch { }
 
+                s.Driver.AssertElementNotFound(By.Id("emailAddressFormInput"));                
+                s.Driver.Navigate().Refresh();
                 s.Driver.AssertElementNotFound(By.Id("emailAddressFormInput"));
             }
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         public async Task CanUseLanguageDropdown()
         {
             using (var s = SeleniumTester.Create())
             {
-                s.Start();
+                await s.StartAsync();
+                s.GoToRegister();
                 s.RegisterNewUser();
                 var store = s.CreateNewStore();
                 s.AddDerivationScheme("BTC");
@@ -113,12 +105,13 @@ namespace BTCPayServer.Tests
             }
         }
         
-        [Fact]
-        public void CanUsePaymentMethodDropdown()
+        [Fact(Timeout = TestTimeout)]
+        public async Task CanUsePaymentMethodDropdown()
         {
             using (var s = SeleniumTester.Create())
             {
-                s.Start();
+                await s.StartAsync();
+                s.GoToRegister();
                 s.RegisterNewUser();
                 var store = s.CreateNewStore();
                 s.AddDerivationScheme("BTC");
@@ -138,30 +131,31 @@ namespace BTCPayServer.Tests
                 Assert.Contains("BTC", currencyDropdownButton.Text);
                 currencyDropdownButton.Click();
                 
-                var elements = s.Driver.FindElement(By.ClassName("vex-content"))
-                    .FindElements(By.ClassName("vexmenuitem"));
+                var elements = s.Driver.FindElement(By.ClassName("vex-content")).FindElements(By.ClassName("vexmenuitem"));
                 Assert.Equal(3, elements.Count);
                 elements.Single(element => element.Text.Contains("LTC")).Click();
+                Thread.Sleep(1000);
                 currencyDropdownButton =  s.Driver.FindElement(By.ClassName("payment__currencies"));
                 Assert.Contains("LTC", currencyDropdownButton.Text);
-                
-                elements = s.Driver.FindElement(By.ClassName("vex-content"))
-                    .FindElements(By.ClassName("vexmenuitem"));
-                
+                currencyDropdownButton.Click();
+
+                elements = s.Driver.FindElement(By.ClassName("vex-content")).FindElements(By.ClassName("vexmenuitem"));
                 elements.Single(element => element.Text.Contains("Lightning")).Click();
-                
+                currencyDropdownButton = s.Driver.FindElement(By.ClassName("payment__currencies"));
+
                 Assert.Contains("Lightning", currencyDropdownButton.Text);
                 
                 s.Driver.Quit();
             }
         }
         
-        [Fact]
-        public void CanUseLightningSatsFeature()
+        [Fact(Timeout = TestTimeout)]
+        public async Task CanUseLightningSatsFeature()
         {
             using (var s = SeleniumTester.Create())
             {
-                s.Start();
+                await s.StartAsync();
+                s.GoToRegister();
                 s.RegisterNewUser();
                 var store = s.CreateNewStore();
                 s.AddInternalLightningNode("BTC");

BTCPayServer.Tests/CoinSwitchTests.cs

@@ -6,6 +6,7 @@ using Microsoft.AspNetCore.Mvc;
 using Xunit;
 using Xunit.Abstractions;
 using BTCPayServer.Data;
+using System.Threading.Tasks;
 
 namespace BTCPayServer.Tests
 {
@@ -19,17 +20,17 @@ namespace BTCPayServer.Tests
 
         [Fact]
         [Trait("Integration", "Integration")]
-        public async void CanSetCoinSwitchPaymentMethod()
+        public async Task CanSetCoinSwitchPaymentMethod()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 var controller = tester.PayTester.GetController<StoresController>(user.UserId, user.StoreId);
 
 
-                var storeBlob = controller.StoreData.GetStoreBlob();
+                var storeBlob = controller.CurrentStore.GetStoreBlob();
                 Assert.Null(storeBlob.CoinSwitchSettings);
 
                 var updateModel = new UpdateCoinSwitchSettingsViewModel()
@@ -41,7 +42,7 @@ namespace BTCPayServer.Tests
                     await controller.UpdateCoinSwitchSettings(user.StoreId, updateModel, "save")).ActionName);
 
                 var store = await tester.PayTester.StoreRepository.FindStore(user.StoreId);
-                storeBlob = controller.StoreData.GetStoreBlob();
+                storeBlob = controller.CurrentStore.GetStoreBlob();
                 Assert.NotNull(storeBlob.CoinSwitchSettings);
                 Assert.NotNull(storeBlob.CoinSwitchSettings);
                 Assert.IsType<CoinSwitchSettings>(storeBlob.CoinSwitchSettings);
@@ -53,11 +54,11 @@ namespace BTCPayServer.Tests
 
         [Fact]
         [Trait("Integration", "Integration")]
-        public async void CanToggleCoinSwitchPaymentMethod()
+        public async Task CanToggleCoinSwitchPaymentMethod()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 var controller = tester.PayTester.GetController<StoresController>(user.UserId, user.StoreId);

BTCPayServer.Tests/CrowdfundTests.cs

@@ -35,13 +35,13 @@ namespace BTCPayServer.Tests
             Logs.LogProvider = new XUnitLogProvider(helper);
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
-        public void CanCreateAndDeleteCrowdfundApp()
+        public async Task CanCreateAndDeleteCrowdfundApp()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 var user2 = tester.NewAccount();
@@ -75,13 +75,13 @@ namespace BTCPayServer.Tests
         
         
         
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
         public async Task CanContributeOnlyWhenAllowed()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
@@ -100,7 +100,7 @@ namespace BTCPayServer.Tests
                 crowdfundViewModel.Enabled = false;
                 crowdfundViewModel.EndDate = null;
                 
-                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel, "save").Result);
                 
                 var anonAppPubsController = tester.PayTester.GetController<AppsPublicController>();
                 var publicApps = user.GetController<AppsPublicController>();
@@ -126,7 +126,7 @@ namespace BTCPayServer.Tests
                 crowdfundViewModel.StartDate= DateTime.Today.AddDays(2);
                 crowdfundViewModel.Enabled = true;
                 
-                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel, "save").Result);
                 Assert.IsType<NotFoundObjectResult>(await anonAppPubsController.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
                 {
                     Amount = new decimal(0.01)
@@ -138,7 +138,7 @@ namespace BTCPayServer.Tests
                 crowdfundViewModel.EndDate= DateTime.Today.AddDays(-1);
                 crowdfundViewModel.Enabled = true;
                 
-                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel, "save").Result);
                 Assert.IsType<NotFoundObjectResult>(await anonAppPubsController.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
                 {
                     Amount = new decimal(0.01)
@@ -152,7 +152,7 @@ namespace BTCPayServer.Tests
                 crowdfundViewModel.TargetAmount = 1;
                 crowdfundViewModel.TargetCurrency = "BTC";
                 crowdfundViewModel.EnforceTargetAmount = true;
-                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel, "save").Result);
                 Assert.IsType<NotFoundObjectResult>(await anonAppPubsController.ContributeToCrowdfund(appId, new ContributeToCrowdfund()
                 {
                     Amount = new decimal(1.01)
@@ -167,13 +167,13 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
-        public void CanComputeCrowdfundModel()
+        public async Task CanComputeCrowdfundModel()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
@@ -195,7 +195,7 @@ namespace BTCPayServer.Tests
                 crowdfundViewModel.TargetCurrency = "BTC";
                 crowdfundViewModel.UseAllStoreInvoices = true;
                 crowdfundViewModel.EnforceTargetAmount = true;
-                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel, "save").Result);
                 
                 var anonAppPubsController = tester.PayTester.GetController<AppsPublicController>();
                 var publicApps = user.GetController<AppsPublicController>();
@@ -253,7 +253,7 @@ namespace BTCPayServer.Tests
                 Assert.Contains(AppService.GetAppInternalTag(appId), invoiceEntity.InternalTags);
 
                 crowdfundViewModel.UseAllStoreInvoices = false;
-                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel, "save").Result);
 
                 Logs.Tester.LogInformation("Because UseAllStoreInvoices is false, let's make sure the invoice is not tagged");
                 invoice = user.BitPay.CreateInvoice(new Invoice()
@@ -272,7 +272,7 @@ namespace BTCPayServer.Tests
                 Logs.Tester.LogInformation("After turning setting a softcap, let's check that only actual payments are counted");
                 crowdfundViewModel.EnforceTargetAmount = false;
                 crowdfundViewModel.UseAllStoreInvoices = true;
-                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel).Result);
+                Assert.IsType<RedirectToActionResult>(apps.UpdateCrowdfund(appId, crowdfundViewModel, "save").Result);
                 invoice = user.BitPay.CreateInvoice(new Invoice()
                 {
                     Buyer = new Buyer() { email = "test@fwf.com" },

BTCPayServer.Tests/CustomerHttpServer.cs

@@ -26,11 +26,10 @@ namespace BTCPayServer.Tests
             _Host = new WebHostBuilder()
                 .Configure(app =>
                 {
-                    app.Run(req =>
+                    app.Run(async req =>
                     {
-                        _Requests.Writer.WriteAsync(JsonConvert.DeserializeObject<JObject>(new StreamReader(req.Request.Body).ReadToEnd()), _Closed.Token);
+                        await _Requests.Writer.WriteAsync(JsonConvert.DeserializeObject<JObject>(await new StreamReader(req.Request.Body).ReadToEndAsync()), _Closed.Token);
                         req.Response.StatusCode = 200;
-                        return Task.CompletedTask;
                     });
                 })
                 .UseKestrel()

BTCPayServer.Tests/Dockerfile

@@ -5,10 +5,12 @@ ENV LC_ALL en_US.UTF-8
 ENV LANG en_US.UTF-8
 
 WORKDIR /source
+COPY nuget.config nuget.config
 COPY Build/Common.csproj Build/Common.csproj
 COPY BTCPayServer/BTCPayServer.csproj BTCPayServer/BTCPayServer.csproj
 COPY BTCPayServer.Common/BTCPayServer.Common.csproj BTCPayServer.Common/BTCPayServer.Common.csproj
 COPY BTCPayServer.Rating/BTCPayServer.Rating.csproj BTCPayServer.Rating/BTCPayServer.Rating.csproj
+COPY BTCPayServer.Data/BTCPayServer.Data.csproj BTCPayServer.Data/BTCPayServer.Data.csproj
 COPY BTCPayServer.Tests/BTCPayServer.Tests.csproj BTCPayServer.Tests/BTCPayServer.Tests.csproj
 RUN dotnet restore BTCPayServer.Tests/BTCPayServer.Tests.csproj
 
@@ -23,6 +25,6 @@ ENV SCREEN_HEIGHT 600 \
     SCREEN_WIDTH 1200
 
 COPY . .
-RUN cd BTCPayServer.Tests && dotnet build
+RUN cd BTCPayServer.Tests && dotnet build /p:CI_TESTS=true
 WORKDIR /source/BTCPayServer.Tests
 ENTRYPOINT ["./docker-entrypoint.sh"]

BTCPayServer.Tests/Extensions.cs

@@ -1,4 +1,6 @@
-using System.Text;
+using System;
+using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Tests.Logging;
 using Microsoft.AspNetCore.Mvc;
@@ -26,6 +28,11 @@ namespace BTCPayServer.Tests
             try
             {
                 Assert.NotEmpty(driver.FindElements(By.ClassName("navbar-brand")));
+                if (driver.PageSource.Contains("alert-danger"))
+                {
+                    foreach (var dangerAlert in driver.FindElements(By.ClassName("alert-danger")))
+                        Assert.False(dangerAlert.Displayed, "No alert should be displayed");
+                }
             }
             catch
             {
@@ -68,20 +75,26 @@ namespace BTCPayServer.Tests
             return Assert.IsType<T>(vr.Model);
         }
 
-        public static IWebElement AssertElementNotFound(this IWebDriver driver, By by)
+        public static void AssertElementNotFound(this IWebDriver driver, By by)
         {
-            try
-            {
-                var webElement = driver.FindElement(by);
-                Assert.False(webElement.Displayed);
-                return webElement;
-            }
-            catch (NoSuchElementException)
-            {
-                
-            }
+            DateTimeOffset now = DateTimeOffset.Now;
+            var wait = SeleniumTester.ImplicitWait;
 
-            return null;
+            while (DateTimeOffset.UtcNow - now < wait)
+            {
+                try
+                {
+                    var webElement = driver.FindElement(by);
+                    if (!webElement.Displayed)
+                        return;
+                }
+                catch (NoSuchElementException)
+                {
+                    return;
+                }
+                Thread.Sleep(50);
+            }
+            Assert.False(true, "Elements was found");
         }
     }
 }

BTCPayServer.Tests/Logging/Logs.cs

@@ -1,4 +1,4 @@
-using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
 using System.Text;

BTCPayServer.Tests/PSBTTests.cs

@@ -11,6 +11,7 @@ using NBitcoin;
 using NBitpayClient;
 using Xunit;
 using Xunit.Abstractions;
+using BTCPayServer.Models;
 
 namespace BTCPayServer.Tests
 {
@@ -27,7 +28,7 @@ namespace BTCPayServer.Tests
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
@@ -49,7 +50,7 @@ namespace BTCPayServer.Tests
                     Assert.Equal("paid", invoice.Status);
                 });
 
-                var walletController = tester.PayTester.GetController<WalletsController>(user.UserId);
+                var walletController = user.GetController<WalletsController>();
                 var walletId = new WalletId(user.StoreId, "BTC");
                 var sendDestination = new Key().PubKey.Hash.GetAddress(user.SupportedNetwork.NBitcoinNetwork).ToString();
                 var sendModel = new WalletSendModel()
@@ -68,10 +69,9 @@ namespace BTCPayServer.Tests
                 var vmLedger = await walletController.WalletSend(walletId, sendModel, command: "ledger").AssertViewModelAsync<WalletSendLedgerModel>();
                 PSBT.Parse(vmLedger.PSBT, user.SupportedNetwork.NBitcoinNetwork);
                 BitcoinAddress.Create(vmLedger.HintChange, user.SupportedNetwork.NBitcoinNetwork);
-                Assert.NotNull(vmLedger.SuccessPath);
                 Assert.NotNull(vmLedger.WebsocketPath);
 
-                var redirectedPSBT = (string)Assert.IsType<RedirectToActionResult>(await walletController.WalletSend(walletId, sendModel, command: "analyze-psbt")).RouteValues["psbt"];
+                string redirectedPSBT = AssertRedirectedPSBT(await walletController.WalletSend(walletId, sendModel, command: "analyze-psbt"));
                 var vmPSBT = await walletController.WalletPSBT(walletId, new WalletPSBTViewModel() { PSBT = redirectedPSBT }).AssertViewModelAsync<WalletPSBTViewModel>();
                 var unsignedPSBT = PSBT.Parse(vmPSBT.PSBT, user.SupportedNetwork.NBitcoinNetwork);
                 Assert.NotNull(vmPSBT.Decoded);
@@ -98,9 +98,9 @@ namespace BTCPayServer.Tests
                 var combineVM = await walletController.WalletPSBT(walletId, vmPSBT, "combine").AssertViewModelAsync<WalletPSBTCombineViewModel>();
                 Assert.Equal(vmPSBT.PSBT, combineVM.OtherPSBT);
                 combineVM.PSBT = signedPSBT.ToBase64();
-                vmPSBT = await walletController.WalletPSBTCombine(walletId, combineVM).AssertViewModelAsync<WalletPSBTViewModel>();
+                var psbt = AssertRedirectedPSBT(await walletController.WalletPSBTCombine(walletId, combineVM));
 
-                var signedPSBT2 = PSBT.Parse(vmPSBT.PSBT, user.SupportedNetwork.NBitcoinNetwork);
+                var signedPSBT2 = PSBT.Parse(psbt, user.SupportedNetwork.NBitcoinNetwork);
                 Assert.True(signedPSBT.TryFinalize(out _));
                 Assert.True(signedPSBT2.TryFinalize(out _));
                 Assert.Equal(signedPSBT, signedPSBT2);
@@ -108,19 +108,27 @@ namespace BTCPayServer.Tests
                 // Can use uploaded file?
                 combineVM.PSBT = null;
                 combineVM.UploadedPSBTFile = TestUtils.GetFormFile("signedPSBT", signedPSBT.ToBytes());
-                vmPSBT = await walletController.WalletPSBTCombine(walletId, combineVM).AssertViewModelAsync<WalletPSBTViewModel>();
-                signedPSBT2 = PSBT.Parse(vmPSBT.PSBT, user.SupportedNetwork.NBitcoinNetwork);
+                psbt = AssertRedirectedPSBT(await walletController.WalletPSBTCombine(walletId, combineVM));
+                signedPSBT2 = PSBT.Parse(psbt, user.SupportedNetwork.NBitcoinNetwork);
                 Assert.True(signedPSBT.TryFinalize(out _));
                 Assert.True(signedPSBT2.TryFinalize(out _));
                 Assert.Equal(signedPSBT, signedPSBT2);
 
                 var ready = (await walletController.WalletPSBTReady(walletId, signedPSBT.ToBase64())).AssertViewModel<WalletPSBTReadyViewModel>();
                 Assert.Equal(signedPSBT.ToBase64(), ready.PSBT);
-                redirect = Assert.IsType<RedirectToActionResult>(await walletController.WalletPSBTReady(walletId, ready, command: "analyze-psbt"));
-                Assert.Equal(signedPSBT.ToBase64(), (string)redirect.RouteValues["psbt"]);
+                psbt = AssertRedirectedPSBT(await walletController.WalletPSBTReady(walletId, ready, command: "analyze-psbt"));
+                Assert.Equal(signedPSBT.ToBase64(), psbt);
                 redirect = Assert.IsType<RedirectToActionResult>(await walletController.WalletPSBTReady(walletId, ready, command: "broadcast"));
                 Assert.Equal(nameof(walletController.WalletTransactions), redirect.ActionName);
             }
         }
+
+        private static string AssertRedirectedPSBT(IActionResult view)
+        {
+            var postRedirectView = Assert.IsType<ViewResult>(view);
+            var postRedirectViewModel = Assert.IsType<PostRedirectViewModel>(postRedirectView.Model);
+            var redirectedPSBT = postRedirectViewModel.Parameters.Single(p => p.Key == "psbt").Value;
+            return redirectedPSBT;
+        }
     }
 }

BTCPayServer.Tests/PaymentRequestTests.cs

@@ -37,11 +37,11 @@ namespace BTCPayServer.Tests
 
         [Fact]
         [Trait("Integration", "Integration")]
-        public void CanCreateViewUpdateAndDeletePaymentRequest()
+        public async Task CanCreateViewUpdateAndDeletePaymentRequest()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
@@ -98,7 +98,7 @@ namespace BTCPayServer.Tests
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
@@ -160,7 +160,7 @@ namespace BTCPayServer.Tests
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");

BTCPayServer.Tests/SeleniumTester.cs

@@ -40,9 +40,9 @@ namespace BTCPayServer.Tests
         }
 
       
-        public void Start()
+        public async Task StartAsync()
         {
-            Server.Start();
+            await Server.StartAsync();
             ChromeOptions options = new ChromeOptions();
             var isDebug = !Server.PayTester.InContainer;
         
@@ -65,20 +65,29 @@ namespace BTCPayServer.Tests
             Logs.Tester.LogInformation("Selenium: Using chrome driver");
             Logs.Tester.LogInformation("Selenium: Browsing to " + Server.PayTester.ServerUri);
             Logs.Tester.LogInformation($"Selenium: Resolution {Driver.Manage().Window.Size}");
-            Driver.Manage().Timeouts().ImplicitWait = TimeSpan.FromSeconds(10);
-            Driver.Navigate().GoToUrl(Server.PayTester.ServerUri);
+            Driver.Manage().Timeouts().ImplicitWait = ImplicitWait;
+            GoToRegister();
             Driver.AssertNoError();
         }
 
+        internal void AssertHappyMessage()
+        {
+            Assert.Single(Driver.FindElements(By.ClassName("alert-success")).Where(el => el.Displayed));
+        }
+
+        public static readonly TimeSpan ImplicitWait = TimeSpan.FromSeconds(10);
         public string Link(string relativeLink)
         {
             return Server.PayTester.ServerUri.AbsoluteUri.WithoutEndingSlash() + relativeLink.WithStartingSlash();
         }
 
+        public void GoToRegister()
+        {
+            Driver.Navigate().GoToUrl(this.Link("/Account/Register"));
+        }
         public string RegisterNewUser(bool isAdmin = false)
         {
             var usr = RandomUtils.GetUInt256().ToString().Substring(64 - 20) + "@a.com";
-            Driver.FindElement(By.Id("Register")).Click();
             Driver.FindElement(By.Id("Email")).SendKeys(usr);
             Driver.FindElement(By.Id("Password")).SendKeys("123456");
             Driver.FindElement(By.Id("ConfirmPassword")).SendKeys("123456");
@@ -106,8 +115,7 @@ namespace BTCPayServer.Tests
             Driver.FindElement(By.ClassName("store-derivation-scheme")).SendKeys(derivationScheme);
             Driver.FindElement(By.Id("Continue")).ForceClick();
             Driver.FindElement(By.Id("Confirm")).ForceClick();
-            Driver.FindElement(By.Id("Save")).ForceClick();
-            return;
+            AssertHappyMessage();
         }
         
         public void AddLightningNode(string cryptoCode, LightningConnectionType connectionType)
@@ -141,6 +149,7 @@ namespace BTCPayServer.Tests
             Assert.NotEmpty(links);
             foreach (var l in links)
             {
+                Logs.Tester.LogInformation($"Checking no error on {l}");
                 Driver.Navigate().GoToUrl(l);
                 Driver.AssertNoError();
             }

BTCPayServer.Tests/SeleniumTests.cs

@@ -8,44 +8,69 @@ using OpenQA.Selenium.Interactions;
 using System.Linq;
 using NBitcoin;
 using System.Threading.Tasks;
+using System.Text.RegularExpressions;
 
 namespace BTCPayServer.Tests
 {
     [Trait("Selenium", "Selenium")]
     public class ChromeTests
     {
+        public const int TestTimeout = TestUtils.TestTimeout;
         public ChromeTests(ITestOutputHelper helper)
         {
             Logs.Tester = new XUnitLog(helper) { Name = "Tests" };
             Logs.LogProvider = new XUnitLogProvider(helper);
         }
 
-        [Fact]
-        public void CanNavigateServerSettings()
+        [Fact(Timeout = TestTimeout)]
+        public async Task CanNavigateServerSettings()
         {
             using (var s = SeleniumTester.Create())
             {
-                s.Start();
+                await s.StartAsync();
                 s.RegisterNewUser(true);
                 s.Driver.FindElement(By.Id("ServerSettings")).Click();
                 s.Driver.AssertNoError();
                 s.ClickOnAllSideMenus();
+                s.Driver.FindElement(By.LinkText("Services")).Click();
+
+                Logs.Tester.LogInformation("Let's if we can access LND's seed");
+                Assert.Contains("server/services/lndseedbackup/BTC", s.Driver.PageSource);
+                s.Driver.Navigate().GoToUrl(s.Link("/server/services/lndseedbackup/BTC"));
+                s.Driver.FindElement(By.Id("details")).Click();
+                var seedEl = s.Driver.FindElement(By.Id("SeedTextArea"));
+                Assert.True(seedEl.Displayed);
+                Assert.Contains("about over million", seedEl.Text, StringComparison.OrdinalIgnoreCase);
+                var passEl = s.Driver.FindElement(By.Id("PasswordInput"));
+                Assert.True(passEl.Displayed);
+                Assert.Contains(passEl.Text, "hellorockstar", StringComparison.OrdinalIgnoreCase);
+                s.Driver.FindElement(By.Id("delete")).Click();
+                s.Driver.FindElement(By.Id("continue")).Click();
+                s.AssertHappyMessage();
+                seedEl = s.Driver.FindElement(By.Id("SeedTextArea"));
+                Assert.Contains("Seed removed", seedEl.Text, StringComparison.OrdinalIgnoreCase);
+
+                Logs.Tester.LogInformation("Let's check if we can access the logs");
+                s.Driver.FindElement(By.LinkText("Logs")).Click();
+                s.Driver.FindElement(By.PartialLinkText(".log")).Click();
+                Assert.Contains("Starting listening NBXplorer", s.Driver.PageSource);
                 s.Driver.Quit();
             }
         }
 
-        [Fact]
-        public void NewUserLogin()
+        [Fact(Timeout = TestTimeout)]
+        public async Task NewUserLogin()
         {
             using (var s = SeleniumTester.Create())
             {
-                s.Start();
+                await s.StartAsync();
                 //Register & Log Out
                 var email = s.RegisterNewUser();
                 s.Driver.FindElement(By.Id("Logout")).Click();
                 s.Driver.AssertNoError();
-                s.Driver.FindElement(By.Id("Login")).Click();
-                s.Driver.AssertNoError();
+                Assert.Contains("Account/Login", s.Driver.Url);
+                // Should show the Tor address
+                Assert.Contains("wsaxew3qa5ljfuenfebmaf3m5ykgatct3p6zjrqwoouj3foererde3id.onion", s.Driver.PageSource);
 
                 s.Driver.Navigate().GoToUrl(s.Link("/invoices"));
                 Assert.Contains("ReturnUrl=%2Finvoices", s.Driver.Url);
@@ -74,7 +99,6 @@ namespace BTCPayServer.Tests
                 s.Driver.AssertNoError();
 
                 //Log In With New Password
-                s.Driver.FindElement(By.Id("Login")).Click();
                 s.Driver.FindElement(By.Id("Email")).SendKeys(email);
                 s.Driver.FindElement(By.Id("Password")).SendKeys("abc???");
                 s.Driver.FindElement(By.Id("LoginButton")).Click();
@@ -89,18 +113,17 @@ namespace BTCPayServer.Tests
 
         static void LogIn(SeleniumTester s, string email)
         {
-            s.Driver.FindElement(By.Id("Login")).Click();
             s.Driver.FindElement(By.Id("Email")).SendKeys(email);
             s.Driver.FindElement(By.Id("Password")).SendKeys("123456");
             s.Driver.FindElement(By.Id("LoginButton")).Click();
             s.Driver.AssertNoError();
         }
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         public async Task CanUseSSHService()
         {
             using (var s = SeleniumTester.Create())
             {
-                s.Start();
+                await s.StartAsync();
                 var alice = s.RegisterNewUser(isAdmin: true);
                 s.Driver.Navigate().GoToUrl(s.Link("/server/services"));
                 Assert.Contains("server/services/ssh", s.Driver.PageSource);
@@ -132,12 +155,12 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact]
-        public void CanUseDynamicDns()
+        [Fact(Timeout = TestTimeout)]
+        public async Task CanUseDynamicDns()
         {
             using (var s = SeleniumTester.Create())
             {
-                s.Start();
+                await s.StartAsync();
                 var alice = s.RegisterNewUser(isAdmin: true);
                 s.Driver.Navigate().GoToUrl(s.Link("/server/services"));
                 Assert.Contains("Dynamic DNS", s.Driver.PageSource);
@@ -182,12 +205,12 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact]
-        public void CanCreateStores()
+        [Fact(Timeout = TestTimeout)]
+        public async Task CanCreateStores()
         {
             using (var s = SeleniumTester.Create())
             {
-                s.Start();
+                await s.StartAsync();
                 var alice = s.RegisterNewUser();
                 var store = s.CreateNewStore().storeName;
                 s.AddDerivationScheme();
@@ -197,6 +220,7 @@ namespace BTCPayServer.Tests
                 s.ClickOnAllSideMenus();
                 s.GoToInvoices();
                 s.CreateInvoice(store);
+                s.AssertHappyMessage();
                 s.Driver.FindElement(By.ClassName("invoice-details-link")).Click();
                 var invoiceUrl = s.Driver.Url;
 
@@ -206,7 +230,7 @@ namespace BTCPayServer.Tests
                 Assert.Contains("ReturnUrl", s.Driver.Url);
                 s.Driver.Navigate().GoToUrl(invoiceUrl);
                 Assert.Contains("ReturnUrl", s.Driver.Url);
-
+                s.GoToRegister();
                 // When logged we should not be able to access store and invoice details
                 var bob = s.RegisterNewUser();
                 s.Driver.Navigate().GoToUrl(storeUrl);
@@ -229,17 +253,85 @@ namespace BTCPayServer.Tests
                 Assert.Contains("ReturnUrl", s.Driver.Url);
                 s.Driver.Navigate().GoToUrl(invoiceUrl);
                 s.Driver.AssertNoError();
+
+                // Alice should be able to delete the store
+                s.Logout();
+                LogIn(s, alice);
+                s.Driver.FindElement(By.Id("Stores")).Click();
+                s.Driver.FindElement(By.LinkText("Remove")).Click();
+                s.Driver.FindElement(By.Id("continue")).Click();
+                s.Driver.FindElement(By.Id("Stores")).Click();
+                s.Driver.Navigate().GoToUrl(storeUrl);
+                Assert.Contains("ReturnUrl", s.Driver.Url);
             }
         }
 
-
-     
-        [Fact]
-        public void CanCreateAppPoS()
+        [Fact(Timeout = TestTimeout)]
+        public async Task CanUsePairing()
         {
             using (var s = SeleniumTester.Create())
             {
-                s.Start();
+                await s.StartAsync();
+                s.Driver.Navigate().GoToUrl(s.Link("/api-access-request"));
+                Assert.Contains("ReturnUrl", s.Driver.Url);
+                s.GoToRegister();
+                var alice = s.RegisterNewUser();
+                var store = s.CreateNewStore().storeName;
+                s.AddDerivationScheme();
+
+                s.Driver.FindElement(By.Id("Tokens")).Click();
+                s.Driver.FindElement(By.Id("CreateNewToken")).Click();
+                s.Driver.FindElement(By.Id("RequestPairing")).Click();
+                string pairingCode = AssertUrlHasPairingCode(s);
+
+                s.Driver.FindElement(By.Id("ApprovePairing")).Click();
+                s.AssertHappyMessage();
+                Assert.Contains(pairingCode, s.Driver.PageSource);
+
+                var client = new NBitpayClient.Bitpay(new Key(), s.Server.PayTester.ServerUri);
+                await client.AuthorizeClient(new NBitpayClient.PairingCode(pairingCode));
+                await client.CreateInvoiceAsync(new NBitpayClient.Invoice()
+                {
+                    Price = 0.000000012m,
+                    Currency = "USD",
+                    FullNotifications = true
+                }, NBitpayClient.Facade.Merchant);
+
+                client = new NBitpayClient.Bitpay(new Key(), s.Server.PayTester.ServerUri);
+
+                var code = await client.RequestClientAuthorizationAsync("hehe", NBitpayClient.Facade.Merchant);
+                s.Driver.Navigate().GoToUrl(code.CreateLink(s.Server.PayTester.ServerUri));
+                s.Driver.FindElement(By.Id("ApprovePairing")).Click();
+
+                await client.CreateInvoiceAsync(new NBitpayClient.Invoice()
+                {
+                    Price = 0.000000012m,
+                    Currency = "USD",
+                    FullNotifications = true
+                }, NBitpayClient.Facade.Merchant);
+
+                s.Driver.Navigate().GoToUrl(s.Link("/api-tokens"));
+                s.Driver.FindElement(By.Id("RequestPairing")).Click();
+                s.Driver.FindElement(By.Id("ApprovePairing")).Click();
+                AssertUrlHasPairingCode(s);
+            }
+        }
+
+        private static string AssertUrlHasPairingCode(SeleniumTester s)
+        {
+            var regex = Regex.Match(new Uri(s.Driver.Url, UriKind.Absolute).Query, "pairingCode=([^&]*)");
+            Assert.True(regex.Success, $"{s.Driver.Url} does not match expected regex");
+            var pairingCode = regex.Groups[1].Value;
+            return pairingCode;
+        }
+
+
+        [Fact(Timeout = TestTimeout)]
+        public async Task CanCreateAppPoS()
+        {
+            using (var s = SeleniumTester.Create())
+            {
+                await s.StartAsync();
                 s.RegisterNewUser();
                 var store = s.CreateNewStore();
 
@@ -258,12 +350,12 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact]
-        public void CanCreateAppCF()
+        [Fact(Timeout = TestTimeout)]
+        public async Task CanCreateAppCF()
         {
             using (var s = SeleniumTester.Create())
             {
-                s.Start();
+                await s.StartAsync();
                 s.RegisterNewUser();
                 var store = s.CreateNewStore();
                 s.AddDerivationScheme();
@@ -286,12 +378,12 @@ namespace BTCPayServer.Tests
             } 
         }
 
-        [Fact]
-        public void CanCreatePayRequest()
+        [Fact(Timeout = TestTimeout)]
+        public async Task CanCreatePayRequest()
         {
             using (var s = SeleniumTester.Create())
             {
-                s.Start();
+                await s.StartAsync();
                 s.RegisterNewUser();
                 s.CreateNewStore();
                 s.AddDerivationScheme();
@@ -309,13 +401,13 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact]
-        public void CanManageWallet()
+        [Fact(Timeout = TestTimeout)]
+        public async Task CanManageWallet()
         {
             using (var s = SeleniumTester.Create())
             {
-                s.Start();
-                s.RegisterNewUser();
+                await s.StartAsync();
+                s.RegisterNewUser(true);
                 s.CreateNewStore();
 
                 // In this test, we try to spend from a manual seed. We import the xpub 49'/0'/0', then try to use the seed 
@@ -331,6 +423,10 @@ namespace BTCPayServer.Tests
 
                 s.ClickOnAllSideMenus();
 
+                // Make sure we can rescan, because we are admin!
+                s.Driver.FindElement(By.Id("WalletRescan")).ForceClick();
+                Assert.Contains("The batch size make sure", s.Driver.PageSource);
+
                 // We setup the fingerprint and the account key path
                 s.Driver.FindElement(By.Id("WalletSettings")).ForceClick();
                 s.Driver.FindElement(By.Id("AccountKeys_0__MasterFingerprint")).SendKeys("8bafd160");

BTCPayServer.Tests/ServerTester.cs

@@ -82,9 +82,9 @@ namespace BTCPayServer.Tests
             get; set;
         }
 
-        public void Start()
+        public Task StartAsync()
         {
-            PayTester.Start();
+            return PayTester.StartAsync();
         }
 
         /// <summary>
@@ -166,12 +166,14 @@ namespace BTCPayServer.Tests
 
         public void Dispose()
         {
+            Logs.Tester.LogInformation("Disposing the BTCPayTester...");
             foreach (var store in Stores)
             {
                 Xunit.Assert.True(PayTester.StoreRepository.DeleteStore(store).GetAwaiter().GetResult());
             }
             if (PayTester != null)
                 PayTester.Dispose();
+            Logs.Tester.LogInformation("BTCPayTester disposed");
         }
     }
 }

BTCPayServer.Tests/StorageTests.cs

@@ -12,7 +12,6 @@ using BTCPayServer.Storage.ViewModels;
 using BTCPayServer.Tests.Logging;
 using DBriize.Utils;
 using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Http.Internal;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Configuration;
 using Microsoft.VisualStudio.TestPlatform.CommunicationUtilities.Resources;
@@ -29,13 +28,13 @@ namespace BTCPayServer.Tests
             Logs.LogProvider = new XUnitLogProvider(helper);
         }
 
-        [Fact]
+        [Fact(Timeout = TestUtils.TestTimeout)]
         [Trait("Integration", "Integration")]
-        public async void CanConfigureStorage()
+        public async Task CanConfigureStorage()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 var controller = tester.PayTester.GetController<ServerController>(user.UserId, user.StoreId);
@@ -118,7 +117,7 @@ namespace BTCPayServer.Tests
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 var controller = tester.PayTester.GetController<ServerController>(user.UserId, user.StoreId);
@@ -140,13 +139,13 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact]
+        [Fact(Timeout = TestUtils.TestTimeout)]
         [Trait("ExternalIntegration", "ExternalIntegration")]
         public async Task CanUseAzureBlobStorage()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 var controller = tester.PayTester.GetController<ServerController>(user.UserId, user.StoreId);
@@ -211,8 +210,8 @@ namespace BTCPayServer.Tests
                     TimeAmount = 1,
                     TimeType = ServerController.CreateTemporaryFileUrlViewModel.TmpFileTimeType.Minutes
                 }));
-            Assert.True(tmpLinkGenerate.RouteValues.ContainsKey("StatusMessage"));
-            var statusMessageModel = new StatusMessageModel(tmpLinkGenerate.RouteValues["StatusMessage"].ToString());
+            var statusMessageModel = controller.TempData.GetStatusMessageModel();
+            Assert.NotNull(statusMessageModel);
             Assert.Equal(StatusMessageModel.StatusSeverity.Success, statusMessageModel.Severity);
             var index = statusMessageModel.Html.IndexOf("target='_blank'>");
             var url = statusMessageModel.Html.Substring(index).ReplaceMultiple(new Dictionary<string, string>()
@@ -222,12 +221,14 @@ namespace BTCPayServer.Tests
             //verify tmpfile is available and the same
             data = await net.DownloadStringTaskAsync(new Uri(url));
             Assert.Equal(fileContent, data);
-            
-            
+
+
             //delete file
-            Assert.Equal(StatusMessageModel.StatusSeverity.Success, new StatusMessageModel(Assert
-                .IsType<RedirectToActionResult>(await controller.DeleteFile(fileId))
-                .RouteValues["statusMessage"].ToString()).Severity);
+            Assert.IsType<RedirectToActionResult>(await controller.DeleteFile(fileId));
+            controller.TempData.GetStatusMessageModel();
+            Assert.NotNull(statusMessageModel);
+
+            Assert.Equal(StatusMessageModel.StatusSeverity.Success, statusMessageModel.Severity);
             
             //attempt to fetch deleted file
             viewFilesViewModel =

BTCPayServer.Tests/TestAccount.cs

@@ -20,6 +20,7 @@ using BTCPayServer.Lightning.CLightning;
 using BTCPayServer.Data;
 using OpenIddict.Abstractions;
 using OpenIddict.Core;
+using Microsoft.AspNetCore.Identity;
 
 namespace BTCPayServer.Tests
 {
@@ -37,6 +38,13 @@ namespace BTCPayServer.Tests
             GrantAccessAsync().GetAwaiter().GetResult();
         }
 
+        public async Task MakeAdmin()
+        {
+            var userManager = parent.PayTester.GetService<UserManager<ApplicationUser>>();
+            var u = await userManager.FindByIdAsync(UserId);
+            await userManager.AddToRoleAsync(u, Roles.ServerAdmin);
+        }
+
         public void Register()
         {
             RegisterAsync().GetAwaiter().GetResult();
@@ -78,7 +86,8 @@ namespace BTCPayServer.Tests
 
         public T GetController<T>(bool setImplicitStore = true) where T : Controller
         {
-            return parent.PayTester.GetController<T>(UserId, setImplicitStore ? StoreId : null);
+            var controller = parent.PayTester.GetController<T>(UserId, setImplicitStore ? StoreId : null, IsAdmin);
+            return controller;
         }
 
         public async Task CreateStoreAsync()
@@ -140,6 +149,7 @@ namespace BTCPayServer.Tests
         {
             get; set;
         }
+        public bool IsAdmin { get; internal set; }
 
         public void RegisterLightningNode(string cryptoCode, LightningConnectionType connectionType)
         {
@@ -172,7 +182,7 @@ namespace BTCPayServer.Tests
         public async Task<BTCPayOpenIdClient> RegisterOpenIdClient(OpenIddictApplicationDescriptor descriptor, string secret = null)
         {
           var openIddictApplicationManager = parent.PayTester.GetService<OpenIddictApplicationManager<BTCPayOpenIdClient>>();
-          var client = new BTCPayOpenIdClient {ApplicationUserId = UserId};
+          var client = new BTCPayOpenIdClient { Id = Guid.NewGuid().ToString(), ApplicationUserId = UserId};
           await openIddictApplicationManager.PopulateAsync(client, descriptor);
           await openIddictApplicationManager.CreateAsync(client, secret);
           return client;

BTCPayServer.Tests/TestData/LndSeedBackup/walletunlock.json

@@ -0,0 +1 @@
+{"wallet_password":"hellorockstar", "cipher_seed_mnemonic":["about","over","million","coast","nature","gold","fabric","aware","adult","salute","sock","envelope","oblige","shed","basic","need","analyst","spot","worth","garbage","planet","genre","leave","cereal"]}

BTCPayServer.Tests/TestData/Tor/hidden_services/BTC-P2P/hostname

@@ -0,0 +1 @@
+rhrk7ncuqfcbkt7deaysn7st32hrf2tzztoumkj2vp3cqzy2d2arvdad.onion

BTCPayServer.Tests/TestData/Tor/hidden_services/BTC-RPC/hostname

@@ -0,0 +1 @@
+r32tqfpchpiptrfltyd4ku7q3ir4yidyfe4em63iz2g5wjcauyvyj4id.onion

BTCPayServer.Tests/TestData/Tor/hidden_services/BTCPayServer/hostname

@@ -0,0 +1 @@
+wsaxew3qa5ljfuenfebmaf3m5ykgatct3p6zjrqwoouj3foererde3id.onion

BTCPayServer.Tests/TestData/Tor/hidden_services/BTCTransmuter/hostname

@@ -0,0 +1 @@
+wzaq2ek6a5g6jyhr7giqsz2gbr6qdtcuwywcyvfplvrk7ugup3virvad.onion

BTCPayServer.Tests/TestData/Tor/hidden_services/BitcoinP2P/hostname

@@ -0,0 +1 @@
+jzebv74oaugje6aeykzcypzxs6pvt27wdmrcpe4pkjfprxgem2vyi7qd.onion

BTCPayServer.Tests/TestData/Tor/hidden_services/WooCommerce/hostname

@@ -0,0 +1 @@
+aeyn6mou5himgmog4tlnbjlgx5bwtwsqttd7sn7hay6lksvlfwmtkqyd.onion

BTCPayServer.Tests/TestData/Tor/hidden_services/c-lightning/hostname

@@ -0,0 +1 @@
+uewlcjmuuwcgs43lpcc7d64k2pf4xs7yyer7ztsq6cblyjxue3bc35qd.onion

BTCPayServer.Tests/TestData/Tor/hidden_services/clightning/hostname

@@ -0,0 +1 @@
+4iz3q7dp5xn5isqxsslrvbjrltqoqqocq25zmjgzvvxm5yp57jj4buid.onion

BTCPayServer.Tests/TestData/Tor/hidden_services/lnd/hostname

@@ -0,0 +1 @@
+ii3kqeayarsxr2jqkmr2l5np2f4vn6lznk55upd3udfbfskbjdzoq4yd.onion

BTCPayServer.Tests/TestData/Tor/torrc

@@ -0,0 +1,24 @@
+# For the hidden service BTC-P2P
+HiddenServiceDir hidden_services/BTC-P2P
+# Redirecting to btcpayserver_bitcoind
+HiddenServicePort 8333 172.19.0.2:39388
+# For the hidden service BTC-RPC
+HiddenServiceDir hidden_services/BTC-RPC
+# Redirecting to btcpayserver_bitcoind
+HiddenServicePort 8332 172.19.0.2:43782
+# For the hidden service BTCPayServer
+HiddenServiceDir hidden_services/BTCPayServer
+# Redirecting to nginx
+HiddenServicePort 80 172.19.0.13:80
+# For the hidden service BTCTransmuter
+HiddenServiceDir hidden_services/BTCTransmuter
+# Redirecting to nginx
+HiddenServicePort 80 172.19.0.13:80
+# For the hidden service WooCommerce
+HiddenServiceDir hidden_services/WooCommerce
+# Redirecting to generated_woocommerce_1
+HiddenServicePort 80 172.19.0.15:80
+# For the hidden service c-lightning
+HiddenServiceDir hidden_services/c-lightning
+# Redirecting to btcpayserver_clightning_bitcoin
+HiddenServicePort 9735 172.19.0.10:9735

BTCPayServer.Tests/TestUtils.cs

@@ -5,13 +5,43 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Http;
+#if NETCOREAPP21
 using Microsoft.AspNetCore.Http.Internal;
+#endif
 using Xunit.Sdk;
+using System.Linq;
 
 namespace BTCPayServer.Tests
 {
     public static class TestUtils
     {
+#if DEBUG && !SHORT_TIMEOUT
+        public const int TestTimeout = 600_000;
+#else
+        public const int TestTimeout = 60_000;
+#endif
+        public static DirectoryInfo TryGetSolutionDirectoryInfo(string currentPath = null)
+        {
+            var directory = new DirectoryInfo(
+                currentPath ?? Directory.GetCurrentDirectory());
+            while (directory != null && !directory.GetFiles("*.sln").Any())
+            {
+                directory = directory.Parent;
+            }
+            return directory;
+        }
+
+
+        public static string GetTestDataFullPath(string relativeFilePath)
+        {
+            var directory = new DirectoryInfo(Directory.GetCurrentDirectory());
+            while (directory != null && !directory.GetFiles("*.csproj").Any())
+            {
+                directory = directory.Parent;
+            }
+            return Path.Combine(directory.FullName, "TestData", relativeFilePath);
+        }
+
         public static FormFile GetFormFile(string filename, string content)
         {
             File.WriteAllText(filename, content);
@@ -44,7 +74,7 @@ namespace BTCPayServer.Tests
             formFile.ContentDisposition = $"form-data; name=\"file\"; filename=\"{fileInfo.Name}\"";
             return formFile;
         }
-        public static void Eventually(Action act, int ms = 200000)
+        public static void Eventually(Action act, int ms = 20_000)
         {
             CancellationTokenSource cts = new CancellationTokenSource(ms);
             while (true)

BTCPayServer.Tests/UnitTest1.cs

@@ -15,9 +15,7 @@ using System.IO;
 using Newtonsoft.Json.Linq;
 using BTCPayServer.Controllers;
 using Microsoft.AspNetCore.Mvc;
-using BTCPayServer.Authentication;
 using System.Diagnostics;
-using Microsoft.EntityFrameworkCore.Extensions;
 using BTCPayServer.Data;
 using Microsoft.EntityFrameworkCore;
 using BTCPayServer.Services.Rates;
@@ -57,16 +55,18 @@ using System.Security;
 using System.Runtime.CompilerServices;
 using System.Net;
 using BTCPayServer.Models.AccountViewModels;
-using BTCPayServer.Services.U2F.Models;
-using Microsoft.AspNetCore.Http.Internal;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.DependencyInjection;
 using NBXplorer.DerivationStrategy;
+using BTCPayServer.U2F.Models;
+using BTCPayServer.Security.Bitpay;
+using MemoryCache = Microsoft.Extensions.Caching.Memory.MemoryCache;
 
 namespace BTCPayServer.Tests
 {
     public class UnitTest1
     {
+        public const int TestTimeout = 60_000;
         public UnitTest1(ITestOutputHelper helper)
         {
             Logs.Tester = new XUnitLog(helper) { Name = "Tests" };
@@ -77,7 +77,7 @@ namespace BTCPayServer.Tests
         [Trait("Fast", "Fast")]
         public async Task CheckNoDeadLink()
         {
-            var views = Path.Combine(LanguageService.TryGetSolutionDirectoryInfo().FullName, "BTCPayServer", "Views");
+            var views = Path.Combine(TestUtils.TryGetSolutionDirectoryInfo().FullName, "BTCPayServer", "Views");
             var viewFiles = Directory.EnumerateFiles(views, "*.cshtml", SearchOption.AllDirectories).ToArray();
             Assert.NotEmpty(viewFiles);
             Regex regex = new Regex("href=\"(http.*?)[\"#]");
@@ -428,7 +428,7 @@ namespace BTCPayServer.Tests
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var response = await tester.PayTester.HttpClient.GetAsync("");
                 Assert.True(response.IsSuccessStatusCode);
             }
@@ -473,11 +473,11 @@ namespace BTCPayServer.Tests
 
         [Fact]
         [Trait("Integration", "Integration")]
-        public void CanAcceptInvoiceWithTolerance2()
+        public async Task CanAcceptInvoiceWithTolerance2()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
@@ -533,13 +533,29 @@ namespace BTCPayServer.Tests
             }
         }
 
+        [Fact]
+        [Trait("Fast", "Fast")]
+        public async Task CanEnumerateTorServices()
+        {
+            var tor = new TorServices(new BTCPayNetworkProvider(NetworkType.Regtest), new BTCPayServerOptions()
+            {
+                TorrcFile = TestUtils.GetTestDataFullPath("Tor/torrc")
+            });
+            await tor.Refresh();
+
+            Assert.Single(tor.Services.Where(t => t.ServiceType == TorServiceType.BTCPayServer));
+            Assert.Single(tor.Services.Where(t => t.ServiceType == TorServiceType.P2P));
+            Assert.Single(tor.Services.Where(t => t.ServiceType == TorServiceType.RPC));
+            Assert.True(tor.Services.Where(t => t.ServiceType == TorServiceType.Other).Count() > 1);
+        }
+
         [Fact(Timeout = 60 * 2 * 1000)]
         [Trait("Integration", "Integration")]
         public async Task CanSetLightningServer()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 await tester.EnsureChannelsSetup();
                 var user = tester.NewAccount();
                 user.GrantAccess();
@@ -552,7 +568,8 @@ namespace BTCPayServer.Tests
                     ConnectionString = "type=charge;server=" + tester.MerchantCharge.Client.Uri.AbsoluteUri,
                     SkipPortTest = true // We can't test this as the IP can't be resolved by the test host :(
                 }, "test", "BTC").GetAwaiter().GetResult();
-                Assert.DoesNotContain("Error", ((LightningNodeViewModel)Assert.IsType<ViewResult>(testResult).Model).StatusMessage, StringComparison.OrdinalIgnoreCase);
+                Assert.False(storeController.TempData.ContainsKey(WellKnownTempData.ErrorMessage));
+                storeController.TempData.Clear();
                 Assert.True(storeController.ModelState.IsValid);
 
                 Assert.IsType<RedirectToActionResult>(storeController.AddLightningNode(user.StoreId, new LightningNodeViewModel()
@@ -599,7 +616,7 @@ namespace BTCPayServer.Tests
 
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 await tester.EnsureChannelsSetup();
                 var user = tester.NewAccount();
                 user.GrantAccess();
@@ -636,23 +653,24 @@ namespace BTCPayServer.Tests
             });
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
-        public void CanUseServerInitiatedPairingCode()
+        public async Task CanUseServerInitiatedPairingCode()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var acc = tester.NewAccount();
                 acc.Register();
                 acc.CreateStore();
 
                 var controller = acc.GetController<StoresController>();
-                var token = (RedirectToActionResult)controller.CreateToken(new Models.StoreViewModels.CreateTokenViewModel()
+                var token = (RedirectToActionResult)await controller.CreateToken2(new Models.StoreViewModels.CreateTokenViewModel()
                 {
                     Label = "bla",
-                    PublicKey = null
-                }).GetAwaiter().GetResult();
+                    PublicKey = null,
+                    StoreId = acc.StoreId
+                });
 
                 var pairingCode = (string)token.RouteValues["pairingCode"];
 
@@ -661,7 +679,7 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
         public async Task CanSendIPN()
         {
@@ -669,7 +687,7 @@ namespace BTCPayServer.Tests
             {
                 using (var tester = ServerTester.Create())
                 {
-                    tester.Start();
+                    await tester.StartAsync();
                     var acc = tester.NewAccount();
                     acc.GrantAccess();
                     acc.RegisterDerivationScheme("BTC");
@@ -685,7 +703,7 @@ namespace BTCPayServer.Tests
                         FullNotifications = true,
                         ExtendedNotifications = true
                     });
-                    BitcoinUrlBuilder url = new BitcoinUrlBuilder(invoice.PaymentUrls.BIP21);
+                    BitcoinUrlBuilder url = new BitcoinUrlBuilder(invoice.PaymentUrls.BIP21, tester.NetworkProvider.BTC.NBitcoinNetwork);
                     bool receivedPayment = false;
                     bool paid = false;
                     bool confirmed = false;
@@ -729,13 +747,13 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
-        public void CantPairTwiceWithSamePubkey()
+        public async Task CantPairTwiceWithSamePubkey()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var acc = tester.NewAccount();
                 acc.Register();
                 acc.CreateStore();
@@ -746,12 +764,12 @@ namespace BTCPayServer.Tests
                 pairingCode = acc.BitPay.RequestClientAuthorization("test1", Facade.Merchant);
                 acc.CreateStore();
                 var store2 = acc.GetController<StoresController>();
-                store2.Pair(pairingCode.ToString(), store2.StoreData.Id).GetAwaiter().GetResult();
-                Assert.Contains(nameof(PairingResult.ReusedKey), store2.StatusMessage, StringComparison.CurrentCultureIgnoreCase);
+                await store2.Pair(pairingCode.ToString(), store2.CurrentStore.Id);
+                Assert.Contains(nameof(PairingResult.ReusedKey), (string)store2.TempData[WellKnownTempData.ErrorMessage], StringComparison.CurrentCultureIgnoreCase);
             }
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
         public void CanSolveTheDogesRatesOnKraken()
         {
@@ -768,20 +786,20 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
         public async Task CanRescanWallet()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var acc = tester.NewAccount();
                 acc.GrantAccess();
                 acc.RegisterDerivationScheme("BTC", true);
                 var btcDerivationScheme = acc.DerivationScheme;
                 acc.RegisterDerivationScheme("LTC", true);
 
-                var walletController = tester.PayTester.GetController<WalletsController>(acc.UserId);
+                var walletController = acc.GetController<WalletsController>();
                 WalletId walletId = new WalletId(acc.StoreId, "LTC");
                 var rescan = Assert.IsType<RescanWalletModel>(Assert.IsType<ViewResult>(walletController.WalletRescan(walletId).Result).Model);
                 Assert.False(rescan.Ok);
@@ -790,8 +808,9 @@ namespace BTCPayServer.Tests
                 Assert.False(rescan.IsServerAdmin);
 
                 walletId = new WalletId(acc.StoreId, "BTC");
-                var serverAdminClaim = new[] { new Claim(Policies.CanModifyServerSettings.Key, "true") };
-                walletController = tester.PayTester.GetController<WalletsController>(acc.UserId, additionalClaims: serverAdminClaim);
+                acc.IsAdmin = true;
+                walletController = acc.GetController<WalletsController>();
+                
                 rescan = Assert.IsType<RescanWalletModel>(Assert.IsType<ViewResult>(walletController.WalletRescan(walletId).Result).Model);
                 Assert.True(rescan.Ok);
                 Assert.True(rescan.IsFullySync);
@@ -861,13 +880,13 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
-        public void CanListInvoices()
+        public async Task CanListInvoices()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var acc = tester.NewAccount();
                 acc.GrantAccess();
                 acc.RegisterDerivationScheme("BTC");
@@ -911,43 +930,43 @@ namespace BTCPayServer.Tests
 
         [Fact]
         [Trait("Integration", "Integration")]
-        public void CanGetRates()
+        public async Task CanGetRates()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var acc = tester.NewAccount();
                 acc.GrantAccess();
                 acc.RegisterDerivationScheme("BTC");
                 acc.RegisterDerivationScheme("LTC");
 
                 var rateController = acc.GetController<RateController>();
-                var GetBaseCurrencyRatesResult = JObject.Parse(((JsonResult)rateController.GetBaseCurrencyRates("BTC", acc.StoreId, default)
+                var GetBaseCurrencyRatesResult = JObject.Parse(((JsonResult)rateController.GetBaseCurrencyRates("BTC", default)
                     .GetAwaiter().GetResult()).Value.ToJson()).ToObject<DataWrapper<Rate[]>>();
                 Assert.NotNull(GetBaseCurrencyRatesResult);
                 Assert.NotNull(GetBaseCurrencyRatesResult.Data);
                 Assert.Equal(2, GetBaseCurrencyRatesResult.Data.Length);
                 Assert.Single(GetBaseCurrencyRatesResult.Data.Where(o => o.Code == "LTC"));
 
-                var GetRatesResult = JObject.Parse(((JsonResult)rateController.GetRates(null, acc.StoreId, default)
+                var GetRatesResult = JObject.Parse(((JsonResult)rateController.GetRates(null, default)
                     .GetAwaiter().GetResult()).Value.ToJson()).ToObject<DataWrapper<Rate[]>>();
                 // We don't have any default currencies, so this should be failing
                 Assert.Null(GetRatesResult?.Data);
 
                 var store = acc.GetController<StoresController>();
-                var ratesVM = (RatesViewModel)(Assert.IsType<ViewResult>(store.Rates(acc.StoreId)).Model);
+                var ratesVM = (RatesViewModel)(Assert.IsType<ViewResult>(store.Rates()).Model);
                 ratesVM.DefaultCurrencyPairs = "BTC_USD,LTC_USD";
                 store.Rates(ratesVM).Wait();
                 store = acc.GetController<StoresController>();
                 rateController = acc.GetController<RateController>();
-                GetRatesResult = JObject.Parse(((JsonResult)rateController.GetRates(null, acc.StoreId, default)
+                GetRatesResult = JObject.Parse(((JsonResult)rateController.GetRates(null, default)
                     .GetAwaiter().GetResult()).Value.ToJson()).ToObject<DataWrapper<Rate[]>>();
                 // Now we should have a result
                 Assert.NotNull(GetRatesResult);
                 Assert.NotNull(GetRatesResult.Data);
                 Assert.Equal(2, GetRatesResult.Data.Length);
 
-                var GetCurrencyPairRateResult = JObject.Parse(((JsonResult)rateController.GetCurrencyPairRate("BTC", "LTC", acc.StoreId, default)
+                var GetCurrencyPairRateResult = JObject.Parse(((JsonResult)rateController.GetCurrencyPairRate("BTC", "LTC", default)
                     .GetAwaiter().GetResult()).Value.ToJson()).ToObject<DataWrapper<Rate>>();
 
                 Assert.NotNull(GetCurrencyPairRateResult);
@@ -958,7 +977,9 @@ namespace BTCPayServer.Tests
                 var rates = acc.BitPay.GetRates();
                 HttpClient client = new HttpClient();
                 // Unauthentified requests should also be ok
-                var response = client.GetAsync($"http://127.0.0.1:{tester.PayTester.Port}/api/rates?storeId={acc.StoreId}").GetAwaiter().GetResult();
+                var response = await client.GetAsync($"http://127.0.0.1:{tester.PayTester.Port}/api/rates?storeId={acc.StoreId}");
+                response.EnsureSuccessStatusCode();
+                response = await client.GetAsync($"http://127.0.0.1:{tester.PayTester.Port}/rates?storeId={acc.StoreId}");
                 response.EnsureSuccessStatusCode();
             }
         }
@@ -969,13 +990,13 @@ namespace BTCPayServer.Tests
             Assert.Equal(expected, result.Invoices.Any(i => i.InvoiceId == invoiceId));
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
-        public void CanRBFPayment()
+        public async Task CanRBFPayment()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
@@ -1039,7 +1060,7 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Fast", "Fast")]
         public void CanParseFilter()
         {
@@ -1067,7 +1088,7 @@ namespace BTCPayServer.Tests
             Assert.Equal("hekki", search.TextSearch);
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Fast", "Fast")]
         public void CanParseFingerprint()
         {
@@ -1084,13 +1105,13 @@ namespace BTCPayServer.Tests
             Assert.Equal(f1.ToString(), f2.ToString());
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
         public async void CheckCORSSetOnBitpayAPI()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 foreach (var req in new[]
                 {
                     "invoices/",
@@ -1122,13 +1143,13 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
-        public void TestAccessBitpayAPI()
+        public async Task TestAccessBitpayAPI()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 Assert.False(user.BitPay.TestAccess(Facade.Merchant));
                 user.GrantAccess();
@@ -1138,7 +1159,7 @@ namespace BTCPayServer.Tests
 
                 // Test request pairing code client side
                 var storeController = user.GetController<StoresController>();
-                storeController.CreateToken(new CreateTokenViewModel()
+                storeController.CreateToken(user.StoreId, new CreateTokenViewModel()
                 {
                     Label = "test2",
                     StoreId = user.StoreId
@@ -1199,14 +1220,14 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
-        public void CanUseExchangeSpecificRate()
+        public async Task CanUseExchangeSpecificRate()
         {
             using (var tester = ServerTester.Create())
             {
                 tester.PayTester.MockRates = false;
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
@@ -1227,7 +1248,7 @@ namespace BTCPayServer.Tests
         private static decimal CreateInvoice(ServerTester tester, TestAccount user, string exchange, string currency = "USD")
         {
             var storeController = user.GetController<StoresController>();
-            var vm = (RatesViewModel)((ViewResult)storeController.Rates(user.StoreId)).Model;
+            var vm = (RatesViewModel)((ViewResult)storeController.Rates()).Model;
             vm.PreferredExchange = exchange;
             storeController.Rates(vm).Wait();
             var invoice2 = user.BitPay.CreateInvoice(new Invoice()
@@ -1242,23 +1263,23 @@ namespace BTCPayServer.Tests
             return invoice2.CryptoInfo[0].Rate;
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
         public async Task CanUseAnyoneCanCreateInvoice()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
 
-                Logs.Tester.LogInformation("StoreId without anyone can create invoice = 401");
+                Logs.Tester.LogInformation("StoreId without anyone can create invoice = 403");
                 var response = await tester.PayTester.HttpClient.SendAsync(new HttpRequestMessage(HttpMethod.Post, $"invoices?storeId={user.StoreId}")
                 {
                     Content = new StringContent("{\"Price\": 5000, \"currency\": \"USD\"}", Encoding.UTF8, "application/json"),
                 });
-                Assert.Equal(401, (int)response.StatusCode);
+                Assert.Equal(403, (int)response.StatusCode);
 
                 Logs.Tester.LogInformation("No store without  anyone can create invoice = 404 because the bitpay API can't know the storeid");
                 response = await tester.PayTester.HttpClient.SendAsync(new HttpRequestMessage(HttpMethod.Post, $"invoices")
@@ -1269,12 +1290,12 @@ namespace BTCPayServer.Tests
 
                 user.ModifyStore(s => s.AnyoneCanCreateInvoice = true);
 
-                Logs.Tester.LogInformation("Bad store with anyone can create invoice = 401");
+                Logs.Tester.LogInformation("Bad store with anyone can create invoice = 403");
                 response = await tester.PayTester.HttpClient.SendAsync(new HttpRequestMessage(HttpMethod.Post, $"invoices?storeId=badid")
                 {
                     Content = new StringContent("{\"Price\": 5000, \"currency\": \"USD\"}", Encoding.UTF8, "application/json"),
                 });
-                Assert.Equal(401, (int)response.StatusCode);
+                Assert.Equal(403, (int)response.StatusCode);
 
                 Logs.Tester.LogInformation("Good store with anyone can create invoice = 200");
                 response = await tester.PayTester.HttpClient.SendAsync(new HttpRequestMessage(HttpMethod.Post, $"invoices?storeId={user.StoreId}")
@@ -1285,13 +1306,13 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
-        public void CanTweakRate()
+        public async Task CanTweakRate()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
@@ -1308,7 +1329,7 @@ namespace BTCPayServer.Tests
                 Assert.Equal(Money.Coins(1.0m), invoice1.BtcPrice);
 
                 var storeController = user.GetController<StoresController>();
-                var vm = (RatesViewModel)((ViewResult)storeController.Rates(user.StoreId)).Model;
+                var vm = (RatesViewModel)((ViewResult)storeController.Rates()).Model;
                 Assert.Equal(0.0, vm.Spread);
                 vm.Spread = 40;
                 storeController.Rates(vm).Wait();
@@ -1330,13 +1351,13 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
-        public void CanHaveLTCOnlyStore()
+        public async Task CanHaveLTCOnlyStore()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("LTC");
@@ -1395,19 +1416,19 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
-        public void CanModifyRates()
+        public async Task CanModifyRates()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
 
                 var store = user.GetController<StoresController>();
-                var rateVm = Assert.IsType<RatesViewModel>(Assert.IsType<ViewResult>(store.Rates(user.StoreId)).Model);
+                var rateVm = Assert.IsType<RatesViewModel>(Assert.IsType<ViewResult>(store.Rates()).Model);
                 Assert.False(rateVm.ShowScripting);
                 Assert.Equal("coinaverage", rateVm.PreferredExchange);
                 Assert.Equal(0.0, rateVm.Spread);
@@ -1415,7 +1436,7 @@ namespace BTCPayServer.Tests
 
                 rateVm.PreferredExchange = "bitflyer";
                 Assert.IsType<RedirectToActionResult>(store.Rates(rateVm, "Save").Result);
-                rateVm = Assert.IsType<RatesViewModel>(Assert.IsType<ViewResult>(store.Rates(user.StoreId)).Model);
+                rateVm = Assert.IsType<RatesViewModel>(Assert.IsType<ViewResult>(store.Rates()).Model);
                 Assert.Equal("bitflyer", rateVm.PreferredExchange);
 
                 rateVm.ScriptTest = "BTC_JPY,BTC_CAD";
@@ -1432,7 +1453,7 @@ namespace BTCPayServer.Tests
                 Assert.IsType<RedirectToActionResult>(store.ShowRateRulesPost(true).Result);
                 Assert.IsType<RedirectToActionResult>(store.Rates(rateVm, "Save").Result);
                 store = user.GetController<StoresController>();
-                rateVm = Assert.IsType<RatesViewModel>(Assert.IsType<ViewResult>(store.Rates(user.StoreId)).Model);
+                rateVm = Assert.IsType<RatesViewModel>(Assert.IsType<ViewResult>(store.Rates()).Model);
                 Assert.Equal(rateVm.StoreId, user.StoreId);
                 Assert.Equal(rateVm.DefaultScript, rateVm.Script);
                 Assert.True(rateVm.ShowScripting);
@@ -1450,20 +1471,20 @@ namespace BTCPayServer.Tests
                 Assert.True(rateVm.TestRateRules.All(t => !t.Error));
                 Assert.IsType<RedirectToActionResult>(store.Rates(rateVm, "Save").Result);
                 store = user.GetController<StoresController>();
-                rateVm = Assert.IsType<RatesViewModel>(Assert.IsType<ViewResult>(store.Rates(user.StoreId)).Model);
+                rateVm = Assert.IsType<RatesViewModel>(Assert.IsType<ViewResult>(store.Rates()).Model);
                 Assert.Equal(50, rateVm.Spread);
                 Assert.True(rateVm.ShowScripting);
                 Assert.Contains("DOGE_X", rateVm.Script, StringComparison.OrdinalIgnoreCase);
             }
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
-        public void CanPayWithTwoCurrencies()
+        public async Task CanPayWithTwoCurrencies()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
@@ -1676,11 +1697,11 @@ namespace BTCPayServer.Tests
 
         [Fact]
         [Trait("Integration", "Integration")]
-        public void CanAddDerivationSchemes()
+        public async Task CanAddDerivationSchemes()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
@@ -1820,7 +1841,7 @@ namespace BTCPayServer.Tests
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 await tester.EnsureChannelsSetup();
                 var user = tester.NewAccount();
                 user.GrantAccess();
@@ -1865,7 +1886,7 @@ namespace BTCPayServer.Tests
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
@@ -2000,7 +2021,7 @@ noninventoryitem:
                 //verify invoices where created
                 invoices = user.BitPay.GetInvoices();
                 Assert.Equal(2, invoices.Count(invoice => invoice.ItemCode.Equals("noninventoryitem")));
-                var inventoryItemInvoice = invoices.SingleOrDefault(invoice => invoice.ItemCode.Equals("inventoryitem"));
+                var inventoryItemInvoice = Assert.Single(invoices.Where(invoice => invoice.ItemCode.Equals("inventoryitem")));
                 Assert.NotNull(inventoryItemInvoice);
                 
                 //let's mark the inventoryitem invoice as invalid, thsi should return the item to back in stock
@@ -2092,7 +2113,7 @@ noninventoryitem:
             Assert.True(client.WaitAllRunning(default).Wait(100));
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Fast", "Fast")]
         public void PosDataParser_ParsesCorrectly()
         {
@@ -2115,13 +2136,13 @@ noninventoryitem:
             });
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
         public async Task PosDataParser_ParsesCorrectly_Slower()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
@@ -2161,9 +2182,9 @@ noninventoryitem:
             }
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
-        public void CanExportInvoicesJson()
+        public async Task CanExportInvoicesJson()
         {
             decimal GetFieldValue(string input, string fieldName)
             {
@@ -2173,7 +2194,7 @@ noninventoryitem:
             }
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
@@ -2236,13 +2257,13 @@ noninventoryitem:
                 });
             }
         }
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
-        public void CanChangeNetworkFeeMode()
+        public async Task CanChangeNetworkFeeMode()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
@@ -2317,13 +2338,13 @@ noninventoryitem:
             }
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
-        public void CanExportInvoicesCsv()
+        public async Task CanExportInvoicesCsv()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
@@ -2357,13 +2378,13 @@ noninventoryitem:
 
 
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
-        public void CanCreateAndDeleteApps()
+        public async Task CanCreateAndDeleteApps()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 var user2 = tester.NewAccount();
@@ -2394,13 +2415,13 @@ noninventoryitem:
             }
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
-        public void CanCreateStrangeInvoice()
+        public async Task CanCreateStrangeInvoice()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
@@ -2455,13 +2476,13 @@ noninventoryitem:
             }
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
-        public void InvoiceFlowThroughDifferentStatesCorrectly()
+        public async Task InvoiceFlowThroughDifferentStatesCorrectly()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
@@ -2622,22 +2643,7 @@ noninventoryitem:
             }
         }
 
-        //[Fact]
-        //[Trait("Integration", "Integration")]
-        // 29 january, the exchange is down
-        //public void CheckQuadrigacxRateProvider()
-        //{
-        //    var quadri = new QuadrigacxRateProvider();
-        //    var rates = quadri.GetRatesAsync().GetAwaiter().GetResult();
-        //    Assert.NotEmpty(rates);
-        //    Assert.NotEqual(0.0m, rates.First().BidAsk.Bid);
-        //    Assert.NotEqual(0.0m, rates.GetRate(QuadrigacxRateProvider.QuadrigacxName, CurrencyPair.Parse("BTC_CAD")).Bid);
-        //    Assert.NotEqual(0.0m, rates.GetRate(QuadrigacxRateProvider.QuadrigacxName, CurrencyPair.Parse("BTC_USD")).Bid);
-        //    Assert.NotEqual(0.0m, rates.GetRate(QuadrigacxRateProvider.QuadrigacxName, CurrencyPair.Parse("LTC_CAD")).Bid);
-        //    Assert.Null(rates.GetRate(QuadrigacxRateProvider.QuadrigacxName, CurrencyPair.Parse("LTC_USD")));
-        //}
-
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
         public void CanQueryDirectProviders()
         {
@@ -2679,7 +2685,7 @@ noninventoryitem:
             factory.Providers["kraken"].GetRatesAsync(default).GetAwaiter().GetResult();
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
         public void CanGetRateCryptoCurrenciesByDefault()
         {
@@ -2734,13 +2740,13 @@ noninventoryitem:
             }
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
         public async Task CheckLogsRoute()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
@@ -2807,7 +2813,7 @@ noninventoryitem:
             return name;
         }
 
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Fast", "Fast")]
         public void CheckRatesProvider()
         {
@@ -2893,50 +2899,14 @@ noninventoryitem:
             Assert.True(DerivationSchemeSettings.TryParseFromColdcard("{\"keystore\": {\"ckcc_xpub\": \"tpubD6NzVbkrYhZ4YHNiuTdTmHRmbcPRLfqgyneZFCL1mkzkUBjXriQShxTh9HL34FK2mhieasJVk9EzJrUfkFqRNQBjiXgx3n5BhPkxKBoFmaS\", \"xpub\": \"vpub5YjYxTemJ39tFRnuAhwduyxG2tKGjoEpmvqVQRPqdYrqa6YGoeSzBtHXaJUYB19zDbXs3JjbEcVWERjQBPf9bEfUUMZNMv1QnMyHV8JPqyf\", \"label\": \"Coldcard Import 0x60d1af8b\", \"ckcc_xfp\": 1624354699, \"type\": \"hardware\", \"hw_type\": \"coldcard\", \"derivation\": \"m/84'/1'/0'\"}, \"wallet_type\": \"standard\", \"use_encryption\": false, \"seed_version\": 17}", testnet, out settings));
             Assert.True(settings.AccountDerivation is DirectDerivationStrategy s3 && s3.Segwit);
         }
-
-        [Fact]
-        [Trait("Fast", "Fast")]
-        public void CheckParseStatusMessageModel()
-        {
-            var legacyStatus = "Error: some bad shit happened";
-            var parsed = new StatusMessageModel(legacyStatus);
-            Assert.Equal(legacyStatus, parsed.Message);
-            Assert.Equal(StatusMessageModel.StatusSeverity.Error, parsed.Severity);
-
-            var legacyStatus2 = "Some normal shit happened";
-            parsed = new StatusMessageModel(legacyStatus2);
-            Assert.Equal(legacyStatus2, parsed.Message);
-            Assert.Equal(StatusMessageModel.StatusSeverity.Success, parsed.Severity);
-
-            var newStatus = new StatusMessageModel()
-            {
-                Html = "<a href='xxx'>something new</a>",
-                Severity = StatusMessageModel.StatusSeverity.Info
-            };
-            parsed = new StatusMessageModel(newStatus.ToString());
-            Assert.Null(parsed.Message);
-            Assert.Equal(newStatus.Html, parsed.Html);
-            Assert.Equal(StatusMessageModel.StatusSeverity.Info, parsed.Severity);
-
-            var newStatus2 = new StatusMessageModel()
-            {
-                Message = "something new",
-                Severity = StatusMessageModel.StatusSeverity.Success
-            };
-            parsed = new StatusMessageModel(newStatus2.ToString());
-            Assert.Null(parsed.Html);
-            Assert.Equal(newStatus2.Message, parsed.Message);
-            Assert.Equal(StatusMessageModel.StatusSeverity.Success, parsed.Severity);
-
-        }
         
-        [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
        public  async Task CanCreateInvoiceWithSpecificPaymentMethods()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 await tester.EnsureChannelsSetup();
                 var user = tester.NewAccount();
                 user.GrantAccess();
@@ -2965,13 +2935,13 @@ noninventoryitem:
         
 
         
-         [Fact]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
         public async Task CanLoginWithNoSecondaryAuthSystemsOrRequestItWhenAdded()
         {
             using (var tester = ServerTester.Create())
             {
-                tester.Start();
+                await tester.StartAsync();
                 var user = tester.NewAccount();
                 user.GrantAccess();
 
@@ -2991,13 +2961,11 @@ noninventoryitem:
                var addRequest = Assert.IsType<AddU2FDeviceViewModel>(Assert.IsType<ViewResult>(manageController.AddU2FDevice("label")).Model);
                //name should match the one provided in beginning
                Assert.Equal("label",addRequest.Name);
-               
-               //sending an invalid response model back to server, should error out
-               var statusMessage = Assert
-                   .IsType<RedirectToActionResult>(await manageController.AddU2FDevice(addRequest))
-                   .RouteValues["StatusMessage"].ToString();
-               Assert.NotNull(statusMessage);
-               Assert.Equal(StatusMessageModel.StatusSeverity.Error, new StatusMessageModel(statusMessage).Severity);
+
+                //sending an invalid response model back to server, should error out
+                Assert.IsType<RedirectToActionResult>(await manageController.AddU2FDevice(addRequest));
+                var statusModel = manageController.TempData.GetStatusMessageModel();
+               Assert.Equal(StatusMessageModel.StatusSeverity.Error, statusModel.Severity);
 
                var contextFactory = tester.PayTester.GetService<ApplicationDbContextFactory>();
 
@@ -3006,6 +2974,7 @@ noninventoryitem:
                {
                    var newDevice = new U2FDevice()
                    {
+                       Id = Guid.NewGuid().ToString(),
                        Name = "fake",
                        Counter = 0,
                        KeyHandle = UTF8Encoding.UTF8.GetBytes("fake"),
@@ -3039,7 +3008,8 @@ noninventoryitem:
         private static bool IsMapped(Invoice invoice, ApplicationDbContext ctx)
         {
             var h = BitcoinAddress.Create(invoice.BitcoinAddress, Network.RegTest).ScriptPubKey.Hash.ToString();
-            return ctx.AddressInvoices.FirstOrDefault(i => i.InvoiceDataId == invoice.Id && i.GetAddress() == h) != null;
+            return (ctx.AddressInvoices.Where(i => i.InvoiceDataId == invoice.Id).ToArrayAsync().GetAwaiter().GetResult())
+                .Where(i => i.GetAddress() == h).Any();
         }
     }
 }

BTCPayServer.Tests/UtilitiesTests.cs

@@ -31,7 +31,7 @@ namespace BTCPayServer.Tests
             var json = await client.GetTransifexAsync("https://api.transifex.com/organizations/btcpayserver/projects/btcpayserver/resources/enjson/");
             var langs = new[] { "en" }.Concat(((JObject)json["stats"]).Properties().Select(n => n.Name)).ToArray();
 
-            var langsDir = Path.Combine(Services.LanguageService.TryGetSolutionDirectoryInfo().FullName, "BTCPayServer", "wwwroot", "locales");
+            var langsDir = Path.Combine(TestUtils.TryGetSolutionDirectoryInfo().FullName, "BTCPayServer", "wwwroot", "locales");
 
             JObject sourceLang = null;
             Task.WaitAll(langs.Select(async l =>

BTCPayServer.Tests/docker-compose.monero.yml

@@ -0,0 +1,28 @@
+version: "3"
+
+services:
+
+    monerod:
+        image: kukks/docker-monero:test
+        restart: unless-stopped
+        container_name: xmr_monerod
+        entrypoint: monerod --fixed-difficulty 100 --rpc-bind-ip=0.0.0.0 --confirm-external-bind --rpc-bind-port=18081 --non-interactive --block-notify="/scripts/notifier.sh https://127.0.0.1:14142/monerolikedaemoncallback/block?cryptoCode=xmr&hash=%s" --testnet --no-igd --hide-my-port --no-sync --offline
+        volumes:
+            - "monero_data:/home/monero/.bitmonero"
+        ports:
+            - "18081:18081"
+    monero_wallet:
+        image: kukks/docker-monero:test
+        restart: unless-stopped
+        container_name: xmr_wallet_rpc
+        entrypoint: monero-wallet-rpc --testnet --rpc-bind-ip=0.0.0.0 --disable-rpc-login --confirm-external-bind --rpc-bind-port=18082 --non-interactive --trusted-daemon  --daemon-address=127.0.0.1:18081 --wallet-file=/wallet/wallet.keys --tx-notify="/scripts/notifier.sh https://127.0.0.1:14142/monerolikedaemoncallback/tx?cryptoCode=xmr&hash=%s"
+        ports:
+            - "18082:18082"
+        volumes:
+            - "monero_wallet:/wallet"
+        depends_on:
+            - monerod
+        
+volumes:
+    monero_data:
+    monero_wallet:

BTCPayServer.Tests/docker-compose.yml

@@ -16,7 +16,6 @@ services:
       TESTS_LTCNBXPLORERURL: http://nbxplorer:32838/
       TESTS_DB: "Postgres"
       TESTS_POSTGRES: User ID=postgres;Host=postgres;Port=5432;Database=btcpayserver
-      TESTS_PORT: 80
       TESTS_HOSTNAME: tests
       TESTS_RUN_EXTERNAL_INTEGRATION: ${TESTS_RUN_EXTERNAL_INTEGRATION:-false}
       TESTS_AzureBlobStorageConnectionString: ${TESTS_AzureBlobStorageConnectionString:-none}
@@ -77,7 +76,7 @@ services:
       - customer_lnd
       - merchant_lnd
   nbxplorer:
-    image: nicolasdorier/nbxplorer:2.0.0.57
+    image: nicolasdorier/nbxplorer:2.0.0.66
     restart: unless-stopped
     ports:
       - "32838:32838"
@@ -128,7 +127,7 @@ services:
       - "bitcoin_datadir:/data"
 
   customer_lightningd:
-    image: btcpayserver/lightning:v0.7.1-dev
+    image: btcpayserver/lightning:v0.7.3-dev
     stop_signal: SIGKILL
     restart: unless-stopped
     environment: 
@@ -141,7 +140,7 @@ services:
         announce-addr=customer_lightningd
         log-level=debug
         funding-confirms=1
-        dev-broadcast-interval=1000
+        dev-fast-gossip
         dev-bitcoind-poll=1
     ports:
       - "30992:9835" # api port
@@ -155,7 +154,7 @@ services:
       - bitcoind
 
   lightning-charged:
-    image: shesek/lightning-charge:0.4.6-standalone
+    image: shesek/lightning-charge:0.4.11-standalone
     restart: unless-stopped
     environment:
       NETWORK: regtest
@@ -175,7 +174,7 @@ services:
       - merchant_lightningd
 
   merchant_lightningd:
-    image: btcpayserver/lightning:v0.7.1-dev
+    image: btcpayserver/lightning:v0.7.3-dev
     stop_signal: SIGKILL
     environment: 
       EXPOSE_TCP: "true"
@@ -187,7 +186,8 @@ services:
         announce-addr=merchant_lightningd
         funding-confirms=1
         log-level=debug
-        dev-broadcast-interval=1000
+        dev-fast-gossip
+        dev-bitcoind-poll=1
     ports:
       - "30993:9835" # api port
     expose:
@@ -224,7 +224,7 @@ services:
       - "5432"
 
   merchant_lnd:
-    image: btcpayserver/lnd:v0.7.0-beta
+    image: btcpayserver/lnd:v0.7.1-beta-withseed
     restart: unless-stopped
     environment:
       LND_CHAIN: "btc"
@@ -242,7 +242,6 @@ services:
         bitcoin.defaultchanconfs=1
         no-macaroons=1
         debuglevel=debug
-        noseedbackup=1
         trickledelay=1000
     ports:
       - "53280:8080"
@@ -255,7 +254,7 @@ services:
       - bitcoind
 
   customer_lnd:
-    image: btcpayserver/lnd:v0.7.0-beta
+    image: btcpayserver/lnd:v0.7.1-beta-withseed
     restart: unless-stopped
     environment:
       LND_CHAIN: "btc"
@@ -273,7 +272,6 @@ services:
         bitcoin.defaultchanconfs=1
         no-macaroons=1
         debuglevel=debug
-        noseedbackup=1
         trickledelay=1000
     ports:
       - "53281:8080"

BTCPayServer/Authentication/OpenId/AuthorizationCodeGrantTypeEventHandler.cs

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

BTCPayServer/Authentication/OpenId/LogoutEventHandler.cs

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

BTCPayServer/Authentication/OpenId/OpenIdExtensions.cs

@@ -1,139 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Security.Claims;
-using System.Threading.Tasks;
-using AspNet.Security.OpenIdConnect.Extensions;
-using AspNet.Security.OpenIdConnect.Primitives;
-using BTCPayServer.Data;
-using BTCPayServer.Models;
-using Microsoft.AspNetCore.Authentication;
-using Microsoft.AspNetCore.Identity;
-using OpenIddict.Abstractions;
-using OpenIddict.Core;
-using OpenIddict.Server;
-
-namespace BTCPayServer.Authentication.OpenId
-{
-    public static class OpenIdExtensions
-    {
-        public static async Task<AuthenticationTicket> CreateAuthenticationTicket(
-            OpenIddictApplicationManager<BTCPayOpenIdClient> applicationManager,
-            OpenIddictAuthorizationManager<BTCPayOpenIdAuthorization> authorizationManager,
-            IdentityOptions identityOptions,
-            SignInManager<ApplicationUser> signInManager,
-            OpenIdConnectRequest request,
-            ApplicationUser user,
-            AuthenticationProperties properties = null)
-        {
-            // Create a new ClaimsPrincipal containing the claims that
-            // will be used to create an id_token, a token or a code.
-            var principal = await signInManager.CreateUserPrincipalAsync(user);
-
-            // Create a new authentication ticket holding the user identity.
-            var ticket = new AuthenticationTicket(principal, properties,
-                OpenIddictServerDefaults.AuthenticationScheme);
-
-            if (!request.IsAuthorizationCodeGrantType() && !request.IsRefreshTokenGrantType())
-            {
-                ticket.SetScopes(request.GetScopes());
-            }
-            else if (request.IsAuthorizationCodeGrantType() &&
-                     string.IsNullOrEmpty(ticket.GetInternalAuthorizationId()))
-            {
-                var app = await applicationManager.FindByClientIdAsync(request.ClientId);
-                var authorizationId = await IsUserAuthorized(authorizationManager, request, user.Id, app.Id);
-                if (!string.IsNullOrEmpty(authorizationId))
-                {
-                    ticket.SetInternalAuthorizationId(authorizationId);
-                }
-            }
-
-            foreach (var claim in ticket.Principal.Claims)
-            {
-                claim.SetDestinations(GetDestinations(identityOptions, claim, ticket));
-            }
-
-            return ticket;
-        }
-
-        private static IEnumerable<string> GetDestinations(IdentityOptions identityOptions, Claim claim,
-            AuthenticationTicket ticket)
-        {
-            // Note: by default, claims are NOT automatically included in the access and identity tokens.
-            // To allow OpenIddict to serialize them, you must attach them a destination, that specifies
-            // whether they should be included in access tokens, in identity tokens or in both.
-
-
-            switch (claim.Type)
-            {
-                case OpenIddictConstants.Claims.Name:
-                    yield return OpenIddictConstants.Destinations.AccessToken;
-
-                    if (ticket.HasScope(OpenIddictConstants.Scopes.Profile))
-                        yield return OpenIddictConstants.Destinations.IdentityToken;
-
-                    yield break;
-
-                case OpenIddictConstants.Claims.Email:
-                    yield return OpenIddictConstants.Destinations.AccessToken;
-
-                    if (ticket.HasScope(OpenIddictConstants.Scopes.Email))
-                        yield return OpenIddictConstants.Destinations.IdentityToken;
-
-                    yield break;
-
-                case OpenIddictConstants.Claims.Role:
-                    yield return OpenIddictConstants.Destinations.AccessToken;
-
-                    if (ticket.HasScope(OpenIddictConstants.Scopes.Roles))
-                        yield return OpenIddictConstants.Destinations.IdentityToken;
-
-                    yield break;
-                default:
-                    if (claim.Type == identityOptions.ClaimsIdentity.SecurityStampClaimType)
-                    {
-                        // Never include the security stamp in the access and identity tokens, as it's a secret value.
-                        yield break;
-                    }
-                    else
-                    {
-                        yield return OpenIddictConstants.Destinations.AccessToken;
-                        yield break;
-                    }
-            }
-        }
-
-        public static async Task<string> IsUserAuthorized(
-            OpenIddictAuthorizationManager<BTCPayOpenIdAuthorization> authorizationManager,
-            OpenIdConnectRequest request, string userId, string applicationId)
-        {
-            var authorizations =
-                await authorizationManager.ListAsync(queryable =>
-                    queryable.Where(authorization =>
-                        authorization.Subject.Equals(userId, StringComparison.OrdinalIgnoreCase) &&
-                        applicationId.Equals(authorization.Application.Id, StringComparison.OrdinalIgnoreCase) &&
-                        authorization.Status.Equals(OpenIddictConstants.Statuses.Valid,
-                            StringComparison.OrdinalIgnoreCase)));
-
-
-            if (authorizations.Length > 0)
-            {
-                var scopeTasks = authorizations.Select(authorization =>
-                    (authorizationManager.GetScopesAsync(authorization).AsTask(), authorization.Id));
-                await Task.WhenAll(scopeTasks.Select((tuple) => tuple.Item1));
-
-                var authorizationsWithSufficientScopes = scopeTasks
-                    .Select((tuple) => (tuple.Id, Scopes: tuple.Item1.Result))
-                    .Where((tuple) => !request.GetScopes().Except(tuple.Scopes).Any());
-
-                if (authorizationsWithSufficientScopes.Any())
-                {
-                    return authorizationsWithSufficientScopes.First().Id;
-                }
-            }
-
-            return null;
-        }
-    }
-}

BTCPayServer/Authentication/OpenId/RefreshTokenGrantTypeEventHandler.cs

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

BTCPayServer/BTCPayServer.csproj

@@ -5,21 +5,18 @@
     <OutputType>Exe</OutputType>
   </PropertyGroup>
   <ItemGroup>
-    <Compile Remove="Build\dockerfiles\**" />
+    <Compile Remove="Build\**" />
+    <Compile Remove="Storage\Services\Providers\GoogleCloudStorage\**" Condition="'$(TargetFramework)' != 'netcoreapp2.1'" />
     <Compile Remove="wwwroot\bundles\jqueryvalidate\**" />
-    <Compile Remove="wwwroot\css\**" />
     <Compile Remove="wwwroot\vendor\jquery-nice-select\**" />
-    <Content Remove="Build\dockerfiles\**" />
+    <Content Remove="Build\**" />
     <Content Remove="wwwroot\bundles\jqueryvalidate\**" />
-    <Content Remove="wwwroot\css\**" />
     <Content Remove="wwwroot\vendor\jquery-nice-select\**" />
-    <EmbeddedResource Remove="Build\dockerfiles\**" />
+    <EmbeddedResource Remove="Build\**" />
     <EmbeddedResource Remove="wwwroot\bundles\jqueryvalidate\**" />
-    <EmbeddedResource Remove="wwwroot\css\**" />
     <EmbeddedResource Remove="wwwroot\vendor\jquery-nice-select\**" />
-    <None Remove="Build\dockerfiles\**" />
+    <None Remove="Build\**" />
     <None Remove="wwwroot\bundles\jqueryvalidate\**" />
-    <None Remove="wwwroot\css\**" />
     <None Remove="wwwroot\vendor\jquery-nice-select\**" />
   </ItemGroup>
   <ItemGroup>
@@ -30,25 +27,25 @@
     <EmbeddedResource Include="Currencies.txt" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="BTCPayServer.Lightning.All" Version="1.1.1" />
-    <PackageReference Include="BuildBundlerMinifier" Version="3.0.415" />
-    <PackageReference Include="BundlerMinifier.Core" Version="3.0.415" />
-    <PackageReference Include="BundlerMinifier.TagHelpers" Version="3.0.415" />
+    <PackageReference Include="BTCPayServer.Hwi" Version="1.1.2" />
+    <PackageReference Include="BTCPayServer.Lightning.All" Version="1.1.5" />
+    <PackageReference Include="BuildBundlerMinifier" Version="3.1.430" />
+    <PackageReference Include="BundlerMinifier.Core" Version="3.1.430" />
+    <PackageReference Include="BundlerMinifier.TagHelpers" Version="3.1.430" />
     <PackageReference Include="HtmlSanitizer" Version="4.0.217" />
-    <PackageReference Include="LedgerWallet" Version="2.0.0.3" />
+    <PackageReference Include="LedgerWallet" Version="2.0.0.5" />
     <PackageReference Include="Microsoft.Extensions.Logging.Filter" Version="1.1.2" />
     <PackageReference Include="Microsoft.NetCore.Analyzers" Version="2.6.2">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
     <PackageReference Include="NBitpayClient" Version="1.0.0.34" />	  
-    <PackageReference Include="DBriize" Version="1.0.0.4" />
+    <PackageReference Include="DBriize" Version="1.0.1.3" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.2" />
     <PackageReference Include="NicolasDorier.CommandLine" Version="1.0.0.2" />
     <PackageReference Include="NicolasDorier.CommandLine.Configuration" Version="1.0.0.3" />
     <PackageReference Include="NicolasDorier.RateLimits" Version="1.0.0.9" />
     <PackageReference Include="NicolasDorier.StandardConfiguration" Version="1.0.0.18" />
-    <PackageReference Include="OpenIddict" Version="2.0.0" />
     <PackageReference Include="Serilog" Version="2.7.1" />
     <PackageReference Include="Serilog.AspNetCore" Version="2.1.1" />
     <PackageReference Include="Serilog.Sinks.File" Version="4.0.0" />
@@ -60,22 +57,27 @@
   </ItemGroup>
 
 	<ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.App" Version="2.1.9" />
+    <PackageReference Include="Microsoft.AspNetCore.App" Version="2.1.9" AllowExplicitVersion="true" Condition="'$(TargetFramework)' == 'netcoreapp2.1'" />
     <PackageReference Include="TwentyTwenty.Storage" Version="2.11.2" />
     <PackageReference Include="TwentyTwenty.Storage.Amazon" Version="2.11.2" />
     <PackageReference Include="TwentyTwenty.Storage.Azure" Version="2.11.2" />
-    <PackageReference Include="TwentyTwenty.Storage.Google" Version="2.11.2" />
+    <PackageReference Include="TwentyTwenty.Storage.Google" Version="2.11.2" Condition="'$(TargetFramework)' == 'netcoreapp2.1'" />
     <PackageReference Include="TwentyTwenty.Storage.Local" Version="2.11.2" />
     <PackageReference Include="U2F.Core" Version="1.0.4" />
 		<PackageReference Include="YamlDotNet" Version="5.2.1" />
+    <PackageReference Include="OpenIddict" Version="3.0.0-alpha1.19515.63" />
+    <PackageReference Include="OpenIddict.Server.AspNetCore" Version="3.0.0-alpha1.19515.63"></PackageReference>
+    <PackageReference Include="OpenIddict.Validation.AspNetCore" Version="3.0.0-alpha1.19515.63"></PackageReference>
 	</ItemGroup>
 
-	<ItemGroup>
-		<DotNetCliToolReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Tools" Version="2.0.0" />
-	</ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' != 'netcoreapp2.1'">
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="3.0.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="3.0.0"></PackageReference>
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.OpenIdConnect" Version="3.0.0" />
+  </ItemGroup>
 
 	<ItemGroup>
-	  <None Include="wwwroot\vendor\bootstrap4-creativestart\creative.js" />
+	  <None Include="wwwroot\main\bootstrap4-creativestart\creative.js" />
 	  <None Include="wwwroot\vendor\font-awesome\fonts\fontawesome-webfont.svg" />
 	  <None Include="wwwroot\vendor\font-awesome\fonts\fontawesome-webfont.woff2" />
 	  <None Include="wwwroot\vendor\font-awesome\less\animated.less" />
@@ -120,9 +122,6 @@
 	</ItemGroup>
 
 	<ItemGroup>
-	  <Folder Include="Authentication\OpenId\Models\" />
-	  <Folder Include="Build\" />
-	  <Folder Include="U2F\Services" />
 	  <Folder Include="wwwroot\vendor\clipboard.js\" />
 	  <Folder Include="wwwroot\vendor\highlightjs\" />
 	  <Folder Include="wwwroot\vendor\summernote" />
@@ -152,6 +151,12 @@
     <Content Update="Views\Server\LightningWalletServices.cshtml">
       <Pack>$(IncludeRazorContentInPack)</Pack>
     </Content>
+    <Content Update="Views\Server\LndSeedBackup.cshtml">
+      <Pack>$(IncludeRazorContentInPack)</Pack>
+    </Content>
+    <Content Update="Views\Server\RPCService.cshtml">
+      <Pack>$(IncludeRazorContentInPack)</Pack>
+    </Content>
     <Content Update="Views\Server\P2PService.cshtml">
       <Pack>$(IncludeRazorContentInPack)</Pack>
     </Content>
@@ -197,12 +202,17 @@
 	  <Content Update="Views\Wallets\WalletRescan.cshtml">
 	    <Pack>$(IncludeRazorContentInPack)</Pack>
 	  </Content>
+	  <Content Update="Views\Wallets\WalletSendVault.cshtml">
+	    <Pack>$(IncludeRazorContentInPack)</Pack>
+	  </Content>
 	  <Content Update="Views\Wallets\WalletSendLedger.cshtml">
 	    <Pack>$(IncludeRazorContentInPack)</Pack>
 	  </Content>
 	  <Content Update="Views\Wallets\WalletTransactions.cshtml">
 	    <Pack>$(IncludeRazorContentInPack)</Pack>
 	  </Content>
+    <Content Remove="Views\Server\EditGoogleCloudStorageStorageProvider.cshtml" Condition="'$(TargetFramework)' != 'netcoreapp2.1'">
+    </Content>
 	  <Content Update="Views\Wallets\_Nav.cshtml">
 	    <Pack>$(IncludeRazorContentInPack)</Pack>
 	  </Content>

BTCPayServer/Configuration/BTCPayServerOptions.cs

@@ -58,7 +58,16 @@ namespace BTCPayServer.Configuration
 
         public static string GetDebugLog(IConfiguration configuration)
         {
-            return configuration.GetValue<string>("debuglog", null);
+            var logfile = configuration.GetValue<string>("debuglog", null);
+            if (!string.IsNullOrEmpty(logfile))
+            {
+                if (!Path.IsPathRooted(logfile))
+                {
+                    var networkType = DefaultConfiguration.GetNetworkType(configuration);
+                    logfile = Path.Combine(configuration.GetDataDir(networkType), logfile);
+                }
+            }
+            return logfile;
         }
         public static LogEventLevel GetDebugLogLevel(IConfiguration configuration)
         {

BTCPayServer/Configuration/DefaultConfiguration.cs

@@ -47,6 +47,7 @@ namespace BTCPayServer.Configuration
             app.Option("--debuglog", "A rolling log file for debug messages.", CommandOptionType.SingleValue);
             app.Option("--debugloglevel", "The severity you log (default:information)", CommandOptionType.SingleValue);
             app.Option("--disable-registration", "Disables new user registrations (default:true)", CommandOptionType.SingleValue);
+            app.Option("--xforwardedproto", "If specified, set X-Forwarded-Proto to the specified value, this may be useful if your reverse proxy handle https but is not configured to add X-Forwarded-Proto (example: --xforwardedproto https)", CommandOptionType.SingleValue);
             foreach (var network in provider.GetAll().OfType<BTCPayNetwork>())
             {
                 var crypto = network.CryptoCode.ToLowerInvariant();

BTCPayServer/Configuration/ExternalConnectionString.cs

@@ -142,6 +142,12 @@ namespace BTCPayServer.Configuration
                 Macaroons = Macaroons?.Clone()
             };
         }
+        public bool? IsOnion()
+        {
+            if (this.Server == null || !this.Server.IsAbsoluteUri)
+                return null;
+            return this.Server.DnsSafeHost.EndsWith(".onion", StringComparison.OrdinalIgnoreCase);
+        }
         public static bool TryParse(string str, out ExternalConnectionString result, out string error)
         {
             if (str == null)

BTCPayServer/Configuration/ExternalService.cs

@@ -24,6 +24,10 @@ namespace BTCPayServer.Configuration
                                 "lnd server: 'server=https://lnd.example.com;macaroondirectorypath=/root/.lnd;certthumbprint=2abdf302...'" + Environment.NewLine +
                                 "Error: {1}",
                                 "LND (REST server)");
+            Load(configuration, cryptoCode, "lndseedbackup", ExternalServiceTypes.LNDSeedBackup, "Invalid setting {0}, " + Environment.NewLine +
+                                "lnd seed backup: /etc/merchant_lnd/data/chain/bitcoin/regtest/walletunlock.json'" + Environment.NewLine +
+                                "Error: {1}",
+                                "LND Seed Backup");
             Load(configuration, cryptoCode, "spark", ExternalServiceTypes.Spark, "Invalid setting {0}, " + Environment.NewLine +
                                 $"Valid example: 'server=https://btcpay.example.com/spark/btc/;cookiefile=/etc/clightning_bitcoin_spark/.cookie'" + Environment.NewLine +
                                 "Error: {1}",
@@ -45,11 +49,17 @@ namespace BTCPayServer.Configuration
             var connStr = configuration.GetOrDefault<string>(setting, string.Empty);
             if (connStr.Length != 0)
             {
-                if (!ExternalConnectionString.TryParse(connStr, out var connectionString, out var error))
+                ExternalConnectionString serviceConnection;
+                if (type == ExternalServiceTypes.LNDSeedBackup)
+                {
+                    // just using CookieFilePath to hold variable instead of refactoring whole holder class to better conform
+                    serviceConnection = new ExternalConnectionString { CookieFilePath = connStr };
+                }
+                else if (!ExternalConnectionString.TryParse(connStr, out serviceConnection, out var error))
                 {
                     throw new ConfigException(string.Format(CultureInfo.InvariantCulture, errorMessage, setting, error));
                 }
-                this.Add(new ExternalService() { Type = type, ConnectionString = connectionString, CryptoCode = cryptoCode, DisplayName = displayName, ServiceName = serviceName });
+                this.Add(new ExternalService() { Type = type, ConnectionString = serviceConnection, CryptoCode = cryptoCode, DisplayName = displayName, ServiceName = serviceName });
             }
         }
 
@@ -73,9 +83,11 @@ namespace BTCPayServer.Configuration
     {
         LNDRest,
         LNDGRPC,
+        LNDSeedBackup,
         Spark,
         RTL,
         Charge,
-        P2P
+        P2P,
+        RPC
     }
 }

BTCPayServer/Controllers/AccessTokenController.cs

@@ -1,6 +1,7 @@
-using BTCPayServer.Authentication;
-using BTCPayServer.Filters;
+using BTCPayServer.Filters;
 using BTCPayServer.Models;
+using BTCPayServer.Security;
+using BTCPayServer.Security.Bitpay;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Cors;
 using Microsoft.AspNetCore.Mvc;
@@ -13,7 +14,7 @@ using System.Threading.Tasks;
 
 namespace BTCPayServer.Controllers
 {
-    [Authorize(AuthenticationSchemes = Security.Policies.BitpayAuthentication)]
+    [Authorize(AuthenticationSchemes = Security.AuthenticationSchemes.Bitpay)]
     [BitpayAPIConstraint()]
     public class AccessTokenController : Controller
     {

BTCPayServer/Controllers/AccountController.cs

@@ -18,15 +18,15 @@ using BTCPayServer.Services.Stores;
 using BTCPayServer.Logging;
 using BTCPayServer.Security;
 using System.Globalization;
-using BTCPayServer.Services.U2F;
-using BTCPayServer.Services.U2F.Models;
+using BTCPayServer.U2F;
+using BTCPayServer.U2F.Models;
 using Newtonsoft.Json;
 using NicolasDorier.RateLimits;
 using BTCPayServer.Data;
 
 namespace BTCPayServer.Controllers
 {
-    [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
+    [Authorize(AuthenticationSchemes = AuthenticationSchemes.Cookie)]
     [Route("[controller]/[action]")]
     public class AccountController : Controller
     {
@@ -74,21 +74,32 @@ namespace BTCPayServer.Controllers
         [AllowAnonymous]
         public async Task<IActionResult> Login(string returnUrl = null)
         {
+            
             if (User.Identity.IsAuthenticated && string.IsNullOrEmpty(returnUrl))
                 return RedirectToLocal();
             // Clear the existing external cookie to ensure a clean login process
             await HttpContext.SignOutAsync(IdentityConstants.ExternalScheme);
 
+            if (!CanLoginOrRegister())
+            {
+                SetInsecureFlags();
+            }
+            
             ViewData["ReturnUrl"] = returnUrl;
             return View();
         }
 
+
         [HttpPost]
         [AllowAnonymous]
         [ValidateAntiForgeryToken]
         [RateLimitsFilter(ZoneLimits.Login, Scope = RateLimitsScope.RemoteAddress)]
         public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null)
         {
+            if (!CanLoginOrRegister())
+            {
+                return RedirectToAction("Login");
+            }
             ViewData["ReturnUrl"] = returnUrl;
             if (ModelState.IsValid)
             {
@@ -199,6 +210,11 @@ namespace BTCPayServer.Controllers
         [ValidateAntiForgeryToken]
         public async Task<IActionResult> LoginWithU2F(LoginWithU2FViewModel viewModel, string returnUrl = null)
         {
+            if (!CanLoginOrRegister())
+            {
+                return RedirectToAction("Login");
+            }
+            
             ViewData["ReturnUrl"] = returnUrl;
             var user = await _userManager.FindByIdAsync(viewModel.UserId);
 
@@ -242,6 +258,11 @@ namespace BTCPayServer.Controllers
         [AllowAnonymous]
         public async Task<IActionResult> LoginWith2fa(bool rememberMe, string returnUrl = null)
         {
+            if (!CanLoginOrRegister())
+            {
+                return RedirectToAction("Login");
+            }
+
             // Ensure the user has gone through the username & password screen first
             var user = await _signInManager.GetTwoFactorAuthenticationUserAsync();
 
@@ -264,6 +285,11 @@ namespace BTCPayServer.Controllers
         [ValidateAntiForgeryToken]
         public async Task<IActionResult> LoginWith2fa(LoginWith2faViewModel model, bool rememberMe, string returnUrl = null)
         {
+            if (!CanLoginOrRegister())
+            {
+                return RedirectToAction("Login");
+            }
+
             if (!ModelState.IsValid)
             {
                 return View(model);
@@ -305,6 +331,11 @@ namespace BTCPayServer.Controllers
         [AllowAnonymous]
         public async Task<IActionResult> LoginWithRecoveryCode(string returnUrl = null)
         {
+            if (!CanLoginOrRegister())
+            {
+                return RedirectToAction("Login");
+            }
+
             // Ensure the user has gone through the username & password screen first
             var user = await _signInManager.GetTwoFactorAuthenticationUserAsync();
             if (user == null)
@@ -322,6 +353,11 @@ namespace BTCPayServer.Controllers
         [ValidateAntiForgeryToken]
         public async Task<IActionResult> LoginWithRecoveryCode(LoginWithRecoveryCodeViewModel model, string returnUrl = null)
         {
+            if (!CanLoginOrRegister())
+            {
+                return RedirectToAction("Login");
+            }
+
             if (!ModelState.IsValid)
             {
                 return View(model);
@@ -364,14 +400,19 @@ namespace BTCPayServer.Controllers
 
         [HttpGet]
         [AllowAnonymous]
-        public async Task<IActionResult> Register(string returnUrl = null, bool logon = true)
+        public async Task<IActionResult> Register(string returnUrl = null, bool logon = true, bool useBasicLayout = false)
         {
+            if (!CanLoginOrRegister())
+            {
+                SetInsecureFlags();
+            }
             var policies = await _SettingsRepository.GetSettingAsync<PoliciesSettings>() ?? new PoliciesSettings();
             if (policies.LockSubscription && !User.IsInRole(Roles.ServerAdmin))
                 return RedirectToAction(nameof(HomeController.Index), "Home");
             ViewData["ReturnUrl"] = returnUrl;
             ViewData["Logon"] = logon.ToString(CultureInfo.InvariantCulture).ToLowerInvariant();
             ViewData["AllowIsAdmin"] = _Options.AllowAdminRegistration;
+            ViewData["UseBasicLayout"] = useBasicLayout;
             return View();
         }
 
@@ -380,6 +421,11 @@ namespace BTCPayServer.Controllers
         [ValidateAntiForgeryToken]
         public async Task<IActionResult> Register(RegisterViewModel model, string returnUrl = null, bool logon = true)
         {
+            if (!CanLoginOrRegister())
+            {
+                return RedirectToAction("Register");
+            }
+
             ViewData["ReturnUrl"] = returnUrl;
             ViewData["Logon"] = logon.ToString(CultureInfo.InvariantCulture).ToLowerInvariant();
             ViewData["AllowIsAdmin"] = _Options.AllowAdminRegistration;
@@ -398,7 +444,9 @@ namespace BTCPayServer.Controllers
                     {
                         await _RoleManager.CreateAsync(new IdentityRole(Roles.ServerAdmin));
                         await _userManager.AddToRoleAsync(user, Roles.ServerAdmin);
-
+                        var settings = await _SettingsRepository.GetSettingAsync<ThemeSettings>();
+                        settings.FirstRun = false;
+                        await _SettingsRepository.UpdateSetting<ThemeSettings>(settings);
                         if(_Options.DisableRegistration)
                         {
                             // Once the admin user has been created lock subsequent user registrations (needs to be disabled for unit tests that require multiple users).
@@ -420,7 +468,7 @@ namespace BTCPayServer.Controllers
                     }
                     else
                     {
-                        TempData["StatusMessage"] = "Account created, please confirm your email";
+                        TempData[WellKnownTempData.SuccessMessage] = "Account created, please confirm your email";
                         return View();
                     }
                 }
@@ -447,88 +495,6 @@ namespace BTCPayServer.Controllers
             return RedirectToAction(nameof(HomeController.Index), "Home");
         }
 
-        [HttpPost]
-        [AllowAnonymous]
-        [ValidateAntiForgeryToken]
-        public IActionResult ExternalLogin(string provider, string returnUrl = null)
-        {
-            // Request a redirect to the external login provider.
-            var redirectUrl = Url.Action(nameof(ExternalLoginCallback), "Account", new
-            {
-                returnUrl
-            });
-            var properties = _signInManager.ConfigureExternalAuthenticationProperties(provider, redirectUrl);
-            return Challenge(properties, provider);
-        }
-
-        [HttpGet]
-        [AllowAnonymous]
-        public async Task<IActionResult> ExternalLoginCallback(string returnUrl = null, string remoteError = null)
-        {
-            if (remoteError != null)
-            {
-                ErrorMessage = $"Error from external provider: {remoteError}";
-                return RedirectToAction(nameof(Login));
-            }
-            var info = await _signInManager.GetExternalLoginInfoAsync();
-            if (info == null)
-            {
-                return RedirectToAction(nameof(Login));
-            }
-
-            // Sign in the user with this external login provider if the user already has a login.
-            var result = await _signInManager.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, isPersistent: false, bypassTwoFactor: true);
-            if (result.Succeeded)
-            {
-                _logger.LogInformation("User logged in with {Name} provider.", info.LoginProvider);
-                return RedirectToLocal(returnUrl);
-            }
-            if (result.IsLockedOut)
-            {
-                return RedirectToAction(nameof(Lockout));
-            }
-            else
-            {
-                // If the user does not have an account, then ask the user to create an account.
-                ViewData["ReturnUrl"] = returnUrl;
-                ViewData["LoginProvider"] = info.LoginProvider;
-                var email = info.Principal.FindFirstValue(ClaimTypes.Email);
-                return View("ExternalLogin", new ExternalLoginViewModel { Email = email });
-            }
-        }
-
-        [HttpPost]
-        [AllowAnonymous]
-        [ValidateAntiForgeryToken]
-        public async Task<IActionResult> ExternalLoginConfirmation(ExternalLoginViewModel model, string returnUrl = null)
-        {
-            if (ModelState.IsValid)
-            {
-                // Get the information about the user from the external login provider
-                var info = await _signInManager.GetExternalLoginInfoAsync();
-                if (info == null)
-                {
-                    throw new ApplicationException("Error loading external login information during confirmation.");
-                }
-                var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
-                var result = await _userManager.CreateAsync(user);
-                if (result.Succeeded)
-                {
-                    result = await _userManager.AddLoginAsync(user, info);
-                    if (result.Succeeded)
-                    {
-                        await _signInManager.SignInAsync(user, isPersistent: false);
-                        _logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
-                        return RedirectToLocal(returnUrl);
-                    }
-                }
-                AddErrors(result);
-            }
-
-            ViewData["ReturnUrl"] = returnUrl;
-            return View(nameof(ExternalLogin), model);
-        }
-
         [HttpGet]
         [AllowAnonymous]
         public async Task<IActionResult> ConfirmEmail(string userId, string code)
@@ -659,6 +625,23 @@ namespace BTCPayServer.Controllers
                 return RedirectToAction(nameof(HomeController.Index), "Home");
             }
         }
+        
+        
+        private bool CanLoginOrRegister()
+        {
+            return _btcPayServerEnvironment.IsDevelopping || _btcPayServerEnvironment.IsSecure;
+        }
+
+        private void SetInsecureFlags()
+        {
+            TempData.SetStatusMessageModel(new StatusMessageModel()
+            {
+                Severity = StatusMessageModel.StatusSeverity.Error,
+                Message = "You cannot login over an insecure connection. Please use HTTPS or Tor."
+            });
+            
+            ViewData["disabled"] = true;
+        }
 
         #endregion
     }

BTCPayServer/Controllers/AppsController.Crowdfund.cs

@@ -68,7 +68,7 @@ namespace BTCPayServer.Controllers
         }
         [HttpPost]
         [Route("{appId}/settings/crowdfund")]
-        public async Task<IActionResult> UpdateCrowdfund(string appId, UpdateCrowdfundViewModel vm)
+        public async Task<IActionResult> UpdateCrowdfund(string appId, UpdateCrowdfundViewModel vm, string command)
         {
             if (!string.IsNullOrEmpty( vm.TargetCurrency) && _currencies.GetCurrencyData(vm.TargetCurrency, false) == null)
                 ModelState.AddModelError(nameof(vm.TargetCurrency), "Invalid currency");
@@ -156,16 +156,25 @@ namespace BTCPayServer.Controllers
 
             app.TagAllInvoices = vm.UseAllStoreInvoices;
             app.SetSettings(newSettings);
-            await _AppService.UpdateOrCreateApp(app);
 
-            _EventAggregator.Publish(new AppUpdated()
+            if (command == "save")
             {
-                AppId = appId,
-                StoreId = app.StoreDataId,
-                Settings = newSettings
-            });
-            StatusMessage = "App updated";
-            return RedirectToAction(nameof(UpdateCrowdfund), new {appId});
+                await _AppService.UpdateOrCreateApp(app);
+
+                _EventAggregator.Publish(new AppUpdated()
+                {
+                    AppId = appId,
+                    StoreId = app.StoreDataId,
+                    Settings = newSettings
+                });
+                TempData[WellKnownTempData.SuccessMessage] = "App updated";
+                return RedirectToAction(nameof(UpdateCrowdfund), new { appId });
+            }
+            else if (command == "viewapp")
+            {
+                return RedirectToAction(nameof(AppsPublicController.ViewCrowdfund), "AppsPublic", new { appId });
+            }
+            return NotFound();
         }
     }
 }

BTCPayServer/Controllers/AppsController.PointOfSale.cs

@@ -201,7 +201,7 @@ namespace BTCPayServer.Controllers
                 
             });
             await _AppService.UpdateOrCreateApp(app);
-            StatusMessage = "App updated";
+            TempData[WellKnownTempData.SuccessMessage] = "App updated";
             return RedirectToAction(nameof(UpdatePointOfSale), new { appId });
         }
 

BTCPayServer/Controllers/AppsController.cs

@@ -19,7 +19,7 @@ using NBitcoin.DataEncoders;
 
 namespace BTCPayServer.Controllers
 {
-    [Authorize(AuthenticationSchemes = Policies.CookieAuthentication)]
+    [Authorize(AuthenticationSchemes = AuthenticationSchemes.Cookie)]
     [AutoValidateAntiforgeryToken]
     [Route("apps")]
     public partial class AppsController : Controller
@@ -50,8 +50,6 @@ namespace BTCPayServer.Controllers
         private readonly EmailSenderFactory _emailSenderFactory;
         private AppService _AppService;
 
-        [TempData]
-        public string StatusMessage { get; set; }
         public string CreatedAppId { get; set; }
 
         public async Task<IActionResult> ListApps()
@@ -71,7 +69,7 @@ namespace BTCPayServer.Controllers
             if (appData == null)
                 return NotFound();
             if (await _AppService.DeleteApp(appData))
-                StatusMessage = "App removed successfully";
+                TempData[WellKnownTempData.SuccessMessage] = "App removed successfully";
             return RedirectToAction(nameof(ListApps));
         }
 
@@ -82,12 +80,12 @@ namespace BTCPayServer.Controllers
             var stores = await _AppService.GetOwnedStores(GetUserId());
             if (stores.Length == 0)
             {
-                StatusMessage = new StatusMessageModel()
+                TempData.SetStatusMessageModel(new StatusMessageModel()
                 {
                     Html =
                         $"Error: You need to create at least one store. <a href='{(Url.Action("CreateStore", "UserStores"))}'>Create store</a>",
                     Severity = StatusMessageModel.StatusSeverity.Error
-                }.ToString();
+                });
                 return RedirectToAction(nameof(ListApps));
             }
             var vm = new CreateAppViewModel();
@@ -102,12 +100,12 @@ namespace BTCPayServer.Controllers
             var stores = await _AppService.GetOwnedStores(GetUserId());
             if (stores.Length == 0)
             {
-                StatusMessage = new StatusMessageModel()
+                TempData.SetStatusMessageModel(new StatusMessageModel()
                 {
                     Html =
                         $"Error: You need to create at least one store. <a href='{(Url.Action("CreateStore", "UserStores"))}'>Create store</a>",
                     Severity = StatusMessageModel.StatusSeverity.Error
-                }.ToString();
+                });
                 return RedirectToAction(nameof(ListApps));
             }
             var selectedStore = vm.SelectedStore;
@@ -124,7 +122,7 @@ namespace BTCPayServer.Controllers
 
             if (!stores.Any(s => s.Id == selectedStore))
             {
-                StatusMessage = "Error: You are not owner of this store";
+                TempData[WellKnownTempData.ErrorMessage] = "You are not owner of this store";
                 return RedirectToAction(nameof(ListApps));
             }
             var appData = new AppData
@@ -134,7 +132,7 @@ namespace BTCPayServer.Controllers
                 AppType = appType.ToString()
             };
             await _AppService.UpdateOrCreateApp(appData);
-            StatusMessage = "App successfully created";
+            TempData[WellKnownTempData.SuccessMessage] = "App successfully created";
             CreatedAppId = appData.Id;
 
             switch (appType)