remove from state when unreserved

BTCPayServer.Abstractions/BTCPayServer.Abstractions.csproj

@@ -31,12 +31,9 @@
     <None Include="icon.png" Pack="true" PackagePath="\" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="3.1.19" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="3.1.19" />
-    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="3.1.18" />
-    <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="3.2.7" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\BTCPayServer.Client\BTCPayServer.Client.csproj" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="3.1.4" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="3.1.4" />
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="3.1.4" />
+    <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="3.1.1" />
   </ItemGroup>
 </Project>

BTCPayServer.Abstractions/Contracts/IBTCPayServerClientFactory.cs

@@ -1,10 +0,0 @@
-using System.Threading.Tasks;
-using BTCPayServer.Client;
-
-namespace BTCPayServer.Abstractions.Contracts
-{
-    public interface IBTCPayServerClientFactory
-    {
-        Task<BTCPayServerClient> Create(string userId, params string[] storeIds);
-    }
-}

BTCPayServer.Abstractions/Contracts/ISyncSummaryProvider.cs

@@ -1,5 +1,3 @@
-using System.Collections.Generic;
-
 namespace BTCPayServer.Abstractions.Contracts
 {
     public interface ISyncSummaryProvider
@@ -7,12 +5,5 @@ namespace BTCPayServer.Abstractions.Contracts
         bool AllAvailable();
 
         string Partial { get; }
-        IEnumerable<ISyncStatus> GetStatuses();
-    }
-
-    public interface ISyncStatus
-    {
-        public string CryptoCode { get; set; }
-        public bool Available { get; }
     }
 }

BTCPayServer.Client/BTCPayServer.Client.csproj

@@ -13,7 +13,7 @@
         <RepositoryType>git</RepositoryType>
     </PropertyGroup>
   <PropertyGroup>
-    <Version Condition=" '$(Version)' == '' ">1.5.0</Version>
+    <Version Condition=" '$(Version)' == '' ">1.3.0</Version>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
@@ -27,9 +27,9 @@
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
   </ItemGroup>
     <ItemGroup>
-      <PackageReference Include="NBitcoin" Version="6.0.15" />
-      <PackageReference Include="BTCPayServer.Lightning.Common" Version="1.2.7" />
-      <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
+      <PackageReference Include="NBitcoin" Version="5.0.73" />
+      <PackageReference Include="BTCPayServer.Lightning.Common" Version="1.2.0" />
+      <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
     </ItemGroup>
   <ItemGroup>
     <None Include="icon.png" Pack="true" PackagePath="\" />

BTCPayServer.Client/BTCPayServerClient.Invoices.cs

@@ -1,54 +1,21 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
-using NBitcoin;
 
 namespace BTCPayServer.Client
 {
     public partial class BTCPayServerClient
     {
-        public virtual async Task<IEnumerable<InvoiceData>> GetInvoices(string storeId, string[] orderId = null,
-            InvoiceStatus[] status = null,
-            DateTimeOffset? startDate = null,
-            DateTimeOffset? endDate = null,
-            string textSearch = null,
-            bool includeArchived = false,
-            int? skip = null,
-            int? take = null,
+        public virtual async Task<IEnumerable<InvoiceData>> GetInvoices(string storeId, bool includeArchived = false,
             CancellationToken token = default)
         {
-            Dictionary<string, object> queryPayload = new Dictionary<string, object>();
-            queryPayload.Add(nameof(includeArchived), includeArchived);
-
-            if (startDate is DateTimeOffset s)
-                queryPayload.Add(nameof(startDate), Utils.DateTimeToUnixTime(s));
-
-            if (endDate is DateTimeOffset e)
-                queryPayload.Add(nameof(endDate), Utils.DateTimeToUnixTime(e));
-
-            if (orderId != null)
-                queryPayload.Add(nameof(orderId), orderId);
-            if (textSearch != null)
-                queryPayload.Add(nameof(textSearch), textSearch);
-            if (status != null)
-                queryPayload.Add(nameof(status), status.Select(s=> s.ToString().ToLower()).ToArray());
-
-            if(skip != null) {
-                queryPayload.Add(nameof(skip), skip);
-            }
-
-             if(take != null) {
-                queryPayload.Add(nameof(take), take);
-            }
-            
             var response =
                 await _httpClient.SendAsync(
                     CreateHttpRequest($"api/v1/stores/{storeId}/invoices",
-                        queryPayload), token);
+                        new Dictionary<string, object>() {{nameof(includeArchived), includeArchived}}), token);
             return await HandleResponse<IEnumerable<InvoiceData>>(response);
         }
 
@@ -103,7 +70,7 @@ namespace BTCPayServer.Client
         {
             if (request == null)
                 throw new ArgumentNullException(nameof(request));
-            if (request.Status != InvoiceStatus.Settled && request.Status != InvoiceStatus.Invalid)
+            if (request.Status!= InvoiceStatus.Settled && request.Status!= InvoiceStatus.Invalid)
                 throw new ArgumentOutOfRangeException(nameof(request.Status), "Status can only be Invalid or Complete");
             var response = await _httpClient.SendAsync(
                 CreateHttpRequest($"api/v1/stores/{storeId}/invoices/{invoiceId}/status", bodyPayload: request,

BTCPayServer.Client/BTCPayServerClient.LNURLPayPaymentMethods.cs

@@ -1,59 +0,0 @@
-using System.Collections.Generic;
-using System.Net.Http;
-using System.Threading;
-using System.Threading.Tasks;
-using BTCPayServer.Client.Models;
-
-namespace BTCPayServer.Client
-{
-    public partial class BTCPayServerClient
-    {
-        public virtual async Task<IEnumerable<LNURLPayPaymentMethodData>>
-            GetStoreLNURLPayPaymentMethods(string storeId, bool? enabled = null,
-                CancellationToken token = default)
-        {
-            var query = new Dictionary<string, object>();
-            if (enabled != null)
-            {
-                query.Add(nameof(enabled), enabled);
-            }
-
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LNURLPay",
-                        query), token);
-            return await HandleResponse<IEnumerable<LNURLPayPaymentMethodData>>(response);
-        }
-
-        public virtual async Task<LNURLPayPaymentMethodData> GetStoreLNURLPayPaymentMethod(
-            string storeId,
-            string cryptoCode, CancellationToken token = default)
-        {
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LNURLPay/{cryptoCode}"), token);
-            return await HandleResponse<LNURLPayPaymentMethodData>(response);
-        }
-
-        public virtual async Task RemoveStoreLNURLPayPaymentMethod(string storeId,
-            string cryptoCode, CancellationToken token = default)
-        {
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LNURLPay/{cryptoCode}",
-                        method: HttpMethod.Delete), token);
-            await HandleResponse(response);
-        }
-
-        public virtual async Task<LNURLPayPaymentMethodData> UpdateStoreLNURLPayPaymentMethod(
-            string storeId,
-            string cryptoCode, LNURLPayPaymentMethodData paymentMethod,
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LNURLPay/{cryptoCode}",
-                    bodyPayload: paymentMethod, method: HttpMethod.Put), token);
-            return await HandleResponse<LNURLPayPaymentMethodData>(response);
-        }
-    }
-}

BTCPayServer.Client/BTCPayServerClient.Lightning.Internal.cs

@@ -9,7 +9,7 @@ namespace BTCPayServer.Client
 {
     public partial class BTCPayServerClient
     {
-        public virtual async Task<LightningNodeInformationData> GetLightningNodeInfo(string cryptoCode,
+        public async Task<LightningNodeInformationData> GetLightningNodeInfo(string cryptoCode,
             CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(
@@ -18,7 +18,7 @@ namespace BTCPayServer.Client
             return await HandleResponse<LightningNodeInformationData>(response);
         }
 
-        public virtual async Task ConnectToLightningNode(string cryptoCode, ConnectToNodeRequest request,
+        public async Task ConnectToLightningNode(string cryptoCode, ConnectToNodeRequest request,
             CancellationToken token = default)
         {
             if (request == null)
@@ -29,7 +29,7 @@ namespace BTCPayServer.Client
             await HandleResponse(response);
         }
 
-        public virtual async Task<IEnumerable<LightningChannelData>> GetLightningNodeChannels(string cryptoCode,
+        public async Task<IEnumerable<LightningChannelData>> GetLightningNodeChannels(string cryptoCode,
             CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(
@@ -38,16 +38,16 @@ namespace BTCPayServer.Client
             return await HandleResponse<IEnumerable<LightningChannelData>>(response);
         }
 
-        public virtual async Task OpenLightningChannel(string cryptoCode, OpenLightningChannelRequest request,
+        public async Task<string> OpenLightningChannel(string cryptoCode, OpenLightningChannelRequest request,
             CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(
                 CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/channels", bodyPayload: request,
                     method: HttpMethod.Post), token);
-            await HandleResponse(response);
+            return await HandleResponse<string>(response);
         }
 
-        public virtual async Task<string> GetLightningDepositAddress(string cryptoCode, CancellationToken token = default)
+        public async Task<string> GetLightningDepositAddress(string cryptoCode, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(
                 CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/address", method: HttpMethod.Post), token);
@@ -55,7 +55,7 @@ namespace BTCPayServer.Client
         }
 
 
-        public virtual async Task PayLightningInvoice(string cryptoCode, PayLightningInvoiceRequest request,
+        public async Task PayLightningInvoice(string cryptoCode, PayLightningInvoiceRequest request,
             CancellationToken token = default)
         {
             if (request == null)
@@ -66,7 +66,7 @@ namespace BTCPayServer.Client
             await HandleResponse(response);
         }
 
-        public virtual async Task<LightningInvoiceData> GetLightningInvoice(string cryptoCode,
+        public async Task<LightningInvoiceData> GetLightningInvoice(string cryptoCode,
             string invoiceId, CancellationToken token = default)
         {
             if (invoiceId == null)
@@ -77,7 +77,7 @@ namespace BTCPayServer.Client
             return await HandleResponse<LightningInvoiceData>(response);
         }
 
-        public virtual async Task<LightningInvoiceData> CreateLightningInvoice(string cryptoCode, CreateLightningInvoiceRequest request,
+        public async Task<LightningInvoiceData> CreateLightningInvoice(string cryptoCode, CreateLightningInvoiceRequest request,
             CancellationToken token = default)
         {
             if (request == null)

BTCPayServer.Client/BTCPayServerClient.Lightning.Store.cs

@@ -9,7 +9,7 @@ namespace BTCPayServer.Client
 {
     public partial class BTCPayServerClient
     {
-        public virtual async Task<LightningNodeInformationData> GetLightningNodeInfo(string storeId, string cryptoCode,
+        public async Task<LightningNodeInformationData> GetLightningNodeInfo(string storeId, string cryptoCode,
             CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(
@@ -18,7 +18,7 @@ namespace BTCPayServer.Client
             return await HandleResponse<LightningNodeInformationData>(response);
         }
 
-        public virtual async Task ConnectToLightningNode(string storeId, string cryptoCode, ConnectToNodeRequest request,
+        public async Task ConnectToLightningNode(string storeId, string cryptoCode, ConnectToNodeRequest request,
             CancellationToken token = default)
         {
             if (request == null)
@@ -29,7 +29,7 @@ namespace BTCPayServer.Client
             await HandleResponse(response);
         }
 
-        public virtual async Task<IEnumerable<LightningChannelData>> GetLightningNodeChannels(string storeId, string cryptoCode,
+        public async Task<IEnumerable<LightningChannelData>> GetLightningNodeChannels(string storeId, string cryptoCode,
             CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(
@@ -38,16 +38,16 @@ namespace BTCPayServer.Client
             return await HandleResponse<IEnumerable<LightningChannelData>>(response);
         }
 
-        public virtual async Task OpenLightningChannel(string storeId, string cryptoCode, OpenLightningChannelRequest request,
+        public async Task<string> OpenLightningChannel(string storeId, string cryptoCode, OpenLightningChannelRequest request,
             CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(
                 CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/channels", bodyPayload: request,
                     method: HttpMethod.Post), token);
-            await HandleResponse(response);
+            return await HandleResponse<string>(response);
         }
 
-        public virtual async Task<string> GetLightningDepositAddress(string storeId, string cryptoCode,
+        public async Task<string> GetLightningDepositAddress(string storeId, string cryptoCode,
             CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(
@@ -56,7 +56,7 @@ namespace BTCPayServer.Client
             return await HandleResponse<string>(response);
         }
 
-        public virtual async Task PayLightningInvoice(string storeId, string cryptoCode, PayLightningInvoiceRequest request,
+        public async Task PayLightningInvoice(string storeId, string cryptoCode, PayLightningInvoiceRequest request,
             CancellationToken token = default)
         {
             if (request == null)
@@ -67,7 +67,7 @@ namespace BTCPayServer.Client
             await HandleResponse(response);
         }
 
-        public virtual async Task<LightningInvoiceData> GetLightningInvoice(string storeId, string cryptoCode,
+        public async Task<LightningInvoiceData> GetLightningInvoice(string storeId, string cryptoCode,
             string invoiceId, CancellationToken token = default)
         {
             if (invoiceId == null)
@@ -78,7 +78,7 @@ namespace BTCPayServer.Client
             return await HandleResponse<LightningInvoiceData>(response);
         }
 
-        public virtual async Task<LightningInvoiceData> CreateLightningInvoice(string storeId, string cryptoCode,
+        public async Task<LightningInvoiceData> CreateLightningInvoice(string storeId, string cryptoCode,
             CreateLightningInvoiceRequest request, CancellationToken token = default)
         {
             if (request == null)

BTCPayServer.Client/BTCPayServerClient.LightningNetworkPaymentMethods.cs

@@ -9,19 +9,12 @@ namespace BTCPayServer.Client
     public partial class BTCPayServerClient
     {
         public virtual async Task<IEnumerable<LightningNetworkPaymentMethodData>>
-            GetStoreLightningNetworkPaymentMethods(string storeId, bool? enabled = null,
+            GetStoreLightningNetworkPaymentMethods(string storeId,
                 CancellationToken token = default)
         {
-            var query = new Dictionary<string, object>();
-            if (enabled != null)
-            {
-                query.Add(nameof(enabled), enabled);
-            }
-
             var response =
                 await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LightningNetwork",
-                        query), token);
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LightningNetwork"), token);
             return await HandleResponse<IEnumerable<LightningNetworkPaymentMethodData>>(response);
         }
 
@@ -47,7 +40,7 @@ namespace BTCPayServer.Client
 
         public virtual async Task<LightningNetworkPaymentMethodData> UpdateStoreLightningNetworkPaymentMethod(
             string storeId,
-            string cryptoCode, UpdateLightningNetworkPaymentMethodRequest paymentMethod,
+            string cryptoCode, LightningNetworkPaymentMethodData paymentMethod,
             CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(
@@ -55,5 +48,16 @@ namespace BTCPayServer.Client
                     bodyPayload: paymentMethod, method: HttpMethod.Put), token);
             return await HandleResponse<LightningNetworkPaymentMethodData>(response);
         }
+
+        public virtual async Task<LightningNetworkPaymentMethodData>
+            UpdateStoreLightningNetworkPaymentMethodToInternalNode(string storeId,
+                string cryptoCode, LightningNetworkPaymentMethodData paymentMethod,
+                CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LightningNetwork/{cryptoCode}/internal",
+                    method: HttpMethod.Put), token);
+            return await HandleResponse<LightningNetworkPaymentMethodData>(response);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.Misc.cs

@@ -1,23 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using BTCPayServer.Client.Models;
-
-namespace BTCPayServer.Client
-{
-    public partial class BTCPayServerClient
-    {
-        public virtual async Task<PermissionMetadata[]> GetPermissionMetadata(CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest("misc/permissions"), token);
-            return await HandleResponse<PermissionMetadata[]>(response);
-        }
-        public virtual async Task<Language[]> GetAvailableLanguages(CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest("misc/lang"), token);
-            return await HandleResponse<Language[]>(response);
-        }
-    }
-}

BTCPayServer.Client/BTCPayServerClient.OnChainPaymentMethods.cs

@@ -9,19 +9,11 @@ namespace BTCPayServer.Client
     public partial class BTCPayServerClient
     {
         public virtual async Task<IEnumerable<OnChainPaymentMethodData>> GetStoreOnChainPaymentMethods(string storeId,
-            bool? enabled = null,
             CancellationToken token = default)
         {
-            var query = new Dictionary<string, object>();
-            if (enabled != null)
-            {
-                query.Add(nameof(enabled), enabled);
-            }
-
             var response =
                 await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/Onchain",
-                        query), token);
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/Onchain"), token);
             return await HandleResponse<IEnumerable<OnChainPaymentMethodData>>(response);
         }
 
@@ -45,7 +37,7 @@ namespace BTCPayServer.Client
         }
 
         public virtual async Task<OnChainPaymentMethodData> UpdateStoreOnChainPaymentMethod(string storeId,
-            string cryptoCode, UpdateOnChainPaymentMethodRequest paymentMethod,
+            string cryptoCode, OnChainPaymentMethodData paymentMethod,
             CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(
@@ -56,7 +48,7 @@ namespace BTCPayServer.Client
 
         public virtual async Task<OnChainPaymentMethodPreviewResultData>
             PreviewProposedStoreOnChainPaymentMethodAddresses(
-                string storeId, string cryptoCode, UpdateOnChainPaymentMethodRequest paymentMethod, int offset = 0,
+                string storeId, string cryptoCode, OnChainPaymentMethodData paymentMethod, int offset = 0,
                 int amount = 10,
                 CancellationToken token = default)
         {
@@ -78,17 +70,5 @@ namespace BTCPayServer.Client
                     method: HttpMethod.Get), token);
             return await HandleResponse<OnChainPaymentMethodPreviewResultData>(response);
         }
-        
-        public virtual async Task<OnChainPaymentMethodDataWithSensitiveData> GenerateOnChainWallet(string storeId,
-            string cryptoCode, GenerateOnChainWalletRequest request,
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/Onchain/{cryptoCode}/generate",
-                    bodyPayload: request,
-                    method: HttpMethod.Post), token);
-            return await HandleResponse<OnChainPaymentMethodDataWithSensitiveData>(response);
-        }
-
     }
 }

BTCPayServer.Client/BTCPayServerClient.PullPayments.cs

@@ -9,18 +9,18 @@ namespace BTCPayServer.Client
 {
     public partial class BTCPayServerClient
     {
-        public virtual async Task<PullPaymentData> CreatePullPayment(string storeId, CreatePullPaymentRequest request, CancellationToken cancellationToken = default)
+        public async Task<PullPaymentData> CreatePullPayment(string storeId, CreatePullPaymentRequest request, CancellationToken cancellationToken = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/pull-payments", bodyPayload: request, method: HttpMethod.Post), cancellationToken);
             return await HandleResponse<PullPaymentData>(response);
         }
-        public virtual async Task<PullPaymentData> GetPullPayment(string pullPaymentId, CancellationToken cancellationToken = default)
+        public async Task<PullPaymentData> GetPullPayment(string pullPaymentId, CancellationToken cancellationToken = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}", method: HttpMethod.Get), cancellationToken);
             return await HandleResponse<PullPaymentData>(response);
         }
 
-        public virtual async Task<PullPaymentData[]> GetPullPayments(string storeId, bool includeArchived = false, CancellationToken cancellationToken = default)
+        public async Task<PullPaymentData[]> GetPullPayments(string storeId, bool includeArchived = false, CancellationToken cancellationToken = default)
         {
             Dictionary<string, object> query = new Dictionary<string, object>();
             query.Add("includeArchived", includeArchived);
@@ -28,44 +28,34 @@ namespace BTCPayServer.Client
             return await HandleResponse<PullPaymentData[]>(response);
         }
 
-        public virtual async Task ArchivePullPayment(string storeId, string pullPaymentId, CancellationToken cancellationToken = default)
+        public async Task ArchivePullPayment(string storeId, string pullPaymentId, CancellationToken cancellationToken = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}", method: HttpMethod.Delete), cancellationToken);
             await HandleResponse(response);
         }
 
-        public virtual async Task<PayoutData[]> GetPayouts(string pullPaymentId, bool includeCancelled = false, CancellationToken cancellationToken = default)
+        public async Task<PayoutData[]> GetPayouts(string pullPaymentId, bool includeCancelled = false, CancellationToken cancellationToken = default)
         {
             Dictionary<string, object> query = new Dictionary<string, object>();
             query.Add("includeCancelled", includeCancelled);
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}/payouts", queryPayload: query, method: HttpMethod.Get), cancellationToken);
             return await HandleResponse<PayoutData[]>(response);
         }
-        public virtual async Task<PayoutData> CreatePayout(string pullPaymentId, CreatePayoutRequest payoutRequest, CancellationToken cancellationToken = default)
+        public async Task<PayoutData> CreatePayout(string pullPaymentId, CreatePayoutRequest payoutRequest, CancellationToken cancellationToken = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}/payouts", bodyPayload: payoutRequest, method: HttpMethod.Post), cancellationToken);
             return await HandleResponse<PayoutData>(response);
         }
 
-        public virtual async Task CancelPayout(string storeId, string payoutId, CancellationToken cancellationToken = default)
+        public async Task CancelPayout(string storeId, string payoutId, CancellationToken cancellationToken = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/payouts/{HttpUtility.UrlEncode(payoutId)}", method: HttpMethod.Delete), cancellationToken);
             await HandleResponse(response);
         }
-        public virtual async Task<PayoutData> ApprovePayout(string storeId, string payoutId, ApprovePayoutRequest request, CancellationToken cancellationToken = default)
+        public async Task<PayoutData> ApprovePayout(string storeId, string payoutId, ApprovePayoutRequest request, CancellationToken cancellationToken = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/payouts/{HttpUtility.UrlEncode(payoutId)}", bodyPayload: request, method: HttpMethod.Post), cancellationToken);
             return await HandleResponse<PayoutData>(response);
         }
-
-        public async Task MarkPayoutPaid(string storeId, string payoutId,
-            CancellationToken cancellationToken = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest(
-                    $"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/payouts/{HttpUtility.UrlEncode(payoutId)}/mark-paid",
-                    method: HttpMethod.Post), cancellationToken);
-            await HandleResponse(response);
-        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.StorePaymentMethods.cs

@@ -1,27 +0,0 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using BTCPayServer.Client.Models;
-
-namespace BTCPayServer.Client
-{
-    public partial class BTCPayServerClient
-    {
-        public virtual async Task<Dictionary<string, GenericPaymentMethodData>> GetStorePaymentMethods(string storeId,
-            bool? enabled = null,
-            CancellationToken token = default)
-        {
-            var query = new Dictionary<string, object>();
-            if (enabled != null)
-            {
-                query.Add(nameof(enabled), enabled);
-            }
-
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods",
-                        query), token);
-            return await HandleResponse<Dictionary<string, GenericPaymentMethodData>>(response);
-        }
-    }
-}

BTCPayServer.Client/BTCPayServerClient.Users.cs

@@ -1,4 +1,3 @@
-#nullable enable
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
@@ -20,16 +19,5 @@ namespace BTCPayServer.Client
             var response = await _httpClient.SendAsync(CreateHttpRequest("api/v1/users", null, request, HttpMethod.Post), token);
             return await HandleResponse<ApplicationUserData>(response);
         }
-
-        public virtual async Task DeleteUser(string userId, CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/users/{userId}", null, HttpMethod.Delete), token);
-            await HandleResponse(response);
-        }
-
-        public virtual async Task DeleteCurrentUser(CancellationToken token = default)
-        {
-            await DeleteUser("me", token);
-        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.Webhooks.cs

@@ -1,58 +1,60 @@
+using System;
+using System.Collections.Generic;
 using System.Net.Http;
+using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
+using Newtonsoft.Json.Linq;
 
 namespace BTCPayServer.Client
 {
     public partial class BTCPayServerClient
     {
-        public virtual async Task<StoreWebhookData> CreateWebhook(string storeId, Client.Models.CreateStoreWebhookRequest create, CancellationToken token = default)
+        public async Task<StoreWebhookData> CreateWebhook(string storeId, Client.Models.CreateStoreWebhookRequest create, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/webhooks", bodyPayload: create, method: HttpMethod.Post), token);
             return await HandleResponse<StoreWebhookData>(response);
         }
-        public virtual async Task<StoreWebhookData> GetWebhook(string storeId, string webhookId, CancellationToken token = default)
+        public async Task<StoreWebhookData> GetWebhook(string storeId, string webhookId, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/webhooks/{webhookId}"), token);
             if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
                 return null;
             return await HandleResponse<StoreWebhookData>(response);
         }
-        public virtual async Task<StoreWebhookData> UpdateWebhook(string storeId, string webhookId, Models.UpdateStoreWebhookRequest update, CancellationToken token = default)
+        public async Task<StoreWebhookData> UpdateWebhook(string storeId, string webhookId, Models.UpdateStoreWebhookRequest update, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/webhooks/{webhookId}", bodyPayload: update, method: HttpMethod.Put), token);
             return await HandleResponse<StoreWebhookData>(response);
         }
-        public virtual async Task<bool> DeleteWebhook(string storeId, string webhookId, CancellationToken token = default)
+        public async Task<bool> DeleteWebhook(string storeId, string webhookId, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/webhooks/{webhookId}", method: HttpMethod.Delete), token);
             return response.IsSuccessStatusCode;
         }
-        public virtual async Task<StoreWebhookData[]> GetWebhooks(string storeId, CancellationToken token = default)
+        public async Task<StoreWebhookData[]> GetWebhooks(string storeId, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/webhooks"), token);
             return await HandleResponse<StoreWebhookData[]>(response);
         }
-        public virtual async Task<WebhookDeliveryData[]> GetWebhookDeliveries(string storeId, string webhookId, CancellationToken token = default)
+        public async Task<WebhookDeliveryData[]> GetWebhookDeliveries(string storeId, string webhookId, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/webhooks/{webhookId}/deliveries"), token);
             return await HandleResponse<WebhookDeliveryData[]>(response);
         }
-        public virtual async Task<WebhookDeliveryData> GetWebhookDelivery(string storeId, string webhookId, string deliveryId, CancellationToken token = default)
+        public async Task<WebhookDeliveryData> GetWebhookDelivery(string storeId, string webhookId, string deliveryId, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/webhooks/{webhookId}/deliveries/{deliveryId}"), token);
-            if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
-                return null;
             return await HandleResponse<WebhookDeliveryData>(response);
         }
-        public virtual async Task<string> RedeliverWebhook(string storeId, string webhookId, string deliveryId, CancellationToken token = default)
+        public async Task<string> RedeliverWebhook(string storeId, string webhookId, string deliveryId, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/webhooks/{webhookId}/deliveries/{deliveryId}/redeliver", null, HttpMethod.Post), token);
             return await HandleResponse<string>(response);
         }
 
-        public virtual async Task<WebhookEvent> GetWebhookDeliveryRequest(string storeId, string webhookId, string deliveryId, CancellationToken token = default)
+        public async Task<WebhookEvent> GetWebhookDeliveryRequest(string storeId, string webhookId, string deliveryId, CancellationToken token = default)
         {
             var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/webhooks/{webhookId}/deliveries/{deliveryId}/request"), token);
             if (response.StatusCode == System.Net.HttpStatusCode.NotFound)

BTCPayServer.Client/BTCPayServerClient.cs

@@ -5,7 +5,6 @@ using System.Linq;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Text;
-using System.Threading;
 using System.Threading.Tasks;
 using Newtonsoft.Json;
 
@@ -70,13 +69,6 @@ namespace BTCPayServer.Client
             return JsonConvert.DeserializeObject<T>(str);
         }
 
-        public async Task<T> SendHttpRequest<T>(string path,
-            Dictionary<string, object> queryPayload = null,
-            HttpMethod method = null, CancellationToken cancellationToken = default)
-        {
-            using var resp = await _httpClient.SendAsync(CreateHttpRequest(path, queryPayload, method), cancellationToken);
-            return await HandleResponse<T>(resp);
-        }
         protected virtual HttpRequestMessage CreateHttpRequest(string path,
             Dictionary<string, object> queryPayload = null,
             HttpMethod method = null)

BTCPayServer.Client/JsonConverters/MnemonicJsonConverter.cs

@@ -1,31 +0,0 @@
-using System;
-using NBitcoin;
-using NBitcoin.JsonConverters;
-using Newtonsoft.Json;
-
-namespace BTCPayServer.Client.JsonConverters
-{
-    public class MnemonicJsonConverter : JsonConverter<Mnemonic>
-    {
-        public override Mnemonic ReadJson(JsonReader reader, Type objectType, Mnemonic existingValue, bool hasExistingValue,
-            JsonSerializer serializer)
-        {
-            return reader.TokenType switch
-            {
-                JsonToken.String => new Mnemonic((string)reader.Value),
-                JsonToken.Null => null,
-                _ => throw new JsonObjectException(reader.Path, "Mnemonic must be a json string")
-            };
-        }
-
-        public override void WriteJson(JsonWriter writer, Mnemonic value, JsonSerializer serializer)
-        {
-            if (value != null)
-                writer.WriteValue(value.ToString());
-            else
-            {
-                writer.WriteNull();
-            }
-        }
-    }
-}

BTCPayServer.Client/JsonConverters/NumericStringJsonConverter.cs

@@ -22,17 +22,13 @@ namespace BTCPayServer.JsonConverters
             switch (token.Type)
             {
                 case JTokenType.Float:
-                    if (objectType == typeof(decimal) || objectType == typeof(decimal?))
-                        return token.Value<decimal>();
-                    if (objectType == typeof(double) || objectType == typeof(double?))
-                        return token.Value<double>();
-                    throw new JsonSerializationException("Unexpected object type: " + objectType);
                 case JTokenType.Integer:
                 case JTokenType.String:
                     if (objectType == typeof(decimal) || objectType == typeof(decimal?) )
                         return decimal.Parse(token.ToString(), CultureInfo.InvariantCulture);
                     if (objectType == typeof(double) || objectType == typeof(double?))
                         return double.Parse(token.ToString(), CultureInfo.InvariantCulture);
+
                     throw new JsonSerializationException("Unexpected object type: " + objectType);
                 case JTokenType.Null when objectType == typeof(decimal?) || objectType == typeof(double?):
                     return null;

BTCPayServer.Client/JsonConverters/WordcountJsonConverter.cs

@@ -1,59 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using NBitcoin;
-using Newtonsoft.Json;
-
-public class WordcountJsonConverter : JsonConverter
-{
-    static WordcountJsonConverter()
-    {
-        _Wordcount = new Dictionary<long, WordCount>()
-        {
-            {18, WordCount.Eighteen},
-            {15, WordCount.Fifteen},
-            {12, WordCount.Twelve},
-            {24, WordCount.TwentyFour},
-            {21, WordCount.TwentyOne}
-        };
-        _WordcountReverse = _Wordcount.ToDictionary(kv => kv.Value, kv => kv.Key);
-    }
-
-    public override bool CanConvert(Type objectType)
-    {
-        return typeof(NBitcoin.WordCount).GetTypeInfo().IsAssignableFrom(objectType.GetTypeInfo()) ||
-               typeof(NBitcoin.WordCount?).GetTypeInfo().IsAssignableFrom(objectType.GetTypeInfo());
-    }
-
-    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
-    {
-        if (reader.TokenType == JsonToken.Null)
-            return default;
-        if (reader.TokenType != JsonToken.Integer)
-            throw new NBitcoin.JsonConverters.JsonObjectException(
-                $"Unexpected json token type, expected Integer, actual {reader.TokenType}", reader);
-        if (!_Wordcount.TryGetValue((long)reader.Value, out var result))
-            throw new NBitcoin.JsonConverters.JsonObjectException(
-                $"Invalid WordCount, possible values {string.Join(", ", _Wordcount.Keys.ToArray())} (default: 12)",
-                reader);
-        return result;
-    }
-
-    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
-    {
-        if (value is WordCount wc)
-            writer.WriteValue(_WordcountReverse[wc]);
-    }
-
-    readonly static Dictionary<long, WordCount> _Wordcount = new Dictionary<long, WordCount>()
-    {
-        {18, WordCount.Eighteen},
-        {15, WordCount.Fifteen},
-        {12, WordCount.Twelve},
-        {24, WordCount.TwentyFour},
-        {21, WordCount.TwentyOne}
-    };
-
-    readonly static Dictionary<WordCount, long> _WordcountReverse;
-}

BTCPayServer.Client/JsonConverters/WordlistJsonConverter.cs

@@ -1,55 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using NBitcoin;
-using Newtonsoft.Json;
-
-public class WordlistJsonConverter : JsonConverter
-{
-    static WordlistJsonConverter()
-    {
-
-        _Wordlists = new Dictionary<string, Wordlist>(StringComparer.OrdinalIgnoreCase)
-        {
-            {"English", Wordlist.English},
-            {"Japanese", Wordlist.Japanese},
-            {"Spanish", Wordlist.Spanish},
-            {"ChineseSimplified", Wordlist.ChineseSimplified},
-            {"ChineseTraditional", Wordlist.ChineseTraditional},
-            {"French", Wordlist.French},
-            {"PortugueseBrazil", Wordlist.PortugueseBrazil},
-            {"Czech", Wordlist.Czech}
-        };
-            
-        _WordlistsReverse = _Wordlists.ToDictionary(kv => kv.Value, kv => kv.Key);
-    }
-
-    public override bool CanConvert(Type objectType)
-    {
-        return typeof(Wordlist).GetTypeInfo().IsAssignableFrom(objectType.GetTypeInfo());
-    }
-
-    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
-    {
-        if (reader.TokenType == JsonToken.Null)
-            return null;
-        if (reader.TokenType != JsonToken.String)
-            throw new NBitcoin.JsonConverters.JsonObjectException(
-                $"Unexpected json token type, expected String, actual {reader.TokenType}", reader);
-        if (!_Wordlists.TryGetValue((string)reader.Value, out var result))
-            throw new NBitcoin.JsonConverters.JsonObjectException(
-                $"Invalid wordlist, possible values {string.Join(", ", _Wordlists.Keys.ToArray())} (default: English)",
-                reader);
-        return result;
-    }
-
-    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
-    {
-        if (value is Wordlist wl)
-            writer.WriteValue(_WordlistsReverse[wl]);
-    }
-
-    readonly static Dictionary<string, Wordlist> _Wordlists;
-    readonly static Dictionary<Wordlist, string> _WordlistsReverse;
-}

BTCPayServer.Client/Models/CreateInvoiceRequest.cs

@@ -1,12 +1,41 @@
+using System;
+using BTCPayServer.Client.JsonConverters;
 using BTCPayServer.JsonConverters;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+using Newtonsoft.Json.Linq;
 
 namespace BTCPayServer.Client.Models
 {
-    public class CreateInvoiceRequest : InvoiceDataBase
+    public class CreateInvoiceRequest
     {
         [JsonConverter(typeof(NumericStringJsonConverter))]
-        public decimal? Amount { get; set; }
-        public string[] AdditionalSearchTerms { get; set; }
+        public decimal Amount { get; set; }
+        public string Currency { get; set; }
+        public JObject Metadata { get; set; }
+        public CheckoutOptions Checkout { get; set; } = new CheckoutOptions();
+
+        public class CheckoutOptions
+        {
+
+            [JsonConverter(typeof(StringEnumConverter))]
+            public SpeedPolicy? SpeedPolicy { get; set; }
+
+            public string[] PaymentMethods { get; set; }
+
+            [JsonConverter(typeof(TimeSpanJsonConverter.Minutes))]
+            [JsonProperty("expirationMinutes")]
+            public TimeSpan? Expiration { get; set; }
+            [JsonConverter(typeof(TimeSpanJsonConverter.Minutes))]
+            [JsonProperty("monitoringMinutes")]
+            public TimeSpan? Monitoring { get; set; }
+
+            public double? PaymentTolerance { get; set; }
+            [JsonProperty("redirectURL")]
+            public string RedirectURL { get; set; }
+
+            public bool? RedirectAutomatically { get; set; }
+            public string DefaultLanguage { get; set; }
+        }
     }
 }

BTCPayServer.Client/Models/GenerateOnChainWalletRequest.cs

@@ -1,25 +0,0 @@
-using BTCPayServer.Client.JsonConverters;
-using NBitcoin;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Converters;
-
-namespace BTCPayServer.Client
-{
-    public class GenerateOnChainWalletRequest
-    {
-        public int AccountNumber { get; set; } = 0;
-        [JsonConverter(typeof(MnemonicJsonConverter))]	
-        public Mnemonic ExistingMnemonic { get; set; }
-        [JsonConverter(typeof(WordlistJsonConverter))]
-        public NBitcoin.Wordlist WordList { get; set; }
-
-        [JsonConverter(typeof(WordcountJsonConverter))]
-        public NBitcoin.WordCount? WordCount { get; set; } = NBitcoin.WordCount.Twelve;
-
-        [JsonConverter(typeof(StringEnumConverter))]
-        public NBitcoin.ScriptPubKeyType ScriptPubKeyType { get; set; } = ScriptPubKeyType.Segwit;
-        public string Passphrase { get; set; }
-        public bool ImportKeysToRPC { get; set; }
-        public bool SavePrivateKeys { get; set; }
-    }
-}

BTCPayServer.Client/Models/GenericPaymentMethodData.cs

@@ -1,9 +0,0 @@
-namespace BTCPayServer.Client.Models
-{
-    public class GenericPaymentMethodData
-    {
-        public bool Enabled { get; set; }
-        public object Data { get; set; }
-        public string CryptoCode { get; set; }
-    }
-}

BTCPayServer.Client/Models/InvoiceData.cs

@@ -1,55 +1,12 @@
 using System;
-using BTCPayServer.Client.JsonConverters;
-using BTCPayServer.JsonConverters;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
-using Newtonsoft.Json.Linq;
 
 namespace BTCPayServer.Client.Models
 {
-    public enum InvoiceType
-    {
-        Standard,
-        TopUp
-    }
-    public class InvoiceDataBase
-    {
-        [JsonConverter(typeof(StringEnumConverter))]
-        public InvoiceType Type { get; set; }
-        public string Currency { get; set; }
-        public JObject Metadata { get; set; }
-        public CheckoutOptions Checkout { get; set; } = new CheckoutOptions();
-        public class CheckoutOptions
-        {
-
-            [JsonConverter(typeof(StringEnumConverter))]
-            public SpeedPolicy? SpeedPolicy { get; set; }
-
-            public string[] PaymentMethods { get; set; }
-            public string DefaultPaymentMethod { get; set; }
-
-            [JsonConverter(typeof(TimeSpanJsonConverter.Minutes))]
-            [JsonProperty("expirationMinutes")]
-            public TimeSpan? Expiration { get; set; }
-            [JsonConverter(typeof(TimeSpanJsonConverter.Minutes))]
-            [JsonProperty("monitoringMinutes")]
-            public TimeSpan? Monitoring { get; set; }
-
-            public double? PaymentTolerance { get; set; }
-            [JsonProperty("redirectURL")]
-            public string RedirectURL { get; set; }
-
-            public bool? RedirectAutomatically { get; set; }
-            public bool? RequiresRefundEmail { get; set; } = null;
-            public string DefaultLanguage { get; set; }
-        }
-    }
-    public class InvoiceData : InvoiceDataBase
+    public class InvoiceData : CreateInvoiceRequest
     {
         public string Id { get; set; }
-        public string StoreId { get; set; }
-        [JsonConverter(typeof(NumericStringJsonConverter))]
-        public decimal Amount { get; set; }
         public string CheckoutLink { get; set; }
         [JsonConverter(typeof(StringEnumConverter))]
         public InvoiceStatus Status { get; set; }
@@ -61,9 +18,6 @@ namespace BTCPayServer.Client.Models
         public DateTimeOffset ExpirationTime { get; set; }
         [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
         public DateTimeOffset CreatedTime { get; set; }
-        [JsonProperty(ItemConverterType = typeof(StringEnumConverter))]
-        public InvoiceStatus[] AvailableStatusesForManualMarking { get; set; }
-        public bool Archived { get; set; }
     }
     public enum InvoiceStatus
     {

BTCPayServer.Client/Models/LNURLPayPaymentMethodBaseData.cs

@@ -1,14 +0,0 @@
-namespace BTCPayServer.Client.Models
-{
-    public class LNURLPayPaymentMethodBaseData
-    {
-        public bool UseBech32Scheme { get; set; }
-        public bool EnableForStandardInvoices { get; set; }
-        public bool LUD12Enabled { get; set; }
-
-        public LNURLPayPaymentMethodBaseData()
-        {
-            
-        }
-    }
-}

BTCPayServer.Client/Models/LNURLPayPaymentMethodData.cs

@@ -1,27 +0,0 @@
-namespace BTCPayServer.Client.Models
-{
-    public class LNURLPayPaymentMethodData: LNURLPayPaymentMethodBaseData
-    {
-        /// <summary>
-        /// Whether the payment method is enabled
-        /// </summary>
-        public bool Enabled { get; set; }
-
-        /// <summary>
-        /// Crypto code of the payment method
-        /// </summary>
-        public string CryptoCode { get; set; }
-
-        public LNURLPayPaymentMethodData()
-        {
-        }
-
-        public LNURLPayPaymentMethodData(string cryptoCode, bool enabled,  bool useBech32Scheme, bool enableForStandardInvoices)
-        {
-            Enabled = enabled;
-            CryptoCode = cryptoCode;
-            UseBech32Scheme = useBech32Scheme;
-            EnableForStandardInvoices = enableForStandardInvoices;
-        }
-    }
-}

BTCPayServer.Client/Models/Language.cs

@@ -1,21 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using Newtonsoft.Json;
-
-namespace BTCPayServer.Client.Models
-{
-    public class Language
-    {
-        public Language(string code, string displayName)
-        {
-            DisplayName = displayName;
-            Code = code;
-        }
-
-        [JsonProperty("code")]
-        public string Code { get; set; }
-        [JsonProperty("currentLanguage")]
-        public string DisplayName { get; set; }
-    }
-}

BTCPayServer.Client/Models/LightningNetworkPaymentMethodBaseData.cs

@@ -1,13 +0,0 @@
-namespace BTCPayServer.Client.Models
-{
-    public class LightningNetworkPaymentMethodBaseData
-    {
-
-        public string ConnectionString { get; set; }
-        public bool DisableBOLT11PaymentOption { get; set; }
-        public LightningNetworkPaymentMethodBaseData()
-        {
-            
-        }
-    }
-}

BTCPayServer.Client/Models/LightningNetworkPaymentMethodData.cs

@@ -1,6 +1,6 @@
 namespace BTCPayServer.Client.Models
 {
-    public class LightningNetworkPaymentMethodData: LightningNetworkPaymentMethodBaseData
+    public class LightningNetworkPaymentMethodData
     {
         /// <summary>
         /// Whether the payment method is enabled
@@ -12,19 +12,17 @@ namespace BTCPayServer.Client.Models
         /// </summary>
         public string CryptoCode { get; set; }
 
+        public string ConnectionString { get; set; }
+
         public LightningNetworkPaymentMethodData()
         {
         }
 
-        public LightningNetworkPaymentMethodData(string cryptoCode, string connectionString, bool enabled, string paymentMethod, bool disableBOLT11PaymentOption)
+        public LightningNetworkPaymentMethodData(string cryptoCode, string connectionString, bool enabled)
         {
             Enabled = enabled;
             CryptoCode = cryptoCode;
             ConnectionString = connectionString;
-            PaymentMethod = paymentMethod;
-            DisableBOLT11PaymentOption = disableBOLT11PaymentOption;
         }
-
-        public string PaymentMethod { get; set; }
     }
 }

BTCPayServer.Client/Models/OnChainPaymentMethodBaseData.cs

@@ -1,24 +0,0 @@
-using NBitcoin;
-using Newtonsoft.Json;
-
-namespace BTCPayServer.Client.Models
-{
-    public class OnChainPaymentMethodBaseData
-    {
-        /// <summary>
-        /// The derivation scheme
-        /// </summary>
-        public string DerivationScheme { get; set; }
-
-        public string Label { get; set; }
-
-        [JsonConverter(typeof(NBitcoin.JsonConverters.KeyPathJsonConverter))]
-        public RootedKeyPath AccountKeyPath { get; set; }
-
-        public OnChainPaymentMethodBaseData()
-        {
-        }
-
-        
-    }
-}

BTCPayServer.Client/Models/OnChainPaymentMethodData.cs

@@ -1,47 +1,39 @@
 using NBitcoin;
+using Newtonsoft.Json;
 
 namespace BTCPayServer.Client.Models
 {
-    public class OnChainPaymentMethodDataPreview : OnChainPaymentMethodBaseData
-    {
-        /// <summary>
-        /// Crypto code of the payment method
-        /// </summary>
-        public string CryptoCode { get; set; }
-
-        public OnChainPaymentMethodDataPreview()
-        {
-            
-        }
-
-        public OnChainPaymentMethodDataPreview(string cryptoCode, string derivationScheme, string label, RootedKeyPath accountKeyPath)
-        {
-            Label = label;
-            AccountKeyPath = accountKeyPath;
-            CryptoCode = cryptoCode;
-            DerivationScheme = derivationScheme;
-        }
-    }
-
-    public class OnChainPaymentMethodData : OnChainPaymentMethodDataPreview
+    public class OnChainPaymentMethodData
     {
         /// <summary>
         /// Whether the payment method is enabled
         /// </summary>
         public bool Enabled { get; set; }
 
-        public string PaymentMethod { get; set; }
+        /// <summary>
+        /// Crypto code of the payment method
+        /// </summary>
+        public string CryptoCode { get; set; }
+
+        /// <summary>
+        /// The derivation scheme
+        /// </summary>
+        public string DerivationScheme { get; set; }
+
+        public string Label { get; set; }
+
+        [JsonConverter(typeof(NBitcoin.JsonConverters.KeyPathJsonConverter))]
+        public RootedKeyPath AccountKeyPath { get; set; }
 
         public OnChainPaymentMethodData()
         {
-            
         }
 
-        public OnChainPaymentMethodData(string cryptoCode, string derivationScheme, bool enabled, string label, RootedKeyPath accountKeyPath, string paymentMethod) :
-            base(cryptoCode, derivationScheme, label, accountKeyPath)
+        public OnChainPaymentMethodData(string cryptoCode, string derivationScheme, bool enabled)
         {
             Enabled = enabled;
-            PaymentMethod = paymentMethod;
+            CryptoCode = cryptoCode;
+            DerivationScheme = derivationScheme;
         }
     }
 }

BTCPayServer.Client/Models/OnChainPaymentMethodDataWithSensitiveData.cs

@@ -1,23 +0,0 @@
-using BTCPayServer.Client.JsonConverters;
-using NBitcoin;
-using Newtonsoft.Json;
-
-namespace BTCPayServer.Client.Models
-{
-    public class OnChainPaymentMethodDataWithSensitiveData : OnChainPaymentMethodData
-    {
-        public OnChainPaymentMethodDataWithSensitiveData()
-        {
-        }
-
-        public OnChainPaymentMethodDataWithSensitiveData(string cryptoCode, string derivationScheme, bool enabled,
-            string label, RootedKeyPath accountKeyPath, Mnemonic mnemonic, string paymentMethod) : base(cryptoCode, derivationScheme, enabled,
-            label, accountKeyPath, paymentMethod)
-        {
-            Mnemonic = mnemonic;
-        }
-
-        [JsonConverter(typeof(MnemonicJsonConverter))]
-        public Mnemonic Mnemonic { get; set; }
-    }
-}

BTCPayServer.Client/Models/OnChainWalletUTXOData.cs

@@ -21,6 +21,5 @@ namespace BTCPayServer.Client.Models
         [JsonConverter(typeof(KeyPathJsonConverter))]
         public KeyPath KeyPath { get; set; }
         public string Address { get; set; }
-        public int Confirmations { get; set; }
     }
 }

BTCPayServer.Client/Models/PermissionMetadata.cs

@@ -1,40 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Newtonsoft.Json;
-
-namespace BTCPayServer.Client.Models
-{
-    public class PermissionMetadata
-    {
-        static PermissionMetadata()
-        {
-            Dictionary<string, PermissionMetadata> nodes = new Dictionary<string, PermissionMetadata>();
-            foreach (var policy in Client.Policies.AllPolicies)
-            {
-                nodes.Add(policy, new PermissionMetadata() { PermissionName = policy });
-            }
-            foreach (var n in nodes)
-            {
-                foreach (var policy in Client.Policies.AllPolicies)
-                {
-                    if (policy.Equals(n.Key, StringComparison.OrdinalIgnoreCase))
-                        continue;
-                    if (Client.Permission.Create(n.Key).Contains(Client.Permission.Create(policy)))
-                        n.Value.SubPermissions.Add(policy);
-                }
-            }
-            foreach (var n in nodes)
-            {
-                n.Value.SubPermissions.Sort();
-            }
-            PermissionNodes = nodes.Values.OrderBy(v => v.PermissionName).ToArray();
-        }
-        public readonly static PermissionMetadata[] PermissionNodes;
-        [JsonProperty("name")]
-        public string PermissionName { get; set; }
-        [JsonProperty("included")]
-        public List<string> SubPermissions { get; set; } = new List<string>();
-    }
-}

BTCPayServer.Client/Models/ServerInfoData.cs

@@ -27,17 +27,12 @@ namespace BTCPayServer.Client.Models
         /// <summary>
         /// detailed sync information per chain
         /// </summary>
-        public IEnumerable<SyncStatus> SyncStatus { get; set; }
-    }
-    
-    public class SyncStatus
-    {
-        public string CryptoCode { get; set; }
-        public virtual bool Available { get; set; }
+        public IEnumerable<ServerInfoSyncStatusData> SyncStatus { get; set; }
     }
 
-    public class ServerInfoSyncStatusData: SyncStatus
+    public class ServerInfoSyncStatusData
     {
+        public string CryptoCode { get; set; }
         public int ChainHeight { get; set; }
         public int? SyncHeight { get; set; }
         public ServerInfoNodeData NodeInformation { get; set; }

BTCPayServer.Client/Models/StoreBaseData.cs

@@ -29,7 +29,8 @@ namespace BTCPayServer.Client.Models
         public string LightningDescriptionTemplate { get; set; }
         public double PaymentTolerance { get; set; } = 0;
         public bool AnyoneCanCreateInvoice { get; set; }
-        public string DefaultCurrency { get; set; }
+
+
         public bool RequiresRefundEmail { get; set; }
         public bool LightningAmountInSatoshi { get; set; }
         public bool LightningPrivateRouteHints { get; set; }

BTCPayServer.Client/Models/UpdateLightningNetworkPaymentMethodRequest.cs

@@ -1,20 +0,0 @@
-namespace BTCPayServer.Client.Models
-{
-    public class UpdateLightningNetworkPaymentMethodRequest: LightningNetworkPaymentMethodBaseData
-    {
-        /// <summary>
-        /// Whether the payment method is enabled
-        /// </summary>
-        public bool Enabled { get; set; }
-
-        public UpdateLightningNetworkPaymentMethodRequest()
-        {
-        }
-
-        public UpdateLightningNetworkPaymentMethodRequest(string connectionString, bool enabled)
-        {
-            Enabled = enabled;
-            ConnectionString = connectionString;
-        }
-    }
-}

BTCPayServer.Client/Models/UpdateOnChainPaymentMethodRequest.cs

@@ -1,25 +0,0 @@
-using NBitcoin;
-
-namespace BTCPayServer.Client.Models
-{
-    public class UpdateOnChainPaymentMethodRequest : OnChainPaymentMethodBaseData
-    {
-        /// <summary>
-        /// Whether the payment method is enabled
-        /// </summary>
-        public bool Enabled { get; set; }
-
-        public UpdateOnChainPaymentMethodRequest()
-        {
-            
-        }
-
-        public UpdateOnChainPaymentMethodRequest(bool enabled, string derivationScheme, string label, RootedKeyPath accountKeyPath)
-        {
-            Enabled = enabled;
-            Label = label;
-            AccountKeyPath = accountKeyPath;
-            DerivationScheme = derivationScheme;
-        }
-    }
-}

BTCPayServer.Client/Models/WebhookEvent.cs

@@ -19,31 +19,7 @@ namespace BTCPayServer.Client.Models
         }
         public string DeliveryId { get; set; }
         public string WebhookId { get; set; }
-        string _OriginalDeliveryId;
-        public string OriginalDeliveryId
-        {
-            get
-            {
-                if (_OriginalDeliveryId is null)
-                {
-                    // Due to a typo in old version, we serialized `orignalDeliveryId` rather than `orignalDeliveryId`
-                    // We silently fix that here.
-                    // Note we can remove this code later on, as old webhook event are unlikely to be useful to anyone,
-                    // and having a null orignalDeliveryId is not end of the world
-                    if (AdditionalData != null &&
-                        AdditionalData.TryGetValue("orignalDeliveryId", out var tok))
-                    {
-                        _OriginalDeliveryId = tok.Value<string>();
-                        AdditionalData.Remove("orignalDeliveryId");
-                    }
-                }
-                return _OriginalDeliveryId;
-            }
-            set
-            {
-                _OriginalDeliveryId = value;
-            }
-        }
+        public string OrignalDeliveryId { get; set; }
         public bool IsRedelivery { get; set; }
         [JsonConverter(typeof(StringEnumConverter))]
         public WebhookEventType Type { get; set; }

BTCPayServer.Client/Models/WebhookEventType.cs

@@ -11,7 +11,6 @@ namespace BTCPayServer.Client.Models
         InvoiceProcessing,
         InvoiceExpired,
         InvoiceSettled,
-        InvoiceInvalid,
-        InvoicePaymentSettled,
+        InvoiceInvalid
     }
 }

BTCPayServer.Client/Models/WebhookInvoiceEvent.cs

@@ -10,89 +10,72 @@ namespace BTCPayServer.Client.Models
     {
         public WebhookInvoiceEvent()
         {
-        }
 
+        }
         public WebhookInvoiceEvent(WebhookEventType evtType)
         {
             this.Type = evtType;
         }
-
-        [JsonProperty(Order = 1)] public string StoreId { get; set; }
-        [JsonProperty(Order = 2)] public string InvoiceId { get; set; }
+        [JsonProperty(Order = 1)]
+        public string StoreId { get; set; }
+        [JsonProperty(Order = 2)]
+        public string InvoiceId { get; set; }
     }
 
     public class WebhookInvoiceSettledEvent : WebhookInvoiceEvent
     {
         public WebhookInvoiceSettledEvent()
         {
-        }
 
+        }
         public WebhookInvoiceSettledEvent(WebhookEventType evtType) : base(evtType)
         {
         }
 
         public bool ManuallyMarked { get; set; }
     }
-
     public class WebhookInvoiceInvalidEvent : WebhookInvoiceEvent
     {
         public WebhookInvoiceInvalidEvent()
         {
-        }
 
+        }
         public WebhookInvoiceInvalidEvent(WebhookEventType evtType) : base(evtType)
         {
         }
 
         public bool ManuallyMarked { get; set; }
     }
-
     public class WebhookInvoiceProcessingEvent : WebhookInvoiceEvent
     {
         public WebhookInvoiceProcessingEvent()
         {
-        }
 
+        }
         public WebhookInvoiceProcessingEvent(WebhookEventType evtType) : base(evtType)
         {
         }
 
         public bool OverPaid { get; set; }
     }
-
     public class WebhookInvoiceReceivedPaymentEvent : WebhookInvoiceEvent
     {
         public WebhookInvoiceReceivedPaymentEvent()
         {
-        }
 
+        }
         public WebhookInvoiceReceivedPaymentEvent(WebhookEventType evtType) : base(evtType)
         {
         }
 
         public bool AfterExpiration { get; set; }
-        public string PaymentMethod { get; set; }
-        public InvoicePaymentMethodDataModel.Payment Payment { get; set; }
-        public bool OverPaid { get; set; }
     }
-
-    public class WebhookInvoicePaymentSettledEvent : WebhookInvoiceReceivedPaymentEvent
-    {
-        public WebhookInvoicePaymentSettledEvent()
-        {
-        }
-
-        public WebhookInvoicePaymentSettledEvent(WebhookEventType evtType) : base(evtType)
-        {
-        }
-    }
-
     public class WebhookInvoiceExpiredEvent : WebhookInvoiceEvent
     {
         public WebhookInvoiceExpiredEvent()
         {
-        }
 
+        }
         public WebhookInvoiceExpiredEvent(WebhookEventType evtType) : base(evtType)
         {
         }

BTCPayServer.Client/Permissions.cs

@@ -17,7 +17,6 @@ namespace BTCPayServer.Client
         public const string CanViewStoreSettings = "btcpay.store.canviewstoresettings";
         public const string CanViewInvoices = "btcpay.store.canviewinvoices";
         public const string CanCreateInvoice = "btcpay.store.cancreateinvoice";
-        public const string CanModifyInvoices = "btcpay.store.canmodifyinvoices";
         public const string CanViewPaymentRequests = "btcpay.store.canviewpaymentrequests";
         public const string CanModifyPaymentRequests = "btcpay.store.canmodifypaymentrequests";
         public const string CanModifyProfile = "btcpay.user.canmodifyprofile";
@@ -25,7 +24,6 @@ namespace BTCPayServer.Client
         public const string CanManageNotificationsForUser = "btcpay.user.canmanagenotificationsforuser";
         public const string CanViewNotificationsForUser = "btcpay.user.canviewnotificationsforuser";
         public const string CanCreateUser = "btcpay.server.cancreateuser";
-        public const string CanDeleteUser = "btcpay.user.candeleteuser";
         public const string CanManagePullPayments = "btcpay.store.canmanagepullpayments";
         public const string Unrestricted = "unrestricted";
         public static IEnumerable<string> AllPolicies
@@ -34,7 +32,6 @@ namespace BTCPayServer.Client
             {
                 yield return CanViewInvoices;
                 yield return CanCreateInvoice;
-                yield return CanModifyInvoices;
                 yield return CanModifyStoreWebhooks;
                 yield return CanModifyServerSettings;
                 yield return CanModifyStoreSettings;
@@ -44,7 +41,6 @@ namespace BTCPayServer.Client
                 yield return CanModifyProfile;
                 yield return CanViewProfile;
                 yield return CanCreateUser;
-                yield return CanDeleteUser;
                 yield return CanManageNotificationsForUser;
                 yield return CanViewNotificationsForUser;
                 yield return Unrestricted;
@@ -166,12 +162,10 @@ namespace BTCPayServer.Client
             switch (subpolicy)
             {
                 case Policies.CanViewInvoices when this.Policy == Policies.CanModifyStoreSettings:
-                case Policies.CanViewInvoices when this.Policy == Policies.CanModifyInvoices:
                 case Policies.CanModifyStoreWebhooks when this.Policy == Policies.CanModifyStoreSettings:
                 case Policies.CanViewInvoices when this.Policy == Policies.CanViewStoreSettings:
                 case Policies.CanViewStoreSettings when this.Policy == Policies.CanModifyStoreSettings:
                 case Policies.CanCreateInvoice when this.Policy == Policies.CanModifyStoreSettings:
-                case Policies.CanModifyInvoices when this.Policy == Policies.CanModifyStoreSettings:
                 case Policies.CanViewProfile when this.Policy == Policies.CanModifyProfile:
                 case Policies.CanModifyPaymentRequests when this.Policy == Policies.CanModifyStoreSettings:
                 case Policies.CanViewPaymentRequests when this.Policy == Policies.CanModifyStoreSettings:
@@ -179,7 +173,6 @@ namespace BTCPayServer.Client
                 case Policies.CanCreateLightningInvoiceInternalNode when this.Policy == Policies.CanUseInternalLightningNode:
                 case Policies.CanCreateLightningInvoiceInStore when this.Policy == Policies.CanUseLightningNodeInStore:
                 case Policies.CanViewNotificationsForUser when this.Policy == Policies.CanManageNotificationsForUser:
-                case Policies.CanUseInternalLightningNode when this.Policy == Policies.CanModifyServerSettings:
                     return true;
                 default:
                     return false;

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.Althash.cs

@@ -1,28 +0,0 @@
-using NBitcoin;
-using NBXplorer;
-
-namespace BTCPayServer
-{
-    public partial class BTCPayNetworkProvider
-    {
-        public void InitAlthash()
-        {
-            var nbxplorerNetwork = NBXplorerNetworkProvider.GetFromCryptoCode("HTML");
-            Add(new BTCPayNetwork()
-            {
-                CryptoCode = nbxplorerNetwork.CryptoCode,
-                DisplayName = "Althash",
-                BlockExplorerLink = NetworkType == ChainName.Mainnet ? "https://explorer.htmlcoin.com/api/tx/{0}" : "https://explorer.htmlcoin.com/api/tx/{0}",
-                NBXplorerNetwork = nbxplorerNetwork,
-                DefaultRateRules = new[]
-                {
-                                "HTML_X = HTML_USD",
-                                "HTML_USD = hitbtc(HTML_USD)"
-                },
-                CryptoImagePath = "imlegacy/althash.png",
-                DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
-                CoinType = NetworkType == ChainName.Mainnet ? new KeyPath("88'") : new KeyPath("1'")
-            });
-        }
-    }
-}

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.Argoneum.cs

@@ -15,6 +15,7 @@ namespace BTCPayServer
                     ? "https://chainz.cryptoid.info/agm/tx.dws?{0}"
                     : "https://chainz.cryptoid.info/agm-test/tx.dws?{0}",
                 NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "argoneum",
                 DefaultRateRules = new[]
                     {
                         "AGM_X = AGM_BTC * BTC_X",

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.BGold.cs

@@ -13,6 +13,7 @@ namespace BTCPayServer
                 DisplayName = "BGold",
                 BlockExplorerLink = NetworkType == ChainName.Mainnet ? "https://btgexplorer.com/tx/{0}" : "https://testnet.btgexplorer.com/tx/{0}",
                 NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "bitcoingold",
                 DefaultRateRules = new[]
                 {
                     "BTG_X = BTG_BTC * BTC_X",

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.BPlus.cs

@@ -14,6 +14,7 @@ namespace BTCPayServer
                 DisplayName = "BPlus",
                 BlockExplorerLink = NetworkType == ChainName.Mainnet ? "https://chainz.cryptoid.info/xbc/tx.dws?{0}" : "https://chainz.cryptoid.info/xbc/tx.dws?{0}",
                 NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "bplus-fix-it",
                 DefaultRateRules = new[]
                 {
                     "XBC_X = XBC_BTC * BTC_X",

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.Bitcore.cs

@@ -11,9 +11,10 @@ namespace BTCPayServer
             Add(new BTCPayNetwork()
             {
                 CryptoCode = nbxplorerNetwork.CryptoCode,
-                DisplayName = "BitCore",
-                BlockExplorerLink = NetworkType == ChainName.Mainnet ? "https://explorer.bitcore.cc/tx/{0}" : "https://explorer.bitcore.cc/tx/{0}",
+                DisplayName = "Bitcore",
+                BlockExplorerLink = NetworkType == ChainName.Mainnet ? "https://insight.bitcore.cc/tx/{0}" : "https://insight.bitcore.cc/tx/{0}",
                 NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "bitcore",
                 DefaultRateRules = new[]
                 {
                                 "BTX_X = BTX_BTC * BTC_X",

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.Chaincoin.cs

@@ -15,6 +15,7 @@ namespace BTCPayServer
                     ? "https://explorer.chaincoin.org/Explorer/Transaction/{0}"
                     : "https://test.explorer.chaincoin.org/Explorer/Transaction/tx/{0}",
                 NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "chaincoin",
                 DefaultRateRules = new[]
                     {
                         "CHC_X = CHC_BTC * BTC_X",

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.Dash.cs

@@ -16,6 +16,7 @@ namespace BTCPayServer
                     ? "https://insight.dash.org/insight/tx/{0}"
                     : "https://testnet-insight.dashevo.org/insight/tx/{0}",
                 NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "dash",
                 DefaultRateRules = new[]
                     {
                         "DASH_X = DASH_BTC * BTC_X",

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.Dogecoin.cs

@@ -14,6 +14,7 @@ namespace BTCPayServer
                 DisplayName = "Dogecoin",
                 BlockExplorerLink = NetworkType == ChainName.Mainnet ? "https://dogechain.info/tx/{0}" : "https://dogechain.info/tx/{0}",
                 NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "dogecoin",
                 DefaultRateRules = new[]
                 {
                                 "DOGE_X = DOGE_BTC * BTC_X",

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.Feathercoin.cs

@@ -14,6 +14,7 @@ namespace BTCPayServer
                 DisplayName = "Feathercoin",
                 BlockExplorerLink = NetworkType == ChainName.Mainnet ? "https://explorer.feathercoin.com/tx/{0}" : "https://explorer.feathercoin.com/tx/{0}",
                 NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "feathercoin",
                 DefaultRateRules = new[]
                 {
                                 "FTC_X = FTC_BTC * BTC_X",

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.Groestlcoin.cs

@@ -15,6 +15,7 @@ namespace BTCPayServer
                     ? "https://chainz.cryptoid.info/grs/tx.dws?{0}.htm"
                     : "https://chainz.cryptoid.info/grs-test/tx.dws?{0}.htm",
                 NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "groestlcoin",
                 DefaultRateRules = new[]
                 {
                     "GRS_X = GRS_BTC * BTC_X",

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.Litecoin.cs

@@ -17,6 +17,7 @@ namespace BTCPayServer
                     ? "https://live.blockcypher.com/ltc/tx/{0}/"
                     : "http://explorer.litecointools.com/tx/{0}",
                 NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "litecoin",
                 DefaultRateRules = new[]
                 {
                     "LTC_X = LTC_BTC * BTC_X",

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.Monacoin.cs

@@ -14,6 +14,7 @@ namespace BTCPayServer
                 DisplayName = "Monacoin",
                 BlockExplorerLink = NetworkType == ChainName.Mainnet ? "https://mona.insight.monaco-ex.org/insight/tx/{0}" : "https://testnet-mona.insight.monaco-ex.org/insight/tx/{0}",
                 NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "monacoin",
                 DefaultRateRules = new[]
                 {
                                 "MONA_X = MONA_BTC * BTC_X",

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.MonetaryUnit.cs

@@ -14,6 +14,7 @@ namespace BTCPayServer
                 DisplayName = "MonetaryUnit",
                 BlockExplorerLink = NetworkType == ChainName.Mainnet ? "https://explorer.monetaryunit.org/#/MUE/mainnet/tx/{0}" : "https://explorer.monetaryunit.org/#/MUE/mainnet/tx/{0}",
                 NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "monetaryunit",
                 DefaultRateRules = new[]
                 {
                                 "MUE_X = MUE_BTC * BTC_X",

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.Polis.cs

@@ -14,6 +14,7 @@ namespace BTCPayServer
                 DisplayName = "Polis",
                 BlockExplorerLink = NetworkType == ChainName.Mainnet ? "https://blockbook.polispay.org/tx/{0}" : "https://blockbook.polispay.org/tx/{0}",
                 NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "polis",
                 DefaultRateRules = new[]
                 {
                                 "POLIS_X = POLIS_BTC * BTC_X",

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.Ufo.cs

@@ -14,6 +14,7 @@ namespace BTCPayServer
                 DisplayName = "Ufo",
                 BlockExplorerLink = NetworkType == ChainName.Mainnet ? "https://chainz.cryptoid.info/ufo/tx.dws?{0}" : "https://chainz.cryptoid.info/ufo/tx.dws?{0}",
                 NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "ufo",
                 DefaultRateRules = new[]
                 {
                                 "UFO_X = UFO_BTC * BTC_X",

BTCPayServer.Common/Altcoins/BTCPayNetworkProvider.Viacoin.cs

@@ -14,6 +14,7 @@ namespace BTCPayServer
                 DisplayName = "Viacoin",
                 BlockExplorerLink = NetworkType == ChainName.Mainnet ? "https://explorer.viacoin.org/tx/{0}" : "https://explorer.viacoin.org/tx/{0}",
                 NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "viacoin",
                 DefaultRateRules = new[]
                 {
                                 "VIA_X = VIA_BTC * BTC_X",

BTCPayServer.Common/Altcoins/Liquid/BTCPayNetworkProvider.Liquid.cs

@@ -24,6 +24,7 @@ namespace BTCPayServer
                 },
                 BlockExplorerLink = NetworkType == ChainName.Mainnet ? "https://blockstream.info/liquid/tx/{0}" : "https://blockstream.info/testnet/liquid/tx/{0}",
                 NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "liquidnetwork",
                 CryptoImagePath = "imlegacy/liquid.png",
                 DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
                 CoinType = NetworkType == ChainName.Mainnet ? new KeyPath("1776'") : new KeyPath("1'"),

BTCPayServer.Common/Altcoins/Liquid/BTCPayNetworkProvider.LiquidAssets.cs

@@ -23,6 +23,7 @@ namespace BTCPayServer
                 DisplayName = "Liquid Tether",
                 BlockExplorerLink = NetworkType == ChainName.Mainnet ? "https://blockstream.info/liquid/tx/{0}" : "https://blockstream.info/testnet/liquid/tx/{0}",
                 NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "liquidnetwork",
                 CryptoImagePath = "imlegacy/liquid-tether.svg",
                 DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
                 CoinType = NetworkType == ChainName.Mainnet ? new KeyPath("1776'") : new KeyPath("1'"),
@@ -46,6 +47,7 @@ namespace BTCPayServer
                 DisplayName = "Ethiopian Birr",
                 BlockExplorerLink = NetworkType == ChainName.Mainnet ? "https://blockstream.info/liquid/tx/{0}" : "https://blockstream.info/testnet/liquid/tx/{0}",
                 NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "liquidnetwork",
                 CryptoImagePath = "imlegacy/etb.png",
                 DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
                 CoinType = NetworkType == ChainName.Mainnet ? new KeyPath("1776'") : new KeyPath("1'"),
@@ -68,6 +70,7 @@ namespace BTCPayServer
                 DisplayName = "Liquid CAD",
                 BlockExplorerLink = NetworkType == ChainName.Mainnet ? "https://blockstream.info/liquid/tx/{0}" : "https://blockstream.info/testnet/liquid/tx/{0}",
                 NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "liquidnetwork",
                 CryptoImagePath = "imlegacy/lcad.png",
                 DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),
                 CoinType = NetworkType == ChainName.Mainnet ? new KeyPath("1776'") : new KeyPath("1'"),

BTCPayServer.Common/Altcoins/Liquid/ElementsLikeBtcPayNetwork.cs

@@ -1,7 +1,6 @@
 #if ALTCOINS
 using System.Collections.Generic;
 using System.Linq;
-using BTCPayServer.Common;
 using NBitcoin;
 using NBXplorer;
 using NBXplorer.Models;
@@ -34,15 +33,13 @@ namespace BTCPayServer
                     output.Value is AssetMoney assetMoney && assetMoney.AssetId == AssetId));
         }
 
-        public override PaymentUrlBuilder GenerateBIP21(string cryptoInfoAddress, Money cryptoInfoDue)
+        public override string GenerateBIP21(string cryptoInfoAddress, Money cryptoInfoDue)
         {
             //precision 0: 10 = 0.00000010
             //precision 2: 10 = 0.00001000
             //precision 8: 10 = 10
-            var money = cryptoInfoDue is null ? null : new Money(cryptoInfoDue.ToDecimal(MoneyUnit.BTC) / decimal.Parse("1".PadRight(1 + 8 - Divisibility, '0')), MoneyUnit.BTC);
-            var builder = base.GenerateBIP21(cryptoInfoAddress, money);
-            builder.QueryParams.Add("assetid", AssetId.ToString());
-            return builder;
+            var money = cryptoInfoDue is null? null: new Money(cryptoInfoDue.ToDecimal(MoneyUnit.BTC) / decimal.Parse("1".PadRight(1 + 8 - Divisibility, '0')), MoneyUnit.BTC);
+            return $"{base.GenerateBIP21(cryptoInfoAddress, money)}{(money is null? "?": "&")}assetid={AssetId}";
         }
     }
 }

BTCPayServer.Common/BTCPayNetwork.cs

@@ -2,7 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using BTCPayServer.Common;
 using NBitcoin;
 using NBXplorer;
 using NBXplorer.Models;
@@ -66,9 +65,44 @@ namespace BTCPayServer
         public virtual bool ReadonlyWallet { get; set; } = false;
         public virtual bool VaultSupported { get; set; } = false;
         public int MaxTrackedConfirmation { get; set; } = 6;
+        public string UriScheme { get; set; }
         public bool SupportPayJoin { get; set; } = false;
         public bool SupportLightning { get; set; } = true;
 
+        public KeyPath GetRootKeyPath(DerivationType type)
+        {
+            KeyPath baseKey;
+            if (!NBitcoinNetwork.Consensus.SupportSegwit)
+            {
+                baseKey = new KeyPath("44'");
+            }
+            else
+            {
+                switch (type)
+                {
+                    case DerivationType.Legacy:
+                        baseKey = new KeyPath("44'");
+                        break;
+                    case DerivationType.SegwitP2SH:
+                        baseKey = new KeyPath("49'");
+                        break;
+                    case DerivationType.Segwit:
+                        baseKey = new KeyPath("84'");
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(type), type, null);
+                }
+            }
+            return baseKey
+                .Derive(CoinType);
+        }
+
+        public KeyPath GetRootKeyPath()
+        {
+            return new KeyPath(NBitcoinNetwork.Consensus.SupportSegwit ? "49'" : "44'")
+                .Derive(CoinType);
+        }
+
         public override T ToObject<T>(string json)
         {
             return NBXplorerNetwork.Serializer.ToObject<T>(json);
@@ -87,15 +121,9 @@ namespace BTCPayServer
             });
         }
 
-        public virtual PaymentUrlBuilder GenerateBIP21(string cryptoInfoAddress, Money cryptoInfoDue)
+        public virtual string GenerateBIP21(string cryptoInfoAddress, Money cryptoInfoDue)
         {
-            var builder = new PaymentUrlBuilder(this.NBitcoinNetwork.UriScheme);
-            builder.Host = cryptoInfoAddress;
-            if (cryptoInfoDue != null && cryptoInfoDue != Money.Zero)
-            {
-                builder.QueryParams.Add("amount", cryptoInfoDue.ToString(false, true));
-            }
-            return builder;
+            return $"{UriScheme}:{cryptoInfoAddress}{(cryptoInfoDue is null? string.Empty: $"?amount={cryptoInfoDue.ToString(false, true)}")}";
         }
 
         public virtual List<TransactionInformation> FilterValidTransactions(List<TransactionInformation> transactionInformationSet)

BTCPayServer.Common/BTCPayNetworkProvider.Bitcoin.cs

@@ -17,6 +17,7 @@ namespace BTCPayServer
                                     NetworkType == Bitcoin.Instance.Signet.ChainName ? "https://explorer.bc-2.jp/tx/{0}"
                                     : "https://blockstream.info/testnet/tx/{0}",
                 NBXplorerNetwork = nbxplorerNetwork,
+                UriScheme = "bitcoin",
                 CryptoImagePath = "imlegacy/bitcoin.svg",
                 LightningImagePath = "imlegacy/bitcoin-lightning.svg",
                 DefaultSettings = BTCPayDefaultSettings.GetDefaultSettings(NetworkType),

BTCPayServer.Common/BTCPayNetworkProvider.cs

@@ -51,7 +51,6 @@ namespace BTCPayServer
             InitMonacoin();
             InitDash();
             InitFeathercoin();
-            InitAlthash();
             InitGroestlcoin();
             InitViacoin();
             InitMonero();
@@ -132,10 +131,5 @@ namespace BTCPayServer
             }
             return network as T;
         }
-        public bool TryGetNetwork<T>(string cryptoCode, out T network) where T : BTCPayNetworkBase
-        {
-            network = GetNetwork<T>(cryptoCode);
-            return network != null;
-        }
     }
 }

BTCPayServer.Common/BTCPayServer.Common.csproj

@@ -4,9 +4,9 @@
 
   <ItemGroup>
     <FrameworkReference Include="Microsoft.AspNetCore.App" />
-    <PackageReference Include="NBXplorer.Client" Version="4.1.3" />
+    <PackageReference Include="NBXplorer.Client" Version="3.0.20" />
   </ItemGroup>
   <ItemGroup Condition="'$(Altcoins)' != 'true'">
     <Compile Remove="Altcoins\**\*.cs"></Compile>
   </ItemGroup>
-</Project>
+</Project>

BTCPayServer.Common/Extensions.cs

@@ -1,6 +1,4 @@
 using System.Collections.Generic;
-using NBitcoin;
-using NBXplorer.DerivationStrategy;
 
 namespace BTCPayServer
 {
@@ -13,23 +11,5 @@ namespace BTCPayServer
                 hashSet.Add(item);
             }
         }
-
-        public static ScriptPubKeyType ScriptPubKeyType(this DerivationStrategyBase derivationStrategyBase)
-        {
-            if (IsSegwitCore(derivationStrategyBase))
-            {
-                return NBitcoin.ScriptPubKeyType.Segwit;
-            }
-
-            return (derivationStrategyBase is P2SHDerivationStrategy p2shStrat && IsSegwitCore(p2shStrat.Inner))
-                ? NBitcoin.ScriptPubKeyType.SegwitP2SH
-                : NBitcoin.ScriptPubKeyType.Legacy;
-        }
-
-        private static bool IsSegwitCore(DerivationStrategyBase derivationStrategyBase)
-        {
-            return (derivationStrategyBase is P2WSHDerivationStrategy) ||
-                   (derivationStrategyBase is DirectDerivationStrategy direct) && direct.Segwit;
-        }
     }
 }

BTCPayServer.Common/IExplorerClientProvider.cs

@@ -1,10 +0,0 @@
-using NBXplorer;
-
-namespace BTCPayServer.Common
-{
-    public interface IExplorerClientProvider
-    {
-        ExplorerClient GetExplorerClient(string cryptoCode);
-        ExplorerClient GetExplorerClient(BTCPayNetworkBase network);
-    }
-}

BTCPayServer.Common/PaymentUrlBuilder.cs

@@ -1,30 +0,0 @@
-#nullable enable
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace BTCPayServer.Common
-{
-    public class PaymentUrlBuilder
-    {
-        public PaymentUrlBuilder(string uriScheme)
-        {
-            UriScheme = uriScheme;
-        }
-        public string UriScheme { get; set; }
-        public Dictionary<string, string> QueryParams { get; set; } = new Dictionary<string, string>();
-        public string? Host { get; set; }
-        public override string ToString()
-        {
-            StringBuilder builder = new StringBuilder($"{UriScheme}:{Host}");
-            if (QueryParams.Count != 0)
-            {
-                var parts = QueryParams.Select(q => Uri.EscapeDataString(q.Key) + "=" + System.Web.NBitcoin.HttpUtility.UrlEncode(q.Value))
-                    .ToArray();
-                builder.Append($"?{string.Join('&', parts)}");
-            }
-            return builder.ToString();
-        }
-    }
-}

BTCPayServer.Data/ApplicationDbContext.cs

@@ -55,7 +55,6 @@ namespace BTCPayServer.Data
         public DbSet<StoreWebhookData> StoreWebhooks { get; set; }
         public DbSet<StoreData> Stores { get; set; }
         public DbSet<U2FDevice> U2FDevices { get; set; }
-        public DbSet<Fido2Credential> Fido2Credentials { get; set; }
         public DbSet<UserStore> UserStore { get; set; }
         public DbSet<WalletData> Wallets { get; set; }
         public DbSet<WalletTransactionData> WalletTransactions { get; set; }
@@ -100,7 +99,6 @@ namespace BTCPayServer.Data
             StoreWebhookData.OnModelCreating(builder);
             //StoreData.OnModelCreating(builder);
             U2FDevice.OnModelCreating(builder);
-            Fido2Credential.OnModelCreating(builder);
             Data.UserStore.OnModelCreating(builder);
             //WalletData.OnModelCreating(builder);
             WalletTransactionData.OnModelCreating(builder);

BTCPayServer.Data/BTCPayServer.Data.csproj

@@ -3,11 +3,11 @@
   <Import Project="../Build/Common.csproj" />
   <ItemGroup>
     <FrameworkReference Include="Microsoft.AspNetCore.App" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="3.1.19">
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="3.1.4">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="3.1.19" />
+    <PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="3.1.4" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\BTCPayServer.Abstractions\BTCPayServer.Abstractions.csproj" />

BTCPayServer.Data/Data/ApplicationUser.cs

@@ -9,7 +9,6 @@ namespace BTCPayServer.Data
     {
         public bool RequiresEmailConfirmation { get; set; }
         public List<StoredFile> StoredFiles { get; set; }
-        [Obsolete("U2F support has been replace with FIDO2")]
         public List<U2FDevice> U2FDevices { get; set; }
         public List<APIKeyData> APIKeys { get; set; }
         public DateTimeOffset? Created { get; set; }
@@ -17,6 +16,5 @@ namespace BTCPayServer.Data
 
         public List<NotificationData> Notifications { get; set; }
         public List<UserStore> UserStores { get; set; }
-        public List<Fido2Credential> Fido2Credentials { get; set; }
     }
 }

BTCPayServer.Data/Data/Fido2Credential.cs

@@ -1,31 +0,0 @@
-using System;
-using System.ComponentModel.DataAnnotations.Schema;
-using Microsoft.EntityFrameworkCore;
-
-namespace BTCPayServer.Data
-{
-    public class Fido2Credential
-    {
-        public string Name { get; set; }
-        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
-        public string Id { get; set; }
-
-        public string ApplicationUserId { get; set; }
-
-        public byte[] Blob { get; set; }
-        public CredentialType Type { get; set; }
-        public enum CredentialType
-        {
-            FIDO2
-        }
-        public static void OnModelCreating(ModelBuilder builder)
-        {
-            builder.Entity<Fido2Credential>()
-                .HasOne(o => o.ApplicationUser)
-                .WithMany(i => i.Fido2Credentials)
-                .HasForeignKey(i => i.ApplicationUserId).OnDelete(DeleteBehavior.Cascade);
-        }
-
-        public ApplicationUser ApplicationUser { get; set; }
-    }
-}

BTCPayServer.Data/Data/PayoutData.cs

@@ -1,7 +1,5 @@
 using System;
 using System.ComponentModel.DataAnnotations;
-using System.ComponentModel.DataAnnotations.Schema;
-using BTCPayServer.Client.Models;
 using Microsoft.EntityFrameworkCore;
 using NBitcoin;
 
@@ -20,24 +18,25 @@ namespace BTCPayServer.Data
         [MaxLength(20)]
         [Required]
         public string PaymentMethodId { get; set; }
+        public string Destination { get; set; }
         public byte[] Blob { get; set; }
         public byte[] Proof { get; set; }
-#nullable enable
-        public string? Destination { get; set; }
-#nullable restore
+
 
         internal static void OnModelCreating(ModelBuilder builder)
         {
             builder.Entity<PayoutData>()
                 .HasOne(o => o.PullPaymentData)
                 .WithMany(o => o.Payouts).OnDelete(DeleteBehavior.Cascade);
+
             builder.Entity<PayoutData>()
                 .Property(o => o.State)
                 .HasConversion<string>();
             builder.Entity<PayoutData>()
-                .HasIndex(o => o.State);
+                .HasIndex(o => o.Destination)
+                .IsUnique();
             builder.Entity<PayoutData>()
-                .HasIndex(x => new { DestinationId = x.Destination, x.State});
+                .HasIndex(o => o.State);
         }
 
         // utility methods
@@ -54,4 +53,13 @@ namespace BTCPayServer.Data
             }
         }
     }
+
+    public enum PayoutState
+    {
+        AwaitingApproval,
+        AwaitingPayment,
+        InProgress,
+        Completed,
+        Cancelled
+    }
 }

BTCPayServer.Data/Data/PullPaymentData.cs

@@ -3,13 +3,11 @@ using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
 using System.Linq;
-using BTCPayServer.Client.Models;
 using Microsoft.EntityFrameworkCore;
 using NBitcoin;
 
 namespace BTCPayServer.Data
 {
-
     public class PullPaymentData
     {
         [Key]
@@ -88,6 +86,7 @@ namespace BTCPayServer.Data
         }
     }
 
+
     public static class PayoutExtensions
     {
         public static IQueryable<PayoutData> GetPayoutInPeriod(this IQueryable<PayoutData> payouts, PullPaymentData pp)

BTCPayServer.Data/Data/U2FDevice.cs

@@ -23,12 +23,11 @@ namespace BTCPayServer.Data
         
         internal static void OnModelCreating(ModelBuilder builder)
         {
-#pragma warning disable CS0618 // Type or member is obsolete
             builder.Entity<U2FDevice>()
                 .HasOne(o => o.ApplicationUser)
                 .WithMany(i => i.U2FDevices)
                 .HasForeignKey(i => i.ApplicationUserId).OnDelete(DeleteBehavior.Cascade);
-#pragma warning restore CS0618 // Type or member is obsolete
+            
         }
     }
 }

BTCPayServer.Data/Migrations/20210314092253_Fido2Credentials.cs

@@ -1,48 +0,0 @@
-using System;
-using Microsoft.EntityFrameworkCore.Migrations;
-using BTCPayServer.Data;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-namespace BTCPayServer.Migrations
-{
-    [DbContext(typeof(ApplicationDbContext))]
-    [Migration("20210314092253_Fido2Credentials")]
-    public partial class Fido2Credentials : Migration
-    {
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            int? maxLength = this.IsMySql(migrationBuilder.ActiveProvider) ? (int?)255 : null;
-            migrationBuilder.CreateTable(
-                name: "Fido2Credentials",
-                columns: table => new
-                {
-                    Id = table.Column<string>(nullable: false, maxLength: maxLength),
-                    Name = table.Column<string>(nullable: true),
-                    ApplicationUserId = table.Column<string>(nullable: true, maxLength: maxLength),
-                    Blob = table.Column<byte[]>(nullable: true),
-                    Type = table.Column<int>(nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_Fido2Credentials", x => x.Id);
-                    table.ForeignKey(
-                        name: "FK_Fido2Credentials_AspNetUsers_ApplicationUserId",
-                        column: x => x.ApplicationUserId,
-                        principalTable: "AspNetUsers",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateIndex(
-                name: "IX_Fido2Credentials_ApplicationUserId",
-                table: "Fido2Credentials",
-                column: "ApplicationUserId");
-        }
-
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropTable(
-                name: "Fido2Credentials");
-        }
-    }
-}

BTCPayServer.Data/Migrations/20211021085011_RemovePayoutDestinationConstraint.cs

@@ -1,41 +0,0 @@
-// <auto-generated />
-using System;
-using BTCPayServer.Data;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Migrations;
-using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-
-namespace BTCPayServer.Migrations
-{
-    [DbContext(typeof(ApplicationDbContext))]
-    [Migration("20211021085011_RemovePayoutDestinationConstraint")]
-    public partial class RemovePayoutDestinationConstraint : Migration
-    {
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropIndex(
-                name: "IX_Payouts_Destination",
-                table: "Payouts");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_Payouts_Destination_State",
-                table: "Payouts",
-                columns: new[] { "Destination", "State" });
-        }
-
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropIndex(
-                name: "IX_Payouts_Destination_State",
-                table: "Payouts");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_Payouts_Destination",
-                table: "Payouts",
-                column: "Destination",
-                unique: true);
-        }
-    }
-}

BTCPayServer.Data/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -15,7 +15,7 @@ namespace BTCPayServer.Migrations
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "3.1.19");
+                .HasAnnotation("ProductVersion", "3.1.4");
 
             modelBuilder.Entity("BTCPayServer.Data.APIKeyData", b =>
                 {
@@ -170,31 +170,6 @@ namespace BTCPayServer.Migrations
                     b.ToTable("AspNetUsers");
                 });
 
-            modelBuilder.Entity("BTCPayServer.Data.Fido2Credential", b =>
-                {
-                    b.Property<string>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("ApplicationUserId")
-                        .HasColumnType("TEXT");
-
-                    b.Property<byte[]>("Blob")
-                        .HasColumnType("BLOB");
-
-                    b.Property<string>("Name")
-                        .HasColumnType("TEXT");
-
-                    b.Property<int>("Type")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicationUserId");
-
-                    b.ToTable("Fido2Credentials");
-                });
-
             modelBuilder.Entity("BTCPayServer.Data.HistoricalAddressInvoiceData", b =>
                 {
                     b.Property<string>("InvoiceDataId")
@@ -527,12 +502,13 @@ namespace BTCPayServer.Migrations
 
                     b.HasKey("Id");
 
+                    b.HasIndex("Destination")
+                        .IsUnique();
+
                     b.HasIndex("PullPaymentDataId");
 
                     b.HasIndex("State");
 
-                    b.HasIndex("Destination", "State");
-
                     b.ToTable("Payouts");
                 });
 
@@ -982,14 +958,6 @@ namespace BTCPayServer.Migrations
                         .OnDelete(DeleteBehavior.Cascade);
                 });
 
-            modelBuilder.Entity("BTCPayServer.Data.Fido2Credential", b =>
-                {
-                    b.HasOne("BTCPayServer.Data.ApplicationUser", "ApplicationUser")
-                        .WithMany("Fido2Credentials")
-                        .HasForeignKey("ApplicationUserId")
-                        .OnDelete(DeleteBehavior.Cascade);
-                });
-
             modelBuilder.Entity("BTCPayServer.Data.HistoricalAddressInvoiceData", b =>
                 {
                     b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")

BTCPayServer.Plugins.Test/BTCPayServer.Plugins.Test.csproj

@@ -13,7 +13,7 @@
       <EmbeddedResource Include="Resources\**" />
     </ItemGroup>
     <ItemGroup>
-      <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="3.1.19">
+      <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="3.1.4">
       </PackageReference>
     </ItemGroup>
 </Project>

BTCPayServer.Plugins.Test/Services/TestPluginService.cs

@@ -20,7 +20,6 @@ namespace BTCPayServer.Plugins.Test.Services
             await using var context = _testPluginDbContextFactory.CreateContext();
 
             await context.TestPluginRecords.AddAsync(new TestPluginData() {Timestamp = DateTimeOffset.UtcNow});
-            await context.SaveChangesAsync();
         }
         
         

BTCPayServer.Plugins.Test/Views/TestExtension/Index.cshtml

@@ -9,8 +9,8 @@
 
         <div class="row">
             <h2>Persisted Data</h2>
-            <p>The following is data persisted to the configured database but in an isolated DbContext. Every time you start BTCPay Server with this plugin enabled, a timestamp is logged.</p>
-            <ul class="list-group">
+            <p>The following is data persisted to the configured database but in an isolated DbContext. Every time you start BTCPayw with this plugin enabled, a timestamp is logged.</p>
+            <ul class="list-group">>
                 @foreach (var item in Model.Data)
                 {
                     <li class="list-group-item">@item.Id at @item.Timestamp.ToString("F")</li>

BTCPayServer.Rating/BTCPayServer.Rating.csproj

@@ -4,10 +4,10 @@
 
   <ItemGroup>
     <FrameworkReference Include="Microsoft.AspNetCore.App" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.11.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.6.0" />
     <PackageReference Include="Microsoft.AspNet.WebApi.Client" Version="5.2.7" />
-    <PackageReference Include="NBitcoin" Version="6.0.15" />
-    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
+    <PackageReference Include="NBitcoin" Version="5.0.73" />
+    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
     <PackageReference Include="DigitalRuby.ExchangeSharp" Version="0.6.3" />
   </ItemGroup>
 

BTCPayServer.Rating/Currencies.json

@@ -1266,13 +1266,6 @@
       "symbol":null,
       "crypto":true
    },
-   {
-      "name":"Althash",
-      "code":"HTML",
-      "divisibility":8,
-      "symbol":null,
-      "crypto":true
-   },
    {
       "name":"CHC",
       "code":"CHC",

BTCPayServer.Rating/CurrencyNameTable.cs

@@ -28,6 +28,7 @@ namespace BTCPayServer.Services.Rates
         }
 
         static readonly Dictionary<string, IFormatProvider> _CurrencyProviders = new Dictionary<string, IFormatProvider>();
+
         public string FormatCurrency(string price, string currency)
         {
             return FormatCurrency(decimal.Parse(price, CultureInfo.InvariantCulture), currency);
@@ -109,8 +110,9 @@ namespace BTCPayServer.Services.Rates
         /// </summary>
         /// <param name="value">The value</param>
         /// <param name="currency">Currency code</param>
+        /// <param name="threeLetterSuffix">Add three letter suffix (like USD)</param>
         /// <returns></returns>
-        public string DisplayFormatCurrency(decimal value, string currency)
+        public string DisplayFormatCurrency(decimal value, string currency, bool threeLetterSuffix = true)
         {
             var provider = GetNumberFormatInfo(currency, true);
             var currencyData = GetCurrencyData(currency, true);

BTCPayServer.Rating/Providers/CryptoMarketExchangeRateProvider.cs

@@ -1,48 +0,0 @@
-using System.Collections.Generic;
-using System.Globalization;
-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 CryptoMarketExchangeRateProvider : IRateProvider
-    {
-        private readonly HttpClient _httpClient;
-        public CryptoMarketExchangeRateProvider(HttpClient httpClient)
-        {
-            _httpClient = httpClient ?? new HttpClient();
-        }
-
-
-        readonly List<string> SupportedPairs = new List<string>()
-        {
-            "BTCARS",
-            "BTCCLP",
-            "BTCBRL"
-        };
-
-        public async Task<PairRate[]> GetRatesAsync(CancellationToken cancellationToken)
-        {
-            var response = await _httpClient.GetAsync("https://api.exchange.cryptomkt.com/api/3/public/ticker/", cancellationToken);
-            var jobj = await response.Content.ReadAsAsync<JObject>(cancellationToken);
-
-            return ((jobj as JObject) ?? new JObject())
-                .Properties()
-                .Where(p => SupportedPairs.Contains(p.Name))
-                .Select(p => new PairRate(CurrencyPair.Parse(p.Name), CreateBidAsk(p)))
-                .ToArray();
-        }
-        private static BidAsk CreateBidAsk(JProperty p)
-        {
-            var bid = decimal.Parse(p.Value["bid"].Value<string>(), System.Globalization.NumberStyles.Any, CultureInfo.InvariantCulture);
-            var ask = decimal.Parse(p.Value["ask"].Value<string>(), System.Globalization.NumberStyles.Any, CultureInfo.InvariantCulture);
-            if (bid > ask)
-                return null;
-            return new BidAsk(bid, ask);
-        }
-    }
-}

BTCPayServer.Rating/Providers/RipioExchangeProvider.cs

@@ -1,42 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Net.Http;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using BTCPayServer.Rating;
-using Newtonsoft.Json.Linq;
-
-namespace BTCPayServer.Services.Rates
-{
-    public class RipioExchangeProvider : IRateProvider
-    {
-        private readonly HttpClient _httpClient;
-        public RipioExchangeProvider(HttpClient httpClient)
-        {
-            _httpClient = httpClient ?? new HttpClient();
-        }
-        public async Task<PairRate[]> GetRatesAsync(CancellationToken cancellationToken)
-        {
-            var response = await _httpClient.GetAsync("https://api.exchange.ripio.com/api/v1/rate/all/", cancellationToken);
-            var jarray = (JArray)(await response.Content.ReadAsAsync<JArray>(cancellationToken));
-            return jarray
-                .Children<JObject>()
-                .Select(jobj => ParsePair(jobj))
-                .Where(p => p != null)
-                .ToArray();
-        }
-
-        private PairRate ParsePair(JObject jobj)
-        {
-            var pair = CurrencyPair.Parse(jobj["pair"].Value<string>());
-            var bid = decimal.Parse(jobj["bid"].Value<string>(), System.Globalization.NumberStyles.Any, CultureInfo.InvariantCulture);
-            var ask = decimal.Parse(jobj["ask"].Value<string>(), System.Globalization.NumberStyles.Any, CultureInfo.InvariantCulture);
-            if (bid > ask)
-                return null;
-            return new PairRate(pair, new BidAsk(bid, ask));
-        }
-    }
-}

BTCPayServer.Rating/Services/RateProviderFactory.cs

@@ -75,8 +75,6 @@ namespace BTCPayServer.Services.Rates
             yield return new AvailableRateProvider("bitbank", "Bitbank", "https://public.bitbank.cc/prices");
             yield return new AvailableRateProvider("bitflyer", "Bitflyer", "https://api.bitflyer.com/v1/ticker");
             yield return new AvailableRateProvider("bitpay", "Bitpay", "https://bitpay.com/rates");
-            yield return new AvailableRateProvider("ripio", "Ripio", "https://api.exchange.ripio.com/api/v1/rate/all/");
-            yield return new AvailableRateProvider("cryptomarket", "CryptoMarket", "https://api.exchange.cryptomkt.com/api/3/public/ticker/");
 
             yield return new AvailableRateProvider("polispay", "PolisPay", "https://obol.polispay.com/complex/btc/polis");
 
@@ -101,8 +99,6 @@ namespace BTCPayServer.Services.Rates
             Providers.Add("bylls", new ByllsRateProvider(_httpClientFactory?.CreateClient("EXCHANGE_BYLLS")));
             Providers.Add("bitbank", new BitbankRateProvider(_httpClientFactory?.CreateClient("EXCHANGE_BITBANK")));
             Providers.Add("bitpay", new BitpayRateProvider(_httpClientFactory?.CreateClient("EXCHANGE_BITPAY")));
-            Providers.Add("ripio", new RipioExchangeProvider(_httpClientFactory?.CreateClient("EXCHANGE_RIPIO")));
-            Providers.Add("cryptomarket", new CryptoMarketExchangeRateProvider(_httpClientFactory?.CreateClient("EXCHANGE_CRYPTOMARKET")));
             Providers.Add("bitflyer", new BitflyerRateProvider(_httpClientFactory?.CreateClient("EXCHANGE_BITFLYER")));
             Providers.Add("polispay", new PolisRateProvider(_httpClientFactory?.CreateClient("EXCHANGE_POLIS")));
             // Providers.Add("argoneum", new ArgoneumRateProvider(_httpClientFactory?.CreateClient("EXCHANGE_ARGONEUM")));

BTCPayServer.Tests/AltcoinTests/AltcoinTests.cs

@@ -26,7 +26,6 @@ using Newtonsoft.Json.Linq;
 using OpenQA.Selenium;
 using Xunit;
 using Xunit.Abstractions;
-using WalletSettingsViewModel = BTCPayServer.Models.StoreViewModels.WalletSettingsViewModel;
 
 namespace BTCPayServer.Tests
 {
@@ -51,14 +50,13 @@ namespace BTCPayServer.Tests
                 tester.ActivateLightning();
                 await tester.StartAsync();
                 var user = tester.NewAccount();
-                var cryptoCode = "BTC";
-                await user.GrantAccessAsync(true);
-                user.RegisterDerivationScheme(cryptoCode);
+                user.GrantAccess(true);
+                user.RegisterDerivationScheme("BTC");
                 user.RegisterDerivationScheme("LTC");
-                user.RegisterLightningNode(cryptoCode, LightningConnectionType.CLightning);
-                var btcNetwork = tester.PayTester.Networks.GetNetwork<BTCPayNetwork>(cryptoCode);
-                var invoice = await user.BitPay.CreateInvoiceAsync(
-                    new Invoice
+                user.RegisterLightningNode("BTC", LightningConnectionType.CLightning);
+                var btcNetwork = tester.PayTester.Networks.GetNetwork<BTCPayNetwork>("BTC");
+                var invoice = user.BitPay.CreateInvoice(
+                    new Invoice()
                     {
                         Price = 1.5m,
                         Currency = "USD",
@@ -71,43 +69,36 @@ namespace BTCPayServer.Tests
                 Assert.Equal(3, invoice.CryptoInfo.Length);
 
                 var controller = user.GetController<StoresController>();
-                var lightningVm = (LightningNodeViewModel)Assert.IsType<ViewResult>(await controller.SetupLightningNode(user.StoreId, cryptoCode)).Model;
+                var lightningVm = (LightningNodeViewModel)Assert.IsType<ViewResult>(controller.AddLightningNode(user.StoreId, "BTC")).Model;
                 Assert.True(lightningVm.Enabled);
-                var response = await controller.SetLightningNodeEnabled(user.StoreId, cryptoCode, false);
-                Assert.IsType<RedirectToActionResult>(response);
-
-                // Get enabled state from overview action
-                PaymentMethodsViewModel paymentMethodsModel;
-                response = controller.PaymentMethods();
-                paymentMethodsModel = (PaymentMethodsViewModel)Assert.IsType<ViewResult>(response).Model;
-                var lnNode = paymentMethodsModel.LightningNodes.Find(node => node.CryptoCode == cryptoCode);
-                Assert.NotNull(lnNode);
-                Assert.False(lnNode.Enabled);
+                lightningVm.Enabled = false;
+                controller.AddLightningNode(user.StoreId, lightningVm, "save", "BTC").GetAwaiter().GetResult();
+                lightningVm = (LightningNodeViewModel)Assert.IsType<ViewResult>(controller.AddLightningNode(user.StoreId, "BTC")).Model;
+                Assert.False(lightningVm.Enabled);
 
                 WalletSetupViewModel setupVm;
                 var storeId = user.StoreId;
-                response = await controller.GenerateWallet(storeId, cryptoCode, WalletSetupMethod.GenerateOptions, new WalletSetupRequest());
+                var cryptoCode = "BTC";
+                var response = await controller.GenerateWallet(storeId, cryptoCode, WalletSetupMethod.GenerateOptions, new GenerateWalletRequest());
                 Assert.IsType<ViewResult>(response);
 
-                // Get enabled state from overview action
-                response = controller.PaymentMethods();
-                paymentMethodsModel = (PaymentMethodsViewModel)Assert.IsType<ViewResult>(response).Model;
-                var derivationScheme = paymentMethodsModel.DerivationSchemes.Find(scheme => scheme.Crypto == cryptoCode);
-                Assert.NotNull(derivationScheme);
-                Assert.True(derivationScheme.Enabled);
+                // Get setup view model from modify action
+                response = await controller.ModifyWallet(new WalletSetupViewModel { StoreId = storeId, CryptoCode = cryptoCode });
+                setupVm = (WalletSetupViewModel)Assert.IsType<ViewResult>(response).Model;
+                Assert.True(setupVm.Enabled);
 
-                // Disable wallet
-                response = controller.SetWalletEnabled(storeId, cryptoCode, false).GetAwaiter().GetResult();
+                // Only Enabling/Disabling the payment method must redirect to store page
+                setupVm.Enabled = false;
+                response = controller.UpdateWallet(setupVm).GetAwaiter().GetResult();
                 Assert.IsType<RedirectToActionResult>(response);
-                response = controller.PaymentMethods();
-                paymentMethodsModel = (PaymentMethodsViewModel)Assert.IsType<ViewResult>(response).Model;
-                derivationScheme = paymentMethodsModel.DerivationSchemes.Find(scheme => scheme.Crypto == cryptoCode);
-                Assert.NotNull(derivationScheme);
-                Assert.False(derivationScheme.Enabled);
 
-                var oldScheme = derivationScheme.Value;
+                response = await controller.ModifyWallet(new WalletSetupViewModel { StoreId = storeId, CryptoCode = cryptoCode });
+                setupVm = (WalletSetupViewModel)Assert.IsType<ViewResult>(response).Model;
+                Assert.False(setupVm.Enabled);
 
-                invoice = await user.BitPay.CreateInvoiceAsync(
+                var oldScheme = setupVm.DerivationScheme;
+
+                invoice = user.BitPay.CreateInvoice(
                     new Invoice
                     {
                         Price = 1.5m,
@@ -122,7 +113,7 @@ namespace BTCPayServer.Tests
                 Assert.Equal("LTC", invoice.CryptoInfo[0].CryptoCode);
 
                 // Removing the derivation scheme, should redirect to store page
-                response = controller.ConfirmDeleteWallet(user.StoreId, cryptoCode).GetAwaiter().GetResult();
+                response = controller.ConfirmDeleteWallet(user.StoreId, "BTC").GetAwaiter().GetResult();
                 Assert.IsType<RedirectToActionResult>(response);
 
                 // Setting it again should show the confirmation page
@@ -139,9 +130,9 @@ namespace BTCPayServer.Tests
                 Assert.True(setupVm.Confirmation);
                 response = await controller.UpdateWallet(setupVm);
                 Assert.IsType<RedirectToActionResult>(response);
-                response = await controller.WalletSettings(storeId, cryptoCode);
-                var settingsVm = (WalletSettingsViewModel)Assert.IsType<ViewResult>(response).Model;
-                Assert.Equal("CoboVault", settingsVm.Source);
+                response = await controller.ModifyWallet(new WalletSetupViewModel { StoreId = storeId, CryptoCode = cryptoCode });
+                setupVm = (WalletSetupViewModel)Assert.IsType<ViewResult>(response).Model;
+                Assert.Equal("CoboVault", setupVm.Source);
 
                 // wasabi wallet file
                 content = "{\r\n  \"EncryptedSecret\": \"6PYWBQ1zsukowsnTNA57UUx791aBuJusm7E4egXUmF5WGw3tcdG3cmTL57\",\r\n  \"ChainCode\": \"waSIVbn8HaoovoQg/0t8IS1+ZCxGsJRGFT21i06nWnc=\",\r\n  \"MasterFingerprint\": \"7a7563b5\",\r\n  \"ExtPubKey\": \"xpub6CEqRFZ7yZxCFXuEWZBAdnC8bdvu9SRHevaoU2SsW9ZmKhrCShmbpGZWwaR15hdLURf8hg47g4TpPGaqEU8hw5LEJCE35AUhne67XNyFGBk\",\r\n  \"PasswordVerified\": false,\r\n  \"MinGapLimit\": 21,\r\n  \"AccountKeyPath\": \"84'/0'/0'\",\r\n  \"BlockchainState\": {\r\n    \"Network\": \"RegTest\",\r\n    \"Height\": \"0\"\r\n  },\r\n  \"HdPubKeys\": []\r\n}";
@@ -150,9 +141,9 @@ namespace BTCPayServer.Tests
                 Assert.True(setupVm.Confirmation);
                 response = await controller.UpdateWallet(setupVm);
                 Assert.IsType<RedirectToActionResult>(response);
-                response = await controller.WalletSettings(storeId, cryptoCode);
-                settingsVm = (WalletSettingsViewModel)Assert.IsType<ViewResult>(response).Model;
-                Assert.Equal("WasabiFile", settingsVm.Source);
+                response = await controller.ModifyWallet(new WalletSetupViewModel { StoreId = storeId, CryptoCode = cryptoCode });
+                setupVm = (WalletSetupViewModel)Assert.IsType<ViewResult>(response).Model;
+                Assert.Equal("WasabiFile", setupVm.Source);
 
                 // Can we upload coldcard settings? (Should fail, we are giving a mainnet file to a testnet network)
                 content = "{\"keystore\": {\"ckcc_xpub\": \"xpub661MyMwAqRbcGVBsTGeNZN6QGVHmMHLdSA4FteGsRrEriu4pnVZMZWnruFFFXkMnyoBjyHndD3Qwcfz4MPzBUxjSevweNFQx7SAYZATtcDw\", \"xpub\": \"ypub6WWc2gWwHbdnAAyJDnR4SPL1phRh7REqrPBfZeizaQ1EmTshieRXJC3Z5YoU4wkcdKHEjQGkh6AYEzCQC1Kz3DNaWSwdc1pc8416hAjzqyD\", \"label\": \"Coldcard Import 0x60d1af8b\", \"ckcc_xfp\": 1624354699, \"type\": \"hardware\", \"hw_type\": \"coldcard\", \"derivation\": \"m/49'/0'/0'\"}, \"wallet_type\": \"standard\", \"use_encryption\": false, \"seed_version\": 17}";
@@ -167,9 +158,9 @@ namespace BTCPayServer.Tests
                 Assert.True(setupVm.Confirmation);
                 response = await controller.UpdateWallet(setupVm);
                 Assert.IsType<RedirectToActionResult>(response);
-                response = await controller.WalletSettings(storeId, cryptoCode);
-                settingsVm = (WalletSettingsViewModel)Assert.IsType<ViewResult>(response).Model;
-                Assert.Equal("ElectrumFile", settingsVm.Source);
+                response = await controller.ModifyWallet(new WalletSetupViewModel { StoreId = storeId, CryptoCode = cryptoCode });
+                setupVm = (WalletSetupViewModel)Assert.IsType<ViewResult>(response).Model;
+                Assert.Equal("ElectrumFile", setupVm.Source);
 
                 // Now let's check that no data has been lost in the process
                 var store = tester.PayTester.StoreRepository.FindStore(storeId).GetAwaiter().GetResult();
@@ -181,8 +172,8 @@ namespace BTCPayServer.Tests
                 Assert.Equal(expected.ToJson(), onchainBTC.ToJson());
 
                 // Let's check that the root hdkey and account key path are taken into account when making a PSBT
-                invoice = await user.BitPay.CreateInvoiceAsync(
-                    new Invoice
+                invoice = user.BitPay.CreateInvoice(
+                    new Invoice()
                     {
                         Price = 1.5m,
                         Currency = "USD",
@@ -193,7 +184,7 @@ namespace BTCPayServer.Tests
                     }, Facade.Merchant);
 
                 tester.ExplorerNode.Generate(1);
-                var invoiceAddress = BitcoinAddress.Create(invoice.CryptoInfo.First(c => c.CryptoCode == cryptoCode).Address,
+                var invoiceAddress = BitcoinAddress.Create(invoice.CryptoInfo.First(c => c.CryptoCode == "BTC").Address,
                     tester.ExplorerNode.Network);
                 tester.ExplorerNode.SendToAddress(invoiceAddress, Money.Coins(1m));
                 TestUtils.Eventually(() =>
@@ -205,9 +196,9 @@ namespace BTCPayServer.Tests
                 var psbt = wallet.CreatePSBT(btcNetwork, onchainBTC,
                     new WalletSendModel()
                     {
-                        Outputs = new List<WalletSendModel.TransactionOutput>
+                        Outputs = new List<WalletSendModel.TransactionOutput>()
                         {
-                            new WalletSendModel.TransactionOutput
+                            new WalletSendModel.TransactionOutput()
                             {
                                 Amount = 0.5m,
                                 DestinationAddress = new Key().PubKey.GetAddress(ScriptPubKeyType.Legacy, btcNetwork.NBitcoinNetwork)
@@ -313,7 +304,7 @@ namespace BTCPayServer.Tests
 
                 var controller = tester.PayTester.GetController<InvoiceController>(null);
                 var checkout =
-                    (Models.InvoicingModels.PaymentModel)((JsonResult)controller.GetStatus(invoice.Id)
+                    (Models.InvoicingModels.PaymentModel)((JsonResult)controller.GetStatus(invoice.Id, null)
                         .GetAwaiter().GetResult()).Value;
                 Assert.Single(checkout.AvailableCryptos);
                 Assert.Equal("LTC", checkout.CryptoCode);
@@ -330,7 +321,7 @@ namespace BTCPayServer.Tests
                 {
                     invoice = user.BitPay.GetInvoice(invoice.Id);
                     Assert.Equal("paid", invoice.Status);
-                    checkout = (Models.InvoicingModels.PaymentModel)((JsonResult)controller.GetStatus(invoice.Id)
+                    checkout = (Models.InvoicingModels.PaymentModel)((JsonResult)controller.GetStatus(invoice.Id, null)
                         .GetAwaiter().GetResult()).Value;
                     Assert.Equal("paid", checkout.Status);
                 });
@@ -613,7 +604,7 @@ namespace BTCPayServer.Tests
                 user.RegisterDerivationScheme("LTC");
                 var apps = user.GetController<AppsController>();
                 var vm = Assert.IsType<CreateAppViewModel>(Assert.IsType<ViewResult>(apps.CreateApp().Result).Model);
-                vm.AppName = "test";
+                vm.Name = "test";
                 vm.SelectedAppType = AppType.PointOfSale.ToString();
                 Assert.IsType<RedirectToActionResult>(apps.CreateApp(vm).Result);
                 var appId = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps().Result).Model)
@@ -821,51 +812,6 @@ normal:
                     normalInvoice.CryptoInfo,
                     s => PaymentTypes.BTCLike.ToString() == s.PaymentType && new[] { "BTC", "LTC" }.Contains(
                              s.CryptoCode));
-                
-                //test topup option
-                vmpos.Template = @"
-a:
-  price: 1000.0
-  title: good apple
-  
-b:
-  price: 10.0
-  custom: false
-c:
-  price: 1.02
-  custom: true
-d:
-  price: 1.02
-  price_type: fixed
-e:
-  price: 1.02
-  price_type: minimum
-f:
-  price_type: topup
-g:
-  custom: topup
-";
-                
-                Assert.IsType<RedirectToActionResult>(apps.UpdatePointOfSale(appId, vmpos).Result);
-                vmpos = Assert.IsType<UpdatePointOfSaleViewModel>(Assert
-                    .IsType<ViewResult>(await apps.UpdatePointOfSale(appId)).Model);
-                Assert.DoesNotContain("custom", vmpos.Template);
-                var items = appService.Parse(vmpos.Template, vmpos.Currency);
-                Assert.Contains(items, item => item.Id == "a" && item.Price.Type == ViewPointOfSaleViewModel.Item.ItemPrice.ItemPriceType.Fixed);
-                Assert.Contains(items, item => item.Id == "b" && item.Price.Type == ViewPointOfSaleViewModel.Item.ItemPrice.ItemPriceType.Fixed);
-                Assert.Contains(items, item => item.Id == "c" && item.Price.Type == ViewPointOfSaleViewModel.Item.ItemPrice.ItemPriceType.Minimum);
-                Assert.Contains(items, item => item.Id == "d" && item.Price.Type == ViewPointOfSaleViewModel.Item.ItemPrice.ItemPriceType.Fixed);
-                Assert.Contains(items, item => item.Id == "e" && item.Price.Type == ViewPointOfSaleViewModel.Item.ItemPrice.ItemPriceType.Minimum);
-                Assert.Contains(items, item => item.Id == "f" && item.Price.Type == ViewPointOfSaleViewModel.Item.ItemPrice.ItemPriceType.Topup);
-                Assert.Contains(items, item => item.Id == "g" && item.Price.Type == ViewPointOfSaleViewModel.Item.ItemPrice.ItemPriceType.Topup);
-                
-                
-                Assert.IsType<RedirectToActionResult>(publicApps
-                    .ViewPointOfSale(appId, PosViewType.Static, null, null, null, null, null, "g").Result);
-                invoices = user.BitPay.GetInvoices();
-                var topupInvoice = invoices.Single(invoice => invoice.ItemCode == "g");
-                Assert.Equal(0, topupInvoice.Price);
-                Assert.Equal("new", topupInvoice.Status);
             }
         }
 
@@ -1000,6 +946,28 @@ g:
 
             result = testnetParser.Parse(tpub);
             Assert.Equal(tpub, result.ToString());
+            testnetParser.HintScriptPubKey = BitcoinAddress
+                .Create("tb1q4s33amqm8l7a07zdxcunqnn3gcsjcfz3xc573l", testnetParser.Network).ScriptPubKey;
+            result = testnetParser.Parse(tpub);
+            Assert.Equal(tpub, result.ToString());
+
+            testnetParser.HintScriptPubKey = BitcoinAddress
+                .Create("2N2humNio3YTApSfY6VztQ9hQwDnhDvaqFQ", testnetParser.Network).ScriptPubKey;
+            result = testnetParser.Parse(tpub);
+            Assert.Equal($"{tpub}-[p2sh]", result.ToString());
+
+            testnetParser.HintScriptPubKey = BitcoinAddress
+                .Create("mwD8bHS65cdgUf6rZUUSoVhi3wNQFu1Nfi", testnetParser.Network).ScriptPubKey;
+            result = testnetParser.Parse(tpub);
+            Assert.Equal($"{tpub}-[legacy]", result.ToString());
+
+            testnetParser.HintScriptPubKey = BitcoinAddress
+                .Create("2N2humNio3YTApSfY6VztQ9hQwDnhDvaqFQ", testnetParser.Network).ScriptPubKey;
+            result = testnetParser.Parse($"{tpub}-[legacy]");
+            Assert.Equal($"{tpub}-[p2sh]", result.ToString());
+
+            result = testnetParser.Parse(tpub);
+            Assert.Equal($"{tpub}-[p2sh]", result.ToString());
 
             var regtestParser = new DerivationSchemeParser(regtestNetworkProvider.GetNetwork<BTCPayNetwork>("BTC"));
             var parsed =

BTCPayServer.Tests/AltcoinTests/ElementsTests.cs

@@ -125,11 +125,11 @@ namespace BTCPayServer.Tests
                 });
 
                 //test precision based on https://github.com/ElementsProject/elements/issues/805#issuecomment-601277606
-                var etbBip21 = new BitcoinUrlBuilder(invoice.CryptoInfo.Single(info => info.CryptoCode == "ETB").PaymentUrls.BIP21, etb.NBitcoinNetwork);
+                var etbBip21 = new BitcoinUrlBuilder(invoice.CryptoInfo.Single(info => info.CryptoCode == "ETB").PaymentUrls.BIP21.Replace(etb.UriScheme, "bitcoin"), etb.NBitcoinNetwork);
                 //precision = 2, 1ETB  = 0.00000100
                 Assert.Equal(100, etbBip21.Amount.Satoshi);
 
-                var lbtcBip21 = new BitcoinUrlBuilder(invoice.CryptoInfo.Single(info => info.CryptoCode == "LBTC").PaymentUrls.BIP21, lbtc.NBitcoinNetwork);
+                var lbtcBip21 = new BitcoinUrlBuilder(invoice.CryptoInfo.Single(info => info.CryptoCode == "LBTC").PaymentUrls.BIP21.Replace(lbtc.UriScheme, "bitcoin"), lbtc.NBitcoinNetwork);
                 //precision = 8, 0.1 = 0.1
                 Assert.Equal(0.1m, lbtcBip21.Amount.ToDecimal(MoneyUnit.BTC));
             }

BTCPayServer.Tests/ApiKeysTests.cs

@@ -89,12 +89,7 @@ namespace BTCPayServer.Tests
                 s.Driver.FindElement(By.Id("AddApiKey")).Click();
                 s.Driver.FindElement(By.CssSelector("button[value='btcpay.store.canmodifystoresettings:change-store-mode']")).Click();
                 //there should be a store already by default in the dropdown
-                var src = s.Driver.PageSource;
-                var getPermissionValueIndex =
-                    s.Driver.FindElement(By.CssSelector("input[value='btcpay.store.canmodifystoresettings']"))
-                        .GetAttribute("name")
-                        .Replace(".Permission", ".SpecificStores[0]");
-                var dropdown = s.Driver.FindElement(By.Name(getPermissionValueIndex));
+                var dropdown = s.Driver.FindElement(By.Name("PermissionValues[4].SpecificStores[0]"));
                 var option = dropdown.FindElement(By.TagName("option"));
                 var storeId = option.GetAttribute("value");
                 option.Click();
@@ -124,8 +119,8 @@ namespace BTCPayServer.Tests
                 //redirect
                 //appidentifier
                 var appidentifier = "testapp";
-                var callbackUrl = s.ServerUri + "postredirect-callback-test";
-                var authUrl = BTCPayServerClient.GenerateAuthorizeUri(s.ServerUri,
+                var callbackUrl = tester.PayTester.ServerUri + "postredirect-callback-test";
+                var authUrl = BTCPayServerClient.GenerateAuthorizeUri(tester.PayTester.ServerUri,
                     new[] { Policies.CanModifyStoreSettings, Policies.CanModifyServerSettings }, applicationDetails: (appidentifier, new Uri(callbackUrl))).ToString();
                 s.Driver.Navigate().GoToUrl(authUrl);
                 Assert.Contains(appidentifier, s.Driver.PageSource);
@@ -143,7 +138,7 @@ namespace BTCPayServer.Tests
                 await TestApiAgainstAccessToken(accessToken, tester, user,
                     (await apiKeyRepo.GetKey(accessToken)).GetBlob().Permissions);
 
-                authUrl = BTCPayServerClient.GenerateAuthorizeUri(s.ServerUri,
+                authUrl = BTCPayServerClient.GenerateAuthorizeUri(tester.PayTester.ServerUri,
                     new[] { Policies.CanModifyStoreSettings, Policies.CanModifyServerSettings }, false, true,  applicationDetails: (null, new Uri(callbackUrl))).ToString();
 
                 s.Driver.Navigate().GoToUrl(authUrl);
@@ -164,7 +159,7 @@ namespace BTCPayServer.Tests
                     (await apiKeyRepo.GetKey(accessToken)).GetBlob().Permissions);
 
                 //let's test the app identifier system
-                authUrl = BTCPayServerClient.GenerateAuthorizeUri(s.ServerUri,
+                authUrl = BTCPayServerClient.GenerateAuthorizeUri(tester.PayTester.ServerUri,
                     new[] { Policies.CanModifyStoreSettings, Policies.CanModifyServerSettings }, false, true, (appidentifier, new Uri(callbackUrl))).ToString();
 
                 //if it's the same, go to the confirm page
@@ -173,7 +168,7 @@ namespace BTCPayServer.Tests
                 Assert.Equal(callbackUrl, s.Driver.Url);
                 
                 //same app but different redirect = nono
-                authUrl = BTCPayServerClient.GenerateAuthorizeUri(s.ServerUri,
+                authUrl = BTCPayServerClient.GenerateAuthorizeUri(tester.PayTester.ServerUri,
                     new[] { Policies.CanModifyStoreSettings, Policies.CanModifyServerSettings }, false, true, (appidentifier, new Uri("https://international.local/callback"))).ToString();
                 
                 s.Driver.Navigate().GoToUrl(authUrl);

BTCPayServer.Tests/BTCPayServer.Tests.csproj

@@ -19,11 +19,11 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
-    <PackageReference Include="Newtonsoft.Json.Schema" Version="3.0.14" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.6.1" />
+    <PackageReference Include="Newtonsoft.Json.Schema" Version="3.0.13" />
     <PackageReference Include="Selenium.Support" Version="3.141.0" />
     <PackageReference Include="Selenium.WebDriver" Version="3.141.0" />
-    <PackageReference Include="Selenium.WebDriver.ChromeDriver" Version="94.0.4606.6100" />
+    <PackageReference Include="Selenium.WebDriver.ChromeDriver" Version="88.0.4324.9600" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.2">
       <PrivateAssets>all</PrivateAssets>

BTCPayServer.Tests/BTCPayServerTester.cs

@@ -85,7 +85,7 @@ namespace BTCPayServer.Tests
 
         public HashSet<string> Chains { get; set; } = new HashSet<string>() { "BTC" };
         public bool UseLightning { get; set; }
-        public bool CheatMode { get; set; } = true;
+        public bool AllowAdminRegistration { get; set; } = true;
         public bool DisableRegistration { get; set; } = false;
         public async Task StartAsync()
         {
@@ -128,13 +128,13 @@ namespace BTCPayServer.Tests
                 config.AppendLine($"lbtc.explorer.url={LBTCNBXplorerUri.AbsoluteUri}");
                 config.AppendLine($"lbtc.explorer.cookiefile=0");
             }
-            if (CheatMode)
-                config.AppendLine("cheatmode=1");
+            if (AllowAdminRegistration)
+                config.AppendLine("allow-admin-registration=1");
 
             config.AppendLine($"torrcfile={TestUtils.GetTestDataFullPath("Tor/torrc")}");
             config.AppendLine($"socksendpoint={SocksEndpoint}");
             config.AppendLine($"debuglog=debug.log");
-            config.AppendLine($"nocsp={NoCSP.ToString().ToLowerInvariant()}");
+
 
             if (!string.IsNullOrEmpty(SSHPassword) && string.IsNullOrEmpty(SSHKeyFile))
                 config.AppendLine($"sshpassword={SSHPassword}");
@@ -167,7 +167,6 @@ namespace BTCPayServer.Tests
                             l.SetMinimumLevel(LogLevel.Information)
                             .AddFilter("Microsoft", LogLevel.Error)
                             .AddFilter("Hangfire", LogLevel.Error)
-                            .AddFilter("Fido2NetLib.DistributedCacheMetadataService", LogLevel.Error)
                             .AddProvider(Logs.LogProvider);
                         });
                     })
@@ -198,7 +197,6 @@ namespace BTCPayServer.Tests
 
                 coinAverageMock = new MockRateProvider();
                 coinAverageMock.ExchangeRates.Add(new PairRate(CurrencyPair.Parse("BTC_USD"), new BidAsk(5000m)));
-                coinAverageMock.ExchangeRates.Add(new PairRate(CurrencyPair.Parse("BTC_EUR"), new BidAsk(4000m)));
                 coinAverageMock.ExchangeRates.Add(new PairRate(CurrencyPair.Parse("BTC_CAD"), new BidAsk(4500m)));
                 coinAverageMock.ExchangeRates.Add(new PairRate(CurrencyPair.Parse("BTC_LTC"), new BidAsk(162m)));
                 coinAverageMock.ExchangeRates.Add(new PairRate(CurrencyPair.Parse("LTC_USD"), new BidAsk(500m)));
@@ -284,8 +282,6 @@ namespace BTCPayServer.Tests
         public string SSHPassword { get; internal set; }
         public string SSHKeyFile { get; internal set; }
         public string SSHConnection { get; set; }
-        public bool NoCSP { get; set; }
-
         public T GetController<T>(string userId = null, string storeId = null, bool isAdmin = false) where T : Controller
         {
             var context = new DefaultHttpContext();

BTCPayServer.Tests/CheckoutUITests.cs

@@ -31,7 +31,7 @@ namespace BTCPayServer.Tests
                 s.RegisterNewUser();
                 var store = s.CreateNewStore();
                 s.AddDerivationScheme("BTC");
-                s.GoToStore(store.storeId, StoreNavPages.CheckoutAppearance);
+                s.GoToStore(store.storeId, StoreNavPages.Checkout);
                 s.Driver.FindElement(By.Id("RequiresRefundEmail")).Click();
                 s.Driver.FindElement(By.Name("command")).Click();
 
@@ -70,68 +70,6 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact(Timeout = TestTimeout)]
-        public async Task CanHandleRefundEmailForm2()
-        {
-
-            using (var s = SeleniumTester.Create())
-            {
-                // Prepare user account and store
-                await s.StartAsync();
-                s.GoToRegister();
-                s.RegisterNewUser();
-                var store = s.CreateNewStore();
-                s.AddDerivationScheme("BTC");
-
-                // Now create an invoice that requires a refund email
-                var invoice = s.CreateInvoice(store.storeName, 100, "USD", "", null, true);
-                s.GoToInvoiceCheckout(invoice);
-
-                var emailInput = s.Driver.FindElement(By.Id("emailAddressFormInput"));
-                Assert.True(emailInput.Displayed);
-
-                emailInput.SendKeys("a@g.com");
-
-                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"));
-
-                s.GoToHome();
-
-                // Now create an invoice that doesn't require a refund email
-                s.CreateInvoice(store.storeName, 100, "USD", "", null, false);
-                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.AssertElementNotFound(By.Id("emailAddressFormInput"));
-                s.Driver.Navigate().Refresh();
-                s.Driver.AssertElementNotFound(By.Id("emailAddressFormInput"));
-
-                s.GoToHome();
-
-                // Now create an invoice that requires refund email but already has one set, email input shouldn't show up
-                s.CreateInvoice(store.storeName, 100, "USD", "a@g.com", null, true);
-                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.AssertElementNotFound(By.Id("emailAddressFormInput"));
-                s.Driver.Navigate().Refresh();
-                s.Driver.AssertElementNotFound(By.Id("emailAddressFormInput"));
-            }
-        }
-
         [Fact(Timeout = TestTimeout)]
         public async Task CanUseLanguageDropdown()
         {
@@ -164,7 +102,7 @@ namespace BTCPayServer.Tests
 
         [Fact(Timeout = TestTimeout)]
         [Trait("Lightning", "Lightning")]
-        public async Task CanSetDefaultPaymentMethod()
+        public async Task CanUseLightningSatsFeature()
         {
             using (var s = SeleniumTester.Create())
             {
@@ -174,37 +112,15 @@ namespace BTCPayServer.Tests
                 s.RegisterNewUser(true);
                 var store = s.CreateNewStore();
                 s.AddLightningNode();
-                s.AddDerivationScheme("BTC");
-
-                var invoiceId = s.CreateInvoice(store.storeName, defaultPaymentMethod: "BTC_LightningLike");
-                s.GoToInvoiceCheckout(invoiceId);
-
-                Assert.Equal("Bitcoin (Lightning) (BTC)", s.Driver.FindElement(By.ClassName("payment__currencies")).Text);
-                s.Driver.Quit();
-            }
-        }
-
-        [Fact(Timeout = TestTimeout)]
-        [Trait("Lightning", "Lightning")]
-        public async Task CanUseLightningSatsFeature()
-        {
-            using (var s = SeleniumTester.Create())
-            {
-                s.Server.ActivateLightning();
-                await s.StartAsync();
-                s.GoToRegister();
-                s.RegisterNewUser(true);
-                (string storeName, string storeId) = s.CreateNewStore();
-                s.AddLightningNode();
-                s.GoToStore(storeId);
-                s.Driver.FindElement(By.Id("Modify-LightningBTC")).Click();
+                s.GoToStore(store.storeId, StoreNavPages.Checkout);
                 s.Driver.SetCheckbox(By.Id("LightningAmountInSatoshi"), true);
-                s.Driver.FindElement(By.Id("save")).Click();
-                Assert.Contains("BTC Lightning settings successfully updated", s.FindAlertMessage().Text);
-                
-                var invoiceId = s.CreateInvoice(storeName, 10, "USD", "a@g.com");
+                var command = s.Driver.FindElement(By.Name("command"));
+
+                command.Click();
+                var invoiceId = s.CreateInvoice(store.storeName, 10, "USD", "a@g.com");
                 s.GoToInvoiceCheckout(invoiceId);
                 Assert.Contains("Sats", s.Driver.FindElement(By.ClassName("payment__currencies_noborder")).Text);
+
             }
         }
 
@@ -222,7 +138,7 @@ namespace BTCPayServer.Tests
                 var invoiceId = s.CreateInvoice(store.storeId, 0.001m, "BTC", "a@x.com");
                 var invoice = await s.Server.PayTester.InvoiceRepository.GetInvoice(invoiceId);
                 s.Driver.Navigate()
-                    .GoToUrl(new Uri(s.ServerUri, $"tests/index.html?invoice={invoiceId}"));
+                    .GoToUrl(new Uri(s.Server.PayTester.ServerUri, $"tests/index.html?invoice={invoiceId}"));
                 TestUtils.Eventually(() =>
                 {
                     Assert.True(s.Driver.FindElement(By.Name("btcpay")).Displayed);
@@ -243,7 +159,7 @@ namespace BTCPayServer.Tests
                 closebutton.Click();
                 s.Driver.AssertElementNotFound(By.Name("btcpay"));
                 Assert.Equal(s.Driver.Url,
-                    new Uri(s.ServerUri, $"tests/index.html?invoice={invoiceId}").ToString());
+                    new Uri(s.Server.PayTester.ServerUri, $"tests/index.html?invoice={invoiceId}").ToString());
             }
         }
     }

BTCPayServer.Tests/CoinSwitchTests.cs

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

BTCPayServer.Tests/CrowdfundTests.cs

@@ -23,7 +23,7 @@ namespace BTCPayServer.Tests
             Logs.LogProvider = new XUnitLogProvider(helper);
         }
 
-        [Fact(Timeout = LongRunningTestTimeout)]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
         public async Task CanCreateAndDeleteCrowdfundApp()
         {
@@ -38,8 +38,8 @@ namespace BTCPayServer.Tests
                 var apps2 = user2.GetController<AppsController>();
                 var vm = Assert.IsType<CreateAppViewModel>(Assert.IsType<ViewResult>(apps.CreateApp().Result).Model);
                 Assert.NotNull(vm.SelectedAppType);
-                Assert.Null(vm.AppName);
-                vm.AppName = "test";
+                Assert.Null(vm.Name);
+                vm.Name = "test";
                 vm.SelectedAppType = AppType.Crowdfund.ToString();
                 var redirectToAction = Assert.IsType<RedirectToActionResult>(apps.CreateApp(vm).Result);
                 Assert.Equal(nameof(apps.UpdateCrowdfund), redirectToAction.ActionName);
@@ -63,7 +63,7 @@ namespace BTCPayServer.Tests
 
 
 
-        [Fact(Timeout = LongRunningTestTimeout)]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
         public async Task CanContributeOnlyWhenAllowed()
         {
@@ -75,7 +75,7 @@ namespace BTCPayServer.Tests
                 user.RegisterDerivationScheme("BTC");
                 var apps = user.GetController<AppsController>();
                 var vm = Assert.IsType<CreateAppViewModel>(Assert.IsType<ViewResult>(apps.CreateApp().Result).Model);
-                vm.AppName = "test";
+                vm.Name = "test";
                 vm.SelectedAppType = AppType.Crowdfund.ToString();
                 Assert.IsType<RedirectToActionResult>(apps.CreateApp(vm).Result);
                 var appId = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps().Result).Model)
@@ -155,7 +155,7 @@ namespace BTCPayServer.Tests
             }
         }
 
-        [Fact(Timeout = LongRunningTestTimeout)]
+        [Fact(Timeout = TestTimeout)]
         [Trait("Integration", "Integration")]
         public async Task CanComputeCrowdfundModel()
         {
@@ -163,12 +163,12 @@ namespace BTCPayServer.Tests
             {
                 await tester.StartAsync();
                 var user = tester.NewAccount();
-                await user.GrantAccessAsync();
+                user.GrantAccess();
                 user.RegisterDerivationScheme("BTC");
-                await user.SetNetworkFeeMode(NetworkFeeMode.Never);
+                user.ModifyStore(s => s.NetworkFeeMode = NetworkFeeMode.Never);
                 var apps = user.GetController<AppsController>();
                 var vm = Assert.IsType<CreateAppViewModel>(Assert.IsType<ViewResult>(apps.CreateApp().Result).Model);
-                vm.AppName = "test";
+                vm.Name = "test";
                 vm.SelectedAppType = AppType.Crowdfund.ToString();
                 Assert.IsType<RedirectToActionResult>(apps.CreateApp(vm).Result);
                 var appId = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps().Result).Model)

BTCPayServer.Tests/Dockerfile

@@ -1,4 +1,4 @@
-FROM mcr.microsoft.com/dotnet/core/sdk:3.1.413 AS builder
+FROM mcr.microsoft.com/dotnet/core/sdk:3.1.202 AS builder
 
 RUN apt-get update && apt-get install -y --no-install-recommends chromium-driver \
     && rm -rf /var/lib/apt/lists/*

BTCPayServer.Tests/Extensions.cs

@@ -7,7 +7,6 @@ using Microsoft.AspNetCore.Mvc;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Serialization;
 using OpenQA.Selenium;
-using OpenQA.Selenium.Support.Extensions;
 using OpenQA.Selenium.Support.UI;
 using Xunit;
 
@@ -28,12 +27,46 @@ namespace BTCPayServer.Tests
 
         public static void AssertNoError(this IWebDriver driver)
         {
-            Assert.NotEmpty(driver.FindElements(By.ClassName("navbar-brand")));
-            if (!driver.PageSource.Contains("alert-danger")) return;
-            foreach (var dangerAlert in driver.FindElements(By.ClassName("alert-danger")))
-                Assert.False(dangerAlert.Displayed, $"No alert should be displayed, but found this on {driver.Url}: {dangerAlert.Text}");
+            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
+            {
+                StringBuilder builder = new StringBuilder();
+                builder.AppendLine();
+                foreach (var logKind in new[] { LogType.Browser, LogType.Client, LogType.Driver, LogType.Server })
+                {
+                    try
+                    {
+                        var logs = driver.Manage().Logs.GetLog(logKind);
+                        builder.AppendLine($"Selenium [{logKind}]:");
+                        foreach (var entry in logs)
+                        {
+                            builder.AppendLine($"[{entry.Level}]: {entry.Message}");
+                        }
+                    }
+                    catch
+                    {
+                        // ignored
+                    }
+
+                    builder.AppendLine("---------");
+                }
+                Logs.Tester.LogInformation(builder.ToString());
+                builder = new StringBuilder();
+                builder.AppendLine("Selenium [Sources]:");
+                builder.AppendLine(driver.PageSource);
+                builder.AppendLine("---------");
+                Logs.Tester.LogInformation(builder.ToString());
+                throw;
+            }
         }
-        
         public static T AssertViewModel<T>(this IActionResult result)
         {
             Assert.NotNull(result);
@@ -48,22 +81,6 @@ namespace BTCPayServer.Tests
             return Assert.IsType<T>(vr.Model);
         }
 
-        // Sometimes, selenium is flaky...
-        public static IWebElement FindElementUntilNotStaled(this IWebDriver driver, By by, Action<IWebElement> act)
-        {
-            retry:
-            try
-            {
-                var el = driver.FindElement(by);
-                act(el);
-                return el;
-            }
-            catch (StaleElementReferenceException)
-            {
-                goto retry;
-            }
-        }
-
         public static void AssertElementNotFound(this IWebDriver driver, By by)
         {
             DateTimeOffset now = DateTimeOffset.Now;
@@ -95,13 +112,6 @@ namespace BTCPayServer.Tests
             wait.Until(d=>((IJavaScriptExecutor)d).ExecuteScript("return document.readyState").Equals("complete"));
             wait.Until(d=>((IJavaScriptExecutor)d).ExecuteScript("return typeof(jQuery) === 'undefined' || jQuery.active === 0").Equals(true));
         }
-        
-        // Open collapse via JS, because if we click the link it triggers the toggle animation.
-        // This leads to Selenium trying to click the button while it is moving resulting in an error.
-        public static void ToggleCollapse(this IWebDriver driver, string collapseId)
-        {
-            driver.ExecuteJavaScript($"document.getElementById('{collapseId}').classList.add('show')");
-        }
 
         public static IWebElement WaitForElement(this IWebDriver driver, By selector)
         {
@@ -119,19 +129,10 @@ namespace BTCPayServer.Tests
             var wait = new WebDriverWait(driver, SeleniumTester.ImplicitWait);
             wait.UntilJsIsReady();
 
-            int retriesLeft = 4;
-            retry:
-            try
-            {
-                var el = driver.FindElement(selector);
-                wait.Until(d => el.Displayed && el.Enabled);
-                el.Click();
-            }
-            catch (ElementClickInterceptedException) when (retriesLeft > 0)
-            {
-                retriesLeft--;
-                goto retry;
-            }
+            var el = driver.FindElement(selector);
+            wait.Until(d => el.Displayed && el.Enabled);
+            el.Click();
+
             wait.UntilJsIsReady();
         }
 
@@ -140,14 +141,7 @@ namespace BTCPayServer.Tests
             var element = driver.FindElement(selector);
             if ((value && !element.Selected) || (!value && element.Selected))
             {
-                try
-                {
-                    driver.WaitForAndClick(selector);
-                }
-                catch (ElementClickInterceptedException)
-                {
-                    element.SendKeys(" ");
-                }
+                driver.WaitForAndClick(selector);
             }
 
             if (value != element.Selected)

BTCPayServer.Tests/LanguageServiceTests.cs

@@ -1,52 +0,0 @@
-using System.Threading.Tasks;
-using BTCPayServer.Services;
-using BTCPayServer.Tests.Logging;
-using Xunit;
-using Xunit.Abstractions;
-
-namespace BTCPayServer.Tests
-{
-    public class LanguageServiceTests
-    {
-        public const int TestTimeout = TestUtils.TestTimeout;
-        public LanguageServiceTests(ITestOutputHelper helper)
-        {
-            Logs.Tester = new XUnitLog(helper) { Name = "Tests" };
-            Logs.LogProvider = new XUnitLogProvider(helper);
-        }
-
-        [Fact(Timeout = TestTimeout)]
-        [Trait("Integration", "Integration")]
-        public async Task CanAutoDetectLanguage()
-        {
-            using (var tester = ServerTester.Create())
-            {
-                await tester.StartAsync();
-                var languageService = tester.PayTester.GetService<LanguageService>();
-                
-                // Most common format. First option does not have a quality score. Others do in descending order.
-                // Result should be nl-NL (because the default weight is 1 for nl)
-                var lang1 = languageService.FindLanguageInAcceptLanguageHeader("nl,fr;q=0.7,en;q=0.5");
-                Assert.NotNull(lang1);
-                Assert.Equal("nl-NL", lang1?.Code);
-
-                // Most common format. First option does not have a quality score. Others do in descending order. This time the first option includes a country.
-                // Result should be nl-NL (because the default weight is 1 for nl-BE and it does not exist in BTCPay Server, but nl-NL does and applies too for language "nl")
-                var lang2 = languageService.FindLanguageInAcceptLanguageHeader("nl-BE,fr;q=0.7,en;q=0.5");
-                Assert.NotNull(lang2);
-                Assert.Equal("nl-NL", lang2?.Code);
-
-                // Unusual format, but still valid. All values have a quality score and not ordered.
-                // Result should be fr-FR (because 0.7 is the highest quality score)
-                var lang3 = languageService.FindLanguageInAcceptLanguageHeader("nl;q=0.1,fr;q=0.7,en;q=0.5");
-                Assert.NotNull(lang3);
-                Assert.Equal("fr-FR", lang3?.Code);
-
-                // Unusual format, but still valid. Some language is given that we don't have and a wildcard for everything else. 
-                // Result should be NULL, because "xx" does not exist and * is a wildcard and has no meaning.
-                var lang4 = languageService.FindLanguageInAcceptLanguageHeader("xx,*;q=0.5");
-                Assert.Null(lang4);
-            }
-        }
-    }
-}

BTCPayServer.Tests/POSTests.cs

@@ -1,71 +0,0 @@
-using System.Threading.Tasks;
-using BTCPayServer.Controllers;
-using BTCPayServer.Models.AppViewModels;
-using BTCPayServer.Services.Apps;
-using BTCPayServer.Tests.Logging;
-using Microsoft.AspNetCore.Mvc;
-using Xunit;
-using Xunit.Abstractions;
-using static BTCPayServer.Tests.UnitTest1;
-
-namespace BTCPayServer.Tests
-{
-    public class POSTests
-    {
-        public POSTests(ITestOutputHelper helper)
-        {
-            Logs.Tester = new XUnitLog(helper) { Name = "Tests" };
-            Logs.LogProvider = new XUnitLogProvider(helper);
-        }
-
-        [Fact(Timeout = LongRunningTestTimeout)]
-        public async Task CanUsePoSApp1()
-        {
-            using (var tester = ServerTester.Create())
-            {
-                await tester.StartAsync();
-                var user = tester.NewAccount();
-                user.GrantAccess();
-                user.RegisterDerivationScheme("BTC");
-                var apps = user.GetController<AppsController>();
-                var vm = Assert.IsType<CreateAppViewModel>(Assert.IsType<ViewResult>(apps.CreateApp().Result).Model);
-                vm.AppName = "test";
-                vm.SelectedAppType = AppType.PointOfSale.ToString();
-                Assert.IsType<RedirectToActionResult>(apps.CreateApp(vm).Result);
-                var appId = Assert.IsType<ListAppsViewModel>(Assert.IsType<ViewResult>(apps.ListApps().Result).Model)
-                    .Apps[0].Id;
-                var vmpos = Assert.IsType<UpdatePointOfSaleViewModel>(Assert
-                    .IsType<ViewResult>(apps.UpdatePointOfSale(appId).Result).Model);
-                vmpos.Template = @"
-apple:
-  price: 5.0
-  title: good apple
-  disabled: true
-orange:
-  price: 10.0
-donation:
-  price: 1.02
-  custom: true
-";
-                Assert.IsType<RedirectToActionResult>(apps.UpdatePointOfSale(appId, vmpos).Result);
-                vmpos = Assert.IsType<UpdatePointOfSaleViewModel>(Assert
-                    .IsType<ViewResult>(apps.UpdatePointOfSale(appId).Result).Model);
-                var publicApps = user.GetController<AppsPublicController>();
-                var vmview =
-                    Assert.IsType<ViewPointOfSaleViewModel>(Assert
-                        .IsType<ViewResult>(publicApps.ViewPointOfSale(appId, PosViewType.Cart).Result).Model);
-
-                // apple shouldn't be available since we it's set to "disabled: true" above
-                Assert.Equal(2, vmview.Items.Length);
-                Assert.Equal("orange", vmview.Items[0].Title);
-                Assert.Equal("donation", vmview.Items[1].Title);
-                // orange is available
-                Assert.IsType<RedirectToActionResult>(publicApps
-                    .ViewPointOfSale(appId, PosViewType.Cart, 0, null, null, null, null, "orange").Result);
-                // apple is not found
-                Assert.IsType<NotFoundResult>(publicApps
-                    .ViewPointOfSale(appId, PosViewType.Cart, 0, null, null, null, null, "apple").Result);
-            }
-        }
-    }
-}