Add translations

Plugins: Add a way for LightningClient to be more customizable (Fix #6467)

.circleci/config.yml

@@ -2,7 +2,7 @@ version: 2
 jobs:
   fast_tests:
     machine:
-      image: ubuntu-2004:202111-02
+      image: ubuntu-2004:2024.11.1
     steps:
       - checkout
       - run:
@@ -10,7 +10,7 @@ jobs:
             cd .circleci && ./run-tests.sh "Fast=Fast|ThirdParty=ThirdParty" && ./can-build.sh
   selenium_tests:
     machine:
-      image: ubuntu-2004:202111-02
+      image: ubuntu-2004:2024.11.1
     steps:
       - checkout
       - run:
@@ -18,7 +18,7 @@ jobs:
             cd .circleci && ./run-tests.sh "Selenium=Selenium"
   integration_tests:
     machine:
-      image: ubuntu-2004:202111-02
+      image: ubuntu-2004:2024.11.1
     steps:
       - checkout
       - run:
@@ -26,7 +26,7 @@ jobs:
             cd .circleci && ./run-tests.sh "Integration=Integration"
   trigger_docs_build:
     machine:
-      image: ubuntu-2004:202111-02
+      image: ubuntu-2004:2024.11.1
     steps:
       - run:
           command: |

.circleci/run-tests.sh

@@ -2,8 +2,8 @@
 set -e
 
 cd ../BTCPayServer.Tests
-docker-compose -v
-docker-compose -f "docker-compose.altcoins.yml" down --v
+docker-compose --version
+docker-compose -f "docker-compose.altcoins.yml" down -v
 
 # For some reason, docker-compose pull fails time to time, so we try several times
 n=0

.gitignore

@@ -266,6 +266,7 @@ paket-files/
 # JetBrains Rider
 .idea/
 *.sln.iml
+.run
 
 # CodeRush
 .cr/

BTCPayServer.Abstractions/BTCPayServer.Abstractions.csproj

@@ -32,8 +32,8 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="HtmlSanitizer" Version="8.0.838" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.6" />
-    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="8.0.4" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.11" />
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="8.0.11" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\BTCPayServer.Client\BTCPayServer.Client.csproj" />

BTCPayServer.Abstractions/Contracts/IFileService.cs

@@ -2,6 +2,7 @@
 using System;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Http;
+using BTCPayServer.Abstractions.Models;
 
 namespace BTCPayServer.Abstractions.Contracts;
 
@@ -14,4 +15,5 @@ public interface IFileService
     Task<string?> GetTemporaryFileUrl(Uri baseUri, string fileId, DateTimeOffset expiry,
         bool isDownload);
     Task RemoveFile(string fileId, string userId);
+    Task<UploadImageResultModel> UploadImage(IFormFile file, string userId, long maxFileSizeInBytes = 1_000_000);
 }

BTCPayServer.Abstractions/Contracts/ISyncSummaryProvider.cs

@@ -12,7 +12,7 @@ namespace BTCPayServer.Abstractions.Contracts
 
     public interface ISyncStatus
     {
-        public string CryptoCode { get; set; }
+        public string PaymentMethodId { get; set; }
         public bool Available { get; }
     }
 }

BTCPayServer.Abstractions/Extensions/ITempDataDictionaryExtensions.cs

@@ -8,6 +8,14 @@ namespace BTCPayServer.Abstractions.Extensions;
 
 public static class SetStatusMessageModelExtensions
 {
+    public static void SetStatusSuccess(this ITempDataDictionary tempData, string statusMessage)
+    {
+        tempData.SetStatusMessageModel(new StatusMessageModel
+        {
+            Severity = StatusMessageModel.StatusSeverity.Success,
+            Message = statusMessage
+        });
+    }
     public static void SetStatusMessageModel(this ITempDataDictionary tempData, StatusMessageModel statusMessage)
     {
         if (statusMessage == null)
@@ -26,19 +34,14 @@ public static class SetStatusMessageModelExtensions
         tempData.TryGetValue("StatusMessageModel", out var model);
         if (successMessage != null || errorMessage != null)
         {
-            var parsedModel = new StatusMessageModel();
-            parsedModel.Message = (string)successMessage ?? (string)errorMessage;
-            if (successMessage != null)
+            var parsedModel = new StatusMessageModel
             {
-                parsedModel.Severity = StatusMessageModel.StatusSeverity.Success;
-            }
-            else
-            {
-                parsedModel.Severity = StatusMessageModel.StatusSeverity.Error;
-            }
+                Message = (string)successMessage ?? (string)errorMessage,
+                Severity = successMessage != null ? StatusMessageModel.StatusSeverity.Success : StatusMessageModel.StatusSeverity.Error
+            };
             return parsedModel;
         }
-        else if (model != null && model is string str)
+        if (model is string str)
         {
             return JObject.Parse(str).ToObject<StatusMessageModel>();
         }

BTCPayServer.Abstractions/Extensions/ViewsRazor.cs

@@ -55,7 +55,7 @@ namespace BTCPayServer.Abstractions.Extensions
             viewData[ACTIVE_CATEGORY_KEY] = activeCategory;
         }
 
-        public static bool IsActiveCategory(this ViewDataDictionary viewData, string category, object id = null)
+        public static bool IsCategoryActive(this ViewDataDictionary viewData, string category, object id = null)
         {
             if (!viewData.ContainsKey(ACTIVE_CATEGORY_KEY)) return false;
             var activeId = viewData[ACTIVE_ID_KEY];
@@ -65,12 +65,12 @@ namespace BTCPayServer.Abstractions.Extensions
             return categoryMatch && idMatch;
         }
 
-        public static bool IsActiveCategory<T>(this ViewDataDictionary viewData, T category, object id = null)
+        public static bool IsCategoryActive<T>(this ViewDataDictionary viewData, T category, object id = null)
         {
-            return IsActiveCategory(viewData, category.ToString(), id);
+            return IsCategoryActive(viewData, category.ToString(), id);
         }
 
-        public static bool IsActivePage(this ViewDataDictionary viewData, string page, string category, object id = null)
+        public static bool IsPageActive(this ViewDataDictionary viewData, string page, string category, object id = null)
         {
             if (!viewData.ContainsKey(ACTIVE_PAGE_KEY)) return false;
             var activeId = viewData[ACTIVE_ID_KEY];
@@ -82,7 +82,7 @@ namespace BTCPayServer.Abstractions.Extensions
             return categoryAndPageMatch && idMatch;
         }
         
-        public static bool IsActivePage<T>(this ViewDataDictionary viewData, IEnumerable<T> pages, object id = null)
+        public static bool IsPageActive<T>(this ViewDataDictionary viewData, IEnumerable<T> pages, object id = null)
             where T : IConvertible
         {
             return pages.Any(page => ActivePageClass(viewData, page.ToString(), page.GetType().ToString(), id) == ACTIVE_CLASS);
@@ -95,7 +95,7 @@ namespace BTCPayServer.Abstractions.Extensions
 
         public static string ActiveCategoryClass(this ViewDataDictionary viewData, string category, object id = null)
         {
-            return IsActiveCategory(viewData, category, id) ? ACTIVE_CLASS : null;
+            return IsCategoryActive(viewData, category, id) ? ACTIVE_CLASS : null;
         }
 
         public static string ActivePageClass<T>(this ViewDataDictionary viewData, T page, object id = null)
@@ -106,12 +106,42 @@ namespace BTCPayServer.Abstractions.Extensions
 
         public static string ActivePageClass(this ViewDataDictionary viewData, string page, string category, object id = null)
         {
-            return IsActivePage(viewData, page, category, id) ? ACTIVE_CLASS : null;
+            return IsPageActive(viewData, page, category, id) ? ACTIVE_CLASS : null;
         }
-        
+
         public static string ActivePageClass<T>(this ViewDataDictionary viewData, IEnumerable<T> pages, object id = null) where T : IConvertible
         {
-            return IsActivePage(viewData, pages, id) ? ACTIVE_CLASS : null;
+            return IsPageActive(viewData, pages, id) ? ACTIVE_CLASS : null;
+        }
+
+        [Obsolete("Use ActiveCategoryClass instead")]
+        public static string IsActiveCategory<T>(this ViewDataDictionary viewData, T category, object id = null)
+        {
+            return ActiveCategoryClass(viewData, category, id);
+        }
+
+        [Obsolete("Use ActiveCategoryClass instead")]
+        public static string IsActiveCategory(this ViewDataDictionary viewData, string category, object id = null)
+        {
+            return ActiveCategoryClass(viewData, category, id);
+        }
+
+        [Obsolete("Use ActivePageClass instead")]
+        public static string IsActivePage<T>(this ViewDataDictionary viewData, T page, object id = null) where T : IConvertible
+        {
+            return ActivePageClass(viewData, page, id);
+        }
+
+        [Obsolete("Use ActivePageClass instead")]
+        public static string IsActivePage<T>(this ViewDataDictionary viewData, IEnumerable<T> pages, object id = null) where T : IConvertible
+        {
+            return ActivePageClass(viewData, pages, id);
+        }
+
+        [Obsolete("Use ActivePageClass instead")]
+        public static string IsActivePage(this ViewDataDictionary viewData, string page, string category, object id = null)
+        {
+            return ActivePageClass(viewData, page, category, id);
         }
 
         public static HtmlString ToBrowserDate(this DateTimeOffset date, string netFormat, string jsDateFormat = "short", string jsTimeFormat = "short")

BTCPayServer.Abstractions/Models/StatusMessageModel.cs

@@ -14,14 +14,6 @@ namespace BTCPayServer.Abstractions.Models
 
         public string SeverityCSS => ToString(Severity);
 
-        private void ParseNonJsonStatus(string s)
-        {
-            Message = s;
-            Severity = s.StartsWith("Error", StringComparison.InvariantCultureIgnoreCase)
-                ? StatusSeverity.Error
-                : StatusSeverity.Success;
-        }
-
         public static string ToString(StatusSeverity severity)
         {
             switch (severity)

BTCPayServer.Abstractions/Models/UploadImageResultModel.cs

@@ -0,0 +1,16 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using BTCPayServer.Abstractions.Contracts;
+
+namespace BTCPayServer.Abstractions.Models;
+
+public class UploadImageResultModel
+{
+    public bool Success { get; set; }
+    public string Response { get; set; } = string.Empty;
+    public IStoredFile? StoredFile { get; set; }
+}

BTCPayServer.Abstractions/Services/UIExtension.cs

@@ -1,9 +1,11 @@
+using System;
 using BTCPayServer.Abstractions.Contracts;
 
 namespace BTCPayServer.Abstractions.Services
 {
     public class UIExtension : IUIExtension
     {
+        [Obsolete("Use extension method BTCPayServer.Extensions.AddUIExtension(this IServiceCollection services, string location, string partialViewName) instead")]
         public UIExtension(string partial, string location)
         {
             Partial = partial;

BTCPayServer.Client/App/IBTCPayAppHubClient.cs

@@ -0,0 +1,139 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using BTCPayServer.Client.Models;
+using BTCPayServer.Lightning;
+using NBitcoin;
+
+namespace BTCPayServer.Client.App;
+
+//methods available on the hub in the client
+public interface IBTCPayAppHubClient
+{
+    Task NotifyServerEvent(ServerEvent ev);
+    Task NotifyNetwork(string network);
+    Task NotifyServerNode(string nodeInfo);
+    Task TransactionDetected(TransactionDetectedRequest request);
+    Task NewBlock(string block);
+    Task StartListen(string key);
+
+    Task<LightningInvoice> CreateInvoice(string key, CreateLightningInvoiceRequest createLightningInvoiceRequest);
+    Task<LightningInvoice?> GetLightningInvoice(string key, uint256 paymentHash);
+    Task<LightningPayment?> GetLightningPayment(string key, uint256 paymentHash);
+    Task CancelInvoice(string key, uint256 paymentHash);
+    Task<List<LightningPayment>> GetLightningPayments(string key, ListPaymentsParams request);
+    Task<List<LightningInvoice>> GetLightningInvoices(string key, ListInvoicesParams request);
+    Task<PayResponse> PayInvoice(string key, string bolt11, long? amountMilliSatoshi);
+    Task MasterUpdated(long? deviceIdentifier);
+    Task<LightningNodeInformation> GetLightningNodeInfo(string key);
+    Task<LightningNodeBalance> GetLightningBalance(string key);
+}
+
+//methods available on the hub in the server
+public interface IBTCPayAppHubServer
+{
+    Task<bool> DeviceMasterSignal(long deviceIdentifier, bool active);
+    
+    Task<Dictionary<string,string>> Pair(PairRequest request);
+    Task<AppHandshakeResponse> Handshake(AppHandshake request);
+    Task<bool> BroadcastTransaction(string tx);
+    Task<decimal> GetFeeRate(int blockTarget);
+    Task<BestBlockResponse> GetBestBlock();
+    Task<TxInfoResponse> FetchTxsAndTheirBlockHeads(string identifier, string[] txIds, string[] outpoints);
+    Task<string> DeriveScript(string identifier);
+    Task TrackScripts(string identifier, string[] scripts);
+    Task<string> UpdatePsbt(string[] identifiers, string psbt);
+    Task<CoinResponse[]> GetUTXOs(string[] identifiers);
+    Task<Dictionary<string, TxResp[]>> GetTransactions(string[] identifiers);
+    Task SendInvoiceUpdate(LightningInvoice lightningInvoice);
+    Task<long?> GetCurrentMaster();
+}
+
+public class ServerEvent
+{
+    public string? Type { get; set; }
+    public string? StoreId { get; set; }
+    public string? UserId { get; set; }
+    public string? AppId { get; set; }
+    public string? InvoiceId { get; set; }
+    public string? Detail { get; set; }
+}
+
+public record TxResp
+{
+    public TxResp(long confirmations, long? height, decimal balanceChange, DateTimeOffset timestamp, string transactionId)
+    {
+        Confirmations = confirmations;
+        Height = height;
+        BalanceChange = balanceChange;
+        Timestamp = timestamp;
+        TransactionId = transactionId;
+    }
+
+    public long Confirmations { get; set; }
+    public long? Height { get; set; }
+    public decimal BalanceChange { get; set; }
+    public DateTimeOffset Timestamp { get; set; }
+    public string TransactionId { get; set; }
+    
+    public override string ToString()
+    {
+        return $"{{ Confirmations = {Confirmations}, Height = {Height}, BalanceChange = {BalanceChange}, Timestamp = {Timestamp}, TransactionId = {TransactionId} }}";
+    }
+}
+
+public class TransactionDetectedRequest
+{
+    public string? Identifier { get; set; }
+    public string? TxId { get; set; }
+    public string[]? SpentScripts { get; set; }
+    public string[]? ReceivedScripts { get; set; }
+    public bool Confirmed { get; set; }
+}
+
+public class CoinResponse
+{
+    public string? Identifier{ get; set; }
+    public bool Confirmed { get; set; }
+    public string? Script { get; set; }
+    public string? Outpoint { get; set; }
+    public decimal Value { get; set; }
+    public string? Path { get; set; }
+}
+
+public class TxInfoResponse
+{
+    public Dictionary<string,TransactionResponse>? Txs { get; set; }
+    public Dictionary<string,string>? BlockHeaders { get; set; }
+    public Dictionary<string,int>? BlockHeghts { get; set; }
+}
+
+public class TransactionResponse
+{
+    public string? BlockHash { get; set; }
+    public string? Transaction { get; set; }
+}
+
+public class BestBlockResponse
+{
+    public string? BlockHash { get; set; }
+    public int BlockHeight { get; set; }
+    public string? BlockHeader { get; set; }
+}
+
+public class AppHandshake
+{
+    public string[]? Identifiers { get; set; }
+}
+
+public class AppHandshakeResponse
+{
+    //response about identifiers being tracked successfully
+    public string[]? IdentifiersAcknowledged { get; set; }
+}
+
+public class PairRequest
+{
+    public Dictionary<string, string?> Derivations { get; set; } = new();
+}

BTCPayServer.Client/App/Models/AcceptInviteRequest.cs

@@ -0,0 +1,8 @@
+#nullable enable
+namespace BTCPayServer.Client.App.Models;
+
+public class AcceptInviteRequest
+{
+    public string? UserId { get; set; }
+    public string? Code { get; set; }
+}

BTCPayServer.Client/App/Models/AcceptInviteResult.cs

@@ -0,0 +1,10 @@
+#nullable enable
+namespace BTCPayServer.Client.App.Models;
+
+public class AcceptInviteResult
+{
+    public string? Email { get; set; }
+    public bool? RequiresUserApproval { get; set; }
+    public bool? EmailHasBeenConfirmed { get; set; }
+    public string? PasswordSetCode { get; set; }
+}

BTCPayServer.Client/App/Models/AccessTokenResult.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace BTCPayServer.Client.App.Models;
+
+public class AccessTokenResult
+{
+    public string AccessToken { get; set; }
+    public string RefreshToken { get; set; }
+    public DateTimeOffset Expiry { get; set; }
+}

BTCPayServer.Client/App/Models/AppInstanceInfo.cs

@@ -0,0 +1,13 @@
+#nullable enable
+namespace BTCPayServer.Client.App.Models;
+
+public class AppInstanceInfo
+{
+    public string BaseUrl { get; set; } = null!;
+    public string ServerName { get; set; } = null!;
+    public string? ContactUrl { get; set; }
+    public string? LogoUrl { get; set; }
+    public string? CustomThemeCssUrl { get; set; }
+    public string? CustomThemeExtension { get; set; }
+    public bool RegistrationEnabled { get; set; }
+}

BTCPayServer.Client/App/Models/AppUserInfo.cs

@@ -0,0 +1,44 @@
+#nullable enable
+using System.Collections.Generic;
+
+namespace BTCPayServer.Client.App.Models;
+
+public class AppUserInfo
+{
+    public string? UserId { get; set; }
+    public string? Email { get; set; }
+    public string? Name { get; set; }
+    public string? ImageUrl { get; set; }
+    public IEnumerable<string>? Roles { get; set; }
+    public IEnumerable<AppUserStoreInfo>? Stores { get; set; }
+
+    public void SetInfo(string email, string? name, string? imageUrl)
+    {
+        Email = email;
+        Name = name;
+        ImageUrl = imageUrl;
+    }
+
+    public static bool Equals(AppUserInfo? x, AppUserInfo? y)
+    {
+        if (ReferenceEquals(x, y)) return true;
+        if (ReferenceEquals(x, null)) return false;
+        if (ReferenceEquals(y, null)) return false;
+        if (x.GetType() != y.GetType()) return false;
+        return x.UserId == y.UserId && x.Email == y.Email &&
+               x.Name == y.Name && x.ImageUrl == y.ImageUrl &&
+               Equals(x.Roles, y.Roles) && Equals(x.Stores, y.Stores);
+    }
+}
+
+public class AppUserStoreInfo
+{
+    public string Id { get; set; } = null!;
+    public string? Name { get; set; }
+    public string? LogoUrl { get; set; }
+    public string? RoleId { get; set; }
+    public string? PosAppId { get; set; }
+    public string? DefaultCurrency { get; set; }
+    public bool Archived { get; set; }
+    public IEnumerable<string>? Permissions { get; set; }
+}

BTCPayServer.Client/App/Models/CreateStoreData.cs

@@ -0,0 +1,11 @@
+#nullable enable
+using System.Collections.Generic;
+
+namespace BTCPayServer.Client.App.Models;
+
+public class CreateStoreData
+{
+    public string? DefaultCurrency { get; set; }
+    public string? RecommendedExchangeId { get; set; }
+    public Dictionary<string, string>? Exchanges { get; set; }
+}

BTCPayServer.Client/BTCPayServer.Client.csproj

@@ -12,11 +12,11 @@
         <PackageLicenseExpression>MIT</PackageLicenseExpression>
         <RepositoryUrl>https://github.com/btcpayserver/btcpayserver</RepositoryUrl>
         <RepositoryType>git</RepositoryType>
-        <Configurations>Debug;Release;Altcoins-Debug;Altcoins-Release</Configurations>
+        <Configurations>Debug;Release</Configurations>
         <Platforms>AnyCPU</Platforms>
     </PropertyGroup>
   <PropertyGroup>
-    <Version Condition=" '$(Version)' == '' ">1.7.4</Version>
+    <Version Condition=" '$(Version)' == '' ">2.0.1</Version>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
@@ -30,8 +30,8 @@
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
   </ItemGroup>
     <ItemGroup>
-      <PackageReference Include="BTCPayServer.Lightning.Common" Version="1.5.1" />
-      <PackageReference Include="NBitcoin" Version="7.0.37" />
+      <PackageReference Include="BTCPayServer.Lightning.Common" Version="1.5.2" />
+      <PackageReference Include="NBitcoin" Version="7.0.46" />
       <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
     </ItemGroup>
   <ItemGroup>

BTCPayServer.Client/BTCPayServerClient.Apps.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
@@ -58,9 +59,33 @@ public partial class BTCPayServerClient
         return await SendHttpRequest<CrowdfundAppData>($"api/v1/apps/crowdfund/{appId}", null, HttpMethod.Get, token);
     }
 
+    public virtual async Task<AppSalesStats> GetAppSales(string appId, int numberOfDays = 7, CancellationToken token = default)
+    {
+        if (appId == null) throw new ArgumentNullException(nameof(appId));
+        var queryPayload = new Dictionary<string, object> { { nameof(numberOfDays), numberOfDays } };
+        return await SendHttpRequest<AppSalesStats>($"api/v1/apps/{appId}/sales", queryPayload, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<List<AppItemStats>> GetAppTopItems(string appId, int offset = 0, int count = 10, CancellationToken token = default)
+    {
+        if (appId == null) throw new ArgumentNullException(nameof(appId));
+        var queryPayload = new Dictionary<string, object> { { nameof(offset), offset }, { nameof(count), count } };
+        return await SendHttpRequest<List<AppItemStats>>($"api/v1/apps/{appId}/top-items", queryPayload, HttpMethod.Get, token);
+    }
+
     public virtual async Task DeleteApp(string appId, CancellationToken token = default)
     {
         if (appId == null) throw new ArgumentNullException(nameof(appId));
         await SendHttpRequest($"api/v1/apps/{appId}", null, HttpMethod.Delete, token);
     }
+
+    public virtual async Task<FileData> UploadAppItemImage(string appId, string filePath, string mimeType, CancellationToken token = default)
+    {
+        return await UploadFileRequest<FileData>($"api/v1/apps/{appId}/image", filePath, mimeType, "file", HttpMethod.Post, token);
+    }
+
+    public virtual async Task DeleteAppItemImage(string appId, string fileId, CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/apps/{appId}/image/{fileId}", null, HttpMethod.Delete, token);
+    }
 }

BTCPayServer.Client/BTCPayServerClient.Invoices.cs

@@ -46,9 +46,15 @@ public partial class BTCPayServerClient
         return await SendHttpRequest<InvoiceData>($"api/v1/stores/{storeId}/invoices/{invoiceId}", null, HttpMethod.Get, token);
     }
     public virtual async Task<InvoicePaymentMethodDataModel[]> GetInvoicePaymentMethods(string storeId, string invoiceId,
+        bool onlyAccountedPayments = true, bool includeSensitive = false,
         CancellationToken token = default)
     {
-        return await SendHttpRequest<InvoicePaymentMethodDataModel[]>($"api/v1/stores/{storeId}/invoices/{invoiceId}/payment-methods", null, HttpMethod.Get, token);
+        var queryPayload = new Dictionary<string, object>
+        {
+            { nameof(onlyAccountedPayments), onlyAccountedPayments },
+            { nameof(includeSensitive), includeSensitive }
+        };
+        return await SendHttpRequest<InvoicePaymentMethodDataModel[]>($"api/v1/stores/{storeId}/invoices/{invoiceId}/payment-methods", queryPayload, HttpMethod.Get, token);
     }
 
     public virtual async Task ArchiveInvoice(string storeId, string invoiceId,

BTCPayServer.Client/BTCPayServerClient.Lightning.Internal.cs

@@ -21,6 +21,13 @@ public partial class BTCPayServerClient
         return await SendHttpRequest<LightningNodeBalanceData>($"api/v1/server/lightning/{cryptoCode}/balance", null, HttpMethod.Get, token);
     }
 
+    public virtual async Task<HistogramData> GetLightningNodeHistogram(string cryptoCode, HistogramType? type = null,
+        CancellationToken token = default)
+    {
+        var queryPayload = type == null ? null : new Dictionary<string, object> { { "type", type.ToString() } };
+        return await SendHttpRequest<HistogramData>($"api/v1/server/lightning/{cryptoCode}/histogram", queryPayload, HttpMethod.Get, token);
+    }
+
     public virtual async Task ConnectToLightningNode(string cryptoCode, ConnectToNodeRequest request,
         CancellationToken token = default)
     {

BTCPayServer.Client/BTCPayServerClient.Lightning.Store.cs

@@ -21,6 +21,13 @@ public partial class BTCPayServerClient
         return await SendHttpRequest<LightningNodeBalanceData>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/balance", null, HttpMethod.Get, token);
     }
 
+    public virtual async Task<HistogramData> GetLightningNodeHistogram(string storeId, string cryptoCode, HistogramType? type = null,
+        CancellationToken token = default)
+    {
+        var queryPayload = type == null ? null : new Dictionary<string, object> { { "type", type.ToString() } };
+        return await SendHttpRequest<HistogramData>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/histogram", queryPayload, HttpMethod.Get, token);
+    }
+
     public virtual async Task ConnectToLightningNode(string storeId, string cryptoCode, ConnectToNodeRequest request,
         CancellationToken token = default)
     {

BTCPayServer.Client/BTCPayServerClient.OnChainPaymentMethods.cs

@@ -15,7 +15,7 @@ public partial class BTCPayServerClient
             int amount = 10,
             CancellationToken token = default)
     {
-        return await SendHttpRequest<UpdatePaymentMethodRequest, OnChainPaymentMethodPreviewResultData>($"api/v1/stores/{storeId}/payment-methods/{paymentMethodId}/preview",
+        return await SendHttpRequest<UpdatePaymentMethodRequest, OnChainPaymentMethodPreviewResultData>($"api/v1/stores/{storeId}/payment-methods/{paymentMethodId}/wallet/preview",
             new Dictionary<string, object> { { "offset", offset }, { "amount", amount } },
             new UpdatePaymentMethodRequest { Config = JValue.CreateString(derivationScheme) },
             HttpMethod.Post, token);
@@ -25,7 +25,7 @@ public partial class BTCPayServerClient
         string storeId, string paymentMethodId, int offset = 0, int amount = 10,
         CancellationToken token = default)
     {
-        return await SendHttpRequest<OnChainPaymentMethodPreviewResultData>($"api/v1/stores/{storeId}/payment-methods/{paymentMethodId}/preview",
+        return await SendHttpRequest<OnChainPaymentMethodPreviewResultData>($"api/v1/stores/{storeId}/payment-methods/{paymentMethodId}/wallet/preview",
             new Dictionary<string, object> { { "offset", offset }, { "amount", amount } }, HttpMethod.Get, token);
     }
 
@@ -33,7 +33,7 @@ public partial class BTCPayServerClient
         string paymentMethodId, GenerateOnChainWalletRequest request,
         CancellationToken token = default)
     {
-        return await SendHttpRequest<GenerateOnChainWalletResponse>($"api/v1/stores/{storeId}/payment-methods/{paymentMethodId}/generate", request, HttpMethod.Post, token);
+        return await SendHttpRequest<GenerateOnChainWalletResponse>($"api/v1/stores/{storeId}/payment-methods/{paymentMethodId}/wallet/generate", request, HttpMethod.Post, token);
     }
 
 }

BTCPayServer.Client/BTCPayServerClient.OnChainWallet.Objects.cs

@@ -15,7 +15,7 @@ public partial class BTCPayServerClient
             parameters.Add("includeNeighbourData", v);
         try
         {
-            return await SendHttpRequest<OnChainWalletObjectData>($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects/{objectId.Type}/{objectId.Id}", parameters, HttpMethod.Get, token);
+            return await SendHttpRequest<OnChainWalletObjectData>($"api/v1/stores/{storeId}/payment-methods/{cryptoCode}-CHAIN/wallet/objects/{objectId.Type}/{objectId.Id}", parameters, HttpMethod.Get, token);
         }
         catch (GreenfieldAPIException err) when (err.APIError.Code == "wallet-object-not-found")
         {
@@ -31,17 +31,17 @@ public partial class BTCPayServerClient
             parameters.Add("ids", ids);
         if (query?.IncludeNeighbourData is bool v)
             parameters.Add("includeNeighbourData", v);
-        return await SendHttpRequest<OnChainWalletObjectData[]>($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects", parameters, HttpMethod.Get, token);
+        return await SendHttpRequest<OnChainWalletObjectData[]>($"api/v1/stores/{storeId}/payment-methods/{cryptoCode}-CHAIN/wallet/objects", parameters, HttpMethod.Get, token);
     }
     public virtual async Task RemoveOnChainWalletObject(string storeId, string cryptoCode, OnChainWalletObjectId objectId,
         CancellationToken token = default)
     {
-        await SendHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects/{objectId.Type}/{objectId.Id}", null, HttpMethod.Delete, token);
+        await SendHttpRequest($"api/v1/stores/{storeId}/payment-methods/{cryptoCode}-CHAIN/wallet/objects/{objectId.Type}/{objectId.Id}", null, HttpMethod.Delete, token);
     }
     public virtual async Task<OnChainWalletObjectData> AddOrUpdateOnChainWalletObject(string storeId, string cryptoCode, AddOnChainWalletObjectRequest request,
         CancellationToken token = default)
     {
-        return await SendHttpRequest<OnChainWalletObjectData>($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects", request, HttpMethod.Post, token);
+        return await SendHttpRequest<OnChainWalletObjectData>($"api/v1/stores/{storeId}/payment-methods/{cryptoCode}-CHAIN/wallet/objects", request, HttpMethod.Post, token);
     }
 
     public virtual async Task AddOrUpdateOnChainWalletLink(string storeId, string cryptoCode,
@@ -49,7 +49,7 @@ public partial class BTCPayServerClient
         AddOnChainWalletObjectLinkRequest request = null,
         CancellationToken token = default)
     {
-        await SendHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects/{objectId.Type}/{objectId.Id}/links", request, HttpMethod.Post, token);
+        await SendHttpRequest($"api/v1/stores/{storeId}/payment-methods/{cryptoCode}-CHAIN/wallet/objects/{objectId.Type}/{objectId.Id}/links", request, HttpMethod.Post, token);
     }
 
     public virtual async Task RemoveOnChainWalletLinks(string storeId, string cryptoCode,
@@ -57,6 +57,6 @@ public partial class BTCPayServerClient
         OnChainWalletObjectId link,
         CancellationToken token = default)
     {
-        await SendHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects/{objectId.Type}/{objectId.Id}/links/{link.Type}/{link.Id}", null, HttpMethod.Delete, token);
+        await SendHttpRequest($"api/v1/stores/{storeId}/payment-methods/{cryptoCode}-CHAIN/wallet/objects/{objectId.Type}/{objectId.Id}/links/{link.Type}/{link.Id}", null, HttpMethod.Delete, token);
     }
 }

BTCPayServer.Client/BTCPayServerClient.OnChainWallet.cs

@@ -14,8 +14,16 @@ public partial class BTCPayServerClient
     public virtual async Task<OnChainWalletOverviewData> ShowOnChainWalletOverview(string storeId, string cryptoCode,
         CancellationToken token = default)
     {
-        return await SendHttpRequest<OnChainWalletOverviewData>($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet", null, HttpMethod.Get, token);
+        return await SendHttpRequest<OnChainWalletOverviewData>($"api/v1/stores/{storeId}/payment-methods/{cryptoCode}-CHAIN/wallet", null, HttpMethod.Get, token);
     }
+    
+    public virtual async Task<HistogramData> GetOnChainWalletHistogram(string storeId, string cryptoCode, HistogramType? type = null,
+        CancellationToken token = default)
+    {
+        var queryPayload = type == null ? null : new Dictionary<string, object> { { "type", type.ToString() } };
+        return await SendHttpRequest<HistogramData>($"api/v1/stores/{storeId}/payment-methods/{cryptoCode}-CHAIN/wallet/histogram", queryPayload, HttpMethod.Get, token);
+    }
+    
     public virtual async Task<OnChainWalletFeeRateData> GetOnChainFeeRate(string storeId, string cryptoCode, int? blockTarget = null,
         CancellationToken token = default)
     {
@@ -24,13 +32,13 @@ public partial class BTCPayServerClient
         {
             queryParams.Add("blockTarget", blockTarget);
         }
-        return await SendHttpRequest<OnChainWalletFeeRateData>($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/feeRate", queryParams, HttpMethod.Get, token);
+        return await SendHttpRequest<OnChainWalletFeeRateData>($"api/v1/stores/{storeId}/payment-methods/{cryptoCode}-CHAIN/wallet/feerate", queryParams, HttpMethod.Get, token);
     }
 
     public virtual async Task<OnChainWalletAddressData> GetOnChainWalletReceiveAddress(string storeId, string cryptoCode, bool forceGenerate = false,
         CancellationToken token = default)
     {
-        return await SendHttpRequest<OnChainWalletAddressData>($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/address", new Dictionary<string, object>
+        return await SendHttpRequest<OnChainWalletAddressData>($"api/v1/stores/{storeId}/payment-methods/{cryptoCode}-CHAIN/wallet/address", new Dictionary<string, object>
         {
             {"forceGenerate", forceGenerate}
         }, HttpMethod.Get, token);
@@ -39,7 +47,7 @@ public partial class BTCPayServerClient
     public virtual async Task UnReserveOnChainWalletReceiveAddress(string storeId, string cryptoCode,
         CancellationToken token = default)
     {
-        await SendHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/address", null, HttpMethod.Delete, token);
+        await SendHttpRequest($"api/v1/stores/{storeId}/payment-methods/{cryptoCode}-CHAIN/wallet/address", null, HttpMethod.Delete, token);
     }
 
     public virtual async Task<IEnumerable<OnChainWalletTransactionData>> ShowOnChainWalletTransactions(
@@ -59,14 +67,14 @@ public partial class BTCPayServerClient
         {
             query.Add(nameof(skip), skip);
         }
-        return await SendHttpRequest<IEnumerable<OnChainWalletTransactionData>>($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions", query, HttpMethod.Get, token);
+        return await SendHttpRequest<IEnumerable<OnChainWalletTransactionData>>($"api/v1/stores/{storeId}/payment-methods/{cryptoCode}-CHAIN/wallet/transactions", query, HttpMethod.Get, token);
     }
 
     public virtual async Task<OnChainWalletTransactionData> GetOnChainWalletTransaction(
         string storeId, string cryptoCode, string transactionId,
         CancellationToken token = default)
     {
-        return await SendHttpRequest<OnChainWalletTransactionData>($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions/{transactionId}", null, HttpMethod.Get, token);
+        return await SendHttpRequest<OnChainWalletTransactionData>($"api/v1/stores/{storeId}/payment-methods/{cryptoCode}-CHAIN/wallet/transactions/{transactionId}", null, HttpMethod.Get, token);
     }
 
     public virtual async Task<OnChainWalletTransactionData> PatchOnChainWalletTransaction(
@@ -74,7 +82,7 @@ public partial class BTCPayServerClient
         PatchOnChainTransactionRequest request,
         bool force = false, CancellationToken token = default)
     {
-        return await SendHttpRequest<PatchOnChainTransactionRequest, OnChainWalletTransactionData>($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions/{transactionId}", 
+        return await SendHttpRequest<PatchOnChainTransactionRequest, OnChainWalletTransactionData>($"api/v1/stores/{storeId}/payment-methods/{cryptoCode}-CHAIN/wallet/transactions/{transactionId}", 
             new Dictionary<string, object> { {"force", force} }, request, HttpMethod.Patch, token);
     }
 
@@ -82,7 +90,7 @@ public partial class BTCPayServerClient
         string cryptoCode,
         CancellationToken token = default)
     {
-        return await SendHttpRequest<IEnumerable<OnChainWalletUTXOData>>($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/utxos", null, HttpMethod.Get, token);
+        return await SendHttpRequest<IEnumerable<OnChainWalletUTXOData>>($"api/v1/stores/{storeId}/payment-methods/{cryptoCode}-CHAIN/wallet/utxos", null, HttpMethod.Get, token);
     }
 
     public virtual async Task<OnChainWalletTransactionData> CreateOnChainTransaction(string storeId,
@@ -94,7 +102,7 @@ public partial class BTCPayServerClient
             throw new ArgumentOutOfRangeException(nameof(request.ProceedWithBroadcast),
                 "Please use CreateOnChainTransactionButDoNotBroadcast when wanting to only create the transaction");
         }
-        return await SendHttpRequest<OnChainWalletTransactionData>($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions", request, HttpMethod.Post, token);
+        return await SendHttpRequest<OnChainWalletTransactionData>($"api/v1/stores/{storeId}/payment-methods/{cryptoCode}-CHAIN/wallet/transactions", request, HttpMethod.Post, token);
     }
 
     public virtual async Task<Transaction> CreateOnChainTransactionButDoNotBroadcast(string storeId,
@@ -106,6 +114,6 @@ public partial class BTCPayServerClient
             throw new ArgumentOutOfRangeException(nameof(request.ProceedWithBroadcast),
                 "Please use CreateOnChainTransaction when wanting to also broadcast the transaction");
         }
-        return Transaction.Parse(await SendHttpRequest<string>($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions", request, HttpMethod.Post, token), network);
+        return Transaction.Parse(await SendHttpRequest<string>($"api/v1/stores/{storeId}/payment-methods/{cryptoCode}-CHAIN/wallet/transactions", request, HttpMethod.Post, token), network);
     }
 }

BTCPayServer.Client/BTCPayServerClient.StorePayoutProcessors.cs

@@ -19,14 +19,14 @@ public partial class BTCPayServerClient
         await SendHttpRequest($"api/v1/stores/{storeId}/payout-processors/{processor}/{paymentMethod}", null, HttpMethod.Delete, token);
     }
 
-    public virtual async Task<IEnumerable<LightningAutomatedPayoutSettings>> GetStoreLightningAutomatedPayoutProcessors(string storeId, string? paymentMethod = null, CancellationToken token = default)
+    public virtual async Task<IEnumerable<LightningAutomatedPayoutSettings>> GetStoreLightningAutomatedPayoutProcessors(string storeId, string? payoutMethodId = null, CancellationToken token = default)
     {
-        return await SendHttpRequest<IEnumerable<LightningAutomatedPayoutSettings>>($"api/v1/stores/{storeId}/payout-processors/LightningAutomatedPayoutSenderFactory{(paymentMethod is null ? string.Empty : $"/{paymentMethod}")}", null, HttpMethod.Get, token);
+        return await SendHttpRequest<IEnumerable<LightningAutomatedPayoutSettings>>($"api/v1/stores/{storeId}/payout-processors/LightningAutomatedPayoutSenderFactory{(payoutMethodId is null ? string.Empty : $"/{payoutMethodId}")}", null, HttpMethod.Get, token);
     }
 
-    public virtual async Task<LightningAutomatedPayoutSettings> UpdateStoreLightningAutomatedPayoutProcessors(string storeId, string paymentMethod, LightningAutomatedPayoutSettings request, CancellationToken token = default)
+    public virtual async Task<LightningAutomatedPayoutSettings> UpdateStoreLightningAutomatedPayoutProcessors(string storeId, string payoutMethodId, LightningAutomatedPayoutSettings request, CancellationToken token = default)
     {
-        return await SendHttpRequest<LightningAutomatedPayoutSettings>($"api/v1/stores/{storeId}/payout-processors/LightningAutomatedPayoutSenderFactory/{paymentMethod}", request, HttpMethod.Put, token);
+        return await SendHttpRequest<LightningAutomatedPayoutSettings>($"api/v1/stores/{storeId}/payout-processors/LightningAutomatedPayoutSenderFactory/{payoutMethodId}", request, HttpMethod.Put, token);
     }
 
     public virtual async Task<OnChainAutomatedPayoutSettings> UpdateStoreOnChainAutomatedPayoutProcessors(string storeId, string paymentMethod, OnChainAutomatedPayoutSettings request, CancellationToken token = default)

BTCPayServer.Client/BTCPayServerClient.StoreUsers.cs

@@ -29,4 +29,10 @@ public partial class BTCPayServerClient
         if (request == null) throw new ArgumentNullException(nameof(request));
         await SendHttpRequest<StoreUserData>($"api/v1/stores/{storeId}/users", request, HttpMethod.Post, token);
     }
+
+    public virtual async Task UpdateStoreUser(string storeId, string userId, StoreUserData request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        await SendHttpRequest<StoreUserData>($"api/v1/stores/{storeId}/users/{userId}", request, HttpMethod.Put, token);
+    }
 }

BTCPayServer.Client/BTCPayServerClient.cs

@@ -156,7 +156,7 @@ public partial class BTCPayServerClient
     protected virtual async Task<T> UploadFileRequest<T>(string apiPath, string filePath, string mimeType, string formFieldName, HttpMethod method = null, CancellationToken token = default)
     {
         using MultipartFormDataContent multipartContent = new();
-        var fileContent = new StreamContent(File.OpenRead(filePath));
+        using var fileContent = new StreamContent(File.OpenRead(filePath));
         var fileName = Path.GetFileName(filePath);
         fileContent.Headers.ContentType = MediaTypeHeaderValue.Parse(mimeType);
         multipartContent.Add(fileContent, formFieldName, fileName);

BTCPayServer.Client/Models/AppCartItem.cs

@@ -0,0 +1,13 @@
+using BTCPayServer.JsonConverters;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models;
+
+public class AppCartItem
+{
+    public string Id { get; set; }
+    public string Title { get; set; }
+    public int Count { get; set; }
+    [JsonConverter(typeof(NumericStringJsonConverter))]
+    public decimal Price { get; set; }
+}

BTCPayServer.Client/Models/AppItem.cs

@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+using BTCPayServer.JsonConverters;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Client.Models;
+
+public enum AppItemPriceType
+{
+    Fixed,
+    Topup,
+    Minimum
+}
+
+public class AppItem
+{
+    public string Id { get; set; }
+    public string Title { get; set; }
+    public bool Disabled { get; set; }
+    public string Description { get; set; }
+    public string[] Categories { get; set; }
+    public string Image { get; set; }
+
+    [JsonConverter(typeof(StringEnumConverter))]
+    public AppItemPriceType PriceType { get; set; }
+
+    [JsonConverter(typeof(NumericStringJsonConverter))]
+    public decimal? Price { get; set; }
+    public string BuyButtonText { get; set; }
+    public int? Inventory { get; set; }
+
+    [JsonExtensionData]
+    public Dictionary<string, JToken> AdditionalData { get; set; }
+}

BTCPayServer.Client/Models/AppItemStats.cs

@@ -0,0 +1,15 @@
+using BTCPayServer.JsonConverters;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models;
+
+public class AppItemStats
+{
+    public string ItemCode { get; set; }
+    public string Title { get; set; }
+    public int SalesCount { get; set; }
+    
+    [JsonConverter(typeof(NumericStringJsonConverter))]
+    public decimal Total { get; set; }
+    public string TotalFormatted { get; set; }
+}

BTCPayServer.Client/Models/AppSalesStats.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models;
+
+public class AppSalesStats
+{
+    public int SalesCount { get; set; }
+    public IEnumerable<AppSalesStatsItem> Series { get; set; }
+}
+
+public class AppSalesStatsItem
+{
+    [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+    public DateTime Date { get; set; }
+    public string Label { get; set; }
+    public int SalesCount { get; set; }
+}

BTCPayServer.Client/Models/CreatePayoutRequest.cs

@@ -8,6 +8,6 @@ namespace BTCPayServer.Client.Models
         public string Destination { get; set; }
         [JsonConverter(typeof(NumericStringJsonConverter))]
         public decimal? Amount { get; set; }
-        public string PaymentMethod { get; set; }
+        public string PayoutMethodId { get; set; }
     }
 }

BTCPayServer.Client/Models/CreatePosInvoiceRequest.cs

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using BTCPayServer.JsonConverters;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models;
+
+public class CreatePosInvoiceRequest
+{
+    public string AppId { get; set; }
+    public List<AppCartItem> Cart { get; set; }
+    [JsonProperty(ItemConverterType = typeof(NumericStringJsonConverter))]
+    public List<decimal> Amounts { get; set; }
+    public int? DiscountPercent { get; set; }
+    public int? TipPercent { get; set; }
+    [JsonConverter(typeof(NumericStringJsonConverter))]
+    public decimal? DiscountAmount { get; set; }
+    [JsonConverter(typeof(NumericStringJsonConverter))]
+    public decimal? Tip { get; set; }
+    [JsonConverter(typeof(NumericStringJsonConverter))]
+    public decimal? Subtotal { get; set; }
+    [JsonConverter(typeof(NumericStringJsonConverter))]
+    public decimal? Total { get; set; }
+    public string PosData { get; set; }
+}
+

BTCPayServer.Client/Models/CreatePullPaymentRequest.cs

@@ -19,7 +19,7 @@ namespace BTCPayServer.Client.Models
         public DateTimeOffset? ExpiresAt { get; set; }
         [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
         public DateTimeOffset? StartsAt { get; set; }
-        public string[] PaymentMethods { get; set; }
+        public string[] PayoutMethods { get; set; }
         public bool AutoApproveClaims { get; set; }
     }
 }

BTCPayServer.Client/Models/CrowdfundAppData.cs

@@ -37,7 +37,7 @@ public abstract class CrowdfundBaseData : AppBaseData
 
 public class CrowdfundAppData : CrowdfundBaseData
 {
-    public object? Perks { get; set; }
+    public AppItem[]? Perks { get; set; }
 }
 
 public class CrowdfundAppRequest : CrowdfundBaseData, IAppRequest

BTCPayServer.Client/Models/GenerateOnChainWalletRequest.cs

@@ -10,6 +10,7 @@ namespace BTCPayServer.Client
 {
     public class GenerateOnChainWalletRequest
     {
+        public string Label { get; set; }
         public int AccountNumber { get; set; } = 0;
         [JsonConverter(typeof(MnemonicJsonConverter))]
         public Mnemonic ExistingMnemonic { get; set; }
@@ -29,6 +30,7 @@ namespace BTCPayServer.Client
     {
         public class ConfigData
         {
+            public string Label { get; set; }
             public string AccountDerivation { get; set; }
             [JsonExtensionData]
             IDictionary<string, JToken> AdditionalData { get; set; }

BTCPayServer.Client/Models/HistogramData.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using BTCPayServer.JsonConverters;
+using NBitcoin.JsonConverters;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace BTCPayServer.Client.Models;
+
+public enum HistogramType
+{
+    Week,
+    Month,
+    YTD,
+    Year,
+    TwoYears,
+    Day
+}
+
+public class HistogramData
+{
+    [JsonConverter(typeof(StringEnumConverter))]
+    public HistogramType Type { get; set; }
+    [JsonProperty(ItemConverterType = typeof(NumericStringJsonConverter))]
+    public List<decimal> Series { get; set; }
+    [JsonProperty(ItemConverterType = typeof(DateTimeToUnixTimeConverter))]
+    public List<DateTimeOffset> Labels { get; set; }
+    [JsonConverter(typeof(NumericStringJsonConverter))]
+    public decimal Balance { get; set; }
+}

BTCPayServer.Client/Models/LightningAutomatedPayoutSettings.cs

@@ -6,12 +6,11 @@ namespace BTCPayServer.Client.Models;
 
 public class LightningAutomatedPayoutSettings
 {
-    public string PaymentMethod { get; set; }
+    public string PayoutMethodId { get; set; }
 
     [JsonConverter(typeof(TimeSpanJsonConverter.Seconds))]
     public TimeSpan IntervalSeconds { get; set; }
 
-    public int? CancelPayoutAfterFailures { get; set; }
     [JsonProperty(DefaultValueHandling = DefaultValueHandling.Populate)]
     public bool  ProcessNewPayoutsInstantly { get; set; }
     

BTCPayServer.Client/Models/NotificationData.cs

@@ -11,7 +11,7 @@ namespace BTCPayServer.Client.Models
         public string Body { get; set; }
         public string StoreId { get; set; }
         public bool Seen { get; set; }
-        public Uri Link { get; set; }
+        public string Link { get; set; }
 
         [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
         public DateTimeOffset CreatedTime { get; set; }

BTCPayServer.Client/Models/OnChainAutomatedPayoutSettings.cs

@@ -6,7 +6,7 @@ namespace BTCPayServer.Client.Models;
 
 public class OnChainAutomatedPayoutSettings
 {
-    public string PaymentMethod { get; set; }
+    public string PayoutMethodId { get; set; }
 
     [JsonConverter(typeof(TimeSpanJsonConverter.Seconds))]
     public TimeSpan IntervalSeconds { get; set; }

BTCPayServer.Client/Models/PaymentMethodCriteriaData.cs

@@ -5,7 +5,7 @@ namespace BTCPayServer.Client.Models;
 
 public class PaymentMethodCriteriaData
 {
-    public string PaymentMethod { get; set; }
+    public string PaymentMethodId { get; set; }
     public string CurrencyCode { get; set; }
     [JsonConverter(typeof(NumericStringJsonConverter))]
     public decimal Amount { get; set; }

BTCPayServer.Client/Models/PayoutData.cs

@@ -21,12 +21,13 @@ namespace BTCPayServer.Client.Models
         public string Id { get; set; }
         public string PullPaymentId { get; set; }
         public string Destination { get; set; }
-        public string PaymentMethod { get; set; }
-        public string CryptoCode { get; set; }
+        public string PayoutMethodId { get; set; }
         [JsonConverter(typeof(NumericStringJsonConverter))]
-        public decimal Amount { get; set; }
+        public decimal OriginalAmount { get; set; }
+        public string OriginalCurrency { get; set; }
+        public string PayoutCurrency { get; set; }
         [JsonConverter(typeof(NumericStringJsonConverter))]
-        public decimal? PaymentMethodAmount { get; set; }
+        public decimal? PayoutAmount { get; set; }
         [JsonConverter(typeof(StringEnumConverter))]
         public PayoutState State { get; set; }
         public int Revision { get; set; }

BTCPayServer.Client/Models/PayoutProcessorData.cs

@@ -4,6 +4,6 @@ namespace BTCPayServer.Client.Models
     {
         public string Name { get; set; }
         public string FriendlyName { get; set; }
-        public string[] PaymentMethods { get; set; }
+        public string[] PayoutMethods { get; set; }
     }
 }

BTCPayServer.Client/Models/PermissionMetadata.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using Newtonsoft.Json;
 
 namespace BTCPayServer.Client.Models
@@ -11,17 +10,17 @@ namespace BTCPayServer.Client.Models
         static PermissionMetadata()
         {
             Dictionary<string, PermissionMetadata> nodes = new Dictionary<string, PermissionMetadata>();
-            foreach (var policy in Client.Policies.AllPolicies)
+            foreach (var policy in Policies.AllPolicies)
             {
                 nodes.Add(policy, new PermissionMetadata() { PermissionName = policy });
             }
             foreach (var n in nodes)
             {
-                foreach (var policy in Client.Policies.AllPolicies)
+                foreach (var policy in Policies.AllPolicies)
                 {
                     if (policy.Equals(n.Key, StringComparison.OrdinalIgnoreCase))
                         continue;
-                    if (Client.Permission.Create(n.Key).Contains(Client.Permission.Create(policy)))
+                    if (Permission.Create(n.Key).Contains(Permission.Create(policy)))
                         n.Value.SubPermissions.Add(policy);
                 }
             }

BTCPayServer.Client/Models/PointOfSaleAppData.cs

@@ -1,8 +1,6 @@
 #nullable enable
-using System.Collections.Generic;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
-using Newtonsoft.Json.Linq;
 
 namespace BTCPayServer.Client.Models;
 
@@ -31,7 +29,7 @@ public abstract class PointOfSaleBaseData : AppBaseData
 
 public class PointOfSaleAppData : PointOfSaleBaseData
 {
-    public object? Items { get; set; }
+    public AppItem[]? Items { get; set; }
 }
 
 public class PointOfSaleAppRequest : PointOfSaleBaseData, IAppRequest

BTCPayServer.Client/Models/RefundInvoiceRequest.cs

@@ -17,7 +17,7 @@ namespace BTCPayServer.Client.Models
     public class RefundInvoiceRequest
     {
         public string? Name { get; set; } = null;
-        public string? PaymentMethod { get; set; }
+        public string? PayoutMethodId { get; set; }
         public string? Description { get; set; } = null;
         
         [JsonConverter(typeof(StringEnumConverter))]

BTCPayServer.Client/Models/ServerInfoData.cs

@@ -32,7 +32,7 @@ namespace BTCPayServer.Client.Models
 
     public class SyncStatus
     {
-        public string CryptoCode { get; set; }
+        public string PaymentMethodId { get; set; }
         public virtual bool Available { get; set; }
     }
 

BTCPayServer.Client/Models/StoreBaseData.cs

@@ -17,6 +17,7 @@ namespace BTCPayServer.Client.Models
         public string Website { get; set; }
 
         public string BrandColor { get; set; }
+        public bool ApplyBrandColorToBackend { get; set; }
         public string LogoUrl { get; set; }
         public string CssUrl { get; set; }
         public string PaymentSoundUrl { get; set; }

BTCPayServer.Client/Models/StoreData.cs

@@ -17,7 +17,25 @@ namespace BTCPayServer.Client.Models
         /// </summary>
         public string UserId { get; set; }
 
+        /// <summary>
+        /// the store role of the user
+        /// </summary>
         public string Role { get; set; }
+
+        /// <summary>
+        /// the email AND username of the user
+        /// </summary>
+        public string Email { get; set; }
+        
+        /// <summary>
+        /// the name of the user
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// the image url of the user
+        /// </summary>
+        public string ImageUrl { get; set; }
     }
 
     public class RoleData

BTCPayServer.Client/Permissions.cs

@@ -1,8 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Globalization;
 using System.Linq;
-using System.Linq.Expressions;
+using System.Text.RegularExpressions;
 
 namespace BTCPayServer.Client
 {
@@ -16,7 +17,7 @@ namespace BTCPayServer.Client
         public const string CanUseLightningNodeInStore = "btcpay.store.canuselightningnode";
         public const string CanModifyServerSettings = "btcpay.server.canmodifyserversettings";
         public const string CanModifyStoreSettings = "btcpay.store.canmodifystoresettings";
-        public const string CanModifyStoreWebhooks = "btcpay.store.webhooks.canmodifywebhooks";
+        public const string CanModifyWebhooks = "btcpay.store.webhooks.canmodifywebhooks";
         public const string CanModifyStoreSettingsUnscoped = "btcpay.store.canmodifystoresettings:";
         public const string CanViewStoreSettings = "btcpay.store.canviewstoresettings";
         public const string CanViewReports = "btcpay.store.canviewreports";
@@ -48,7 +49,7 @@ namespace BTCPayServer.Client
                 yield return CanViewInvoices;
                 yield return CanCreateInvoice;
                 yield return CanModifyInvoices;
-                yield return CanModifyStoreWebhooks;
+                yield return CanModifyWebhooks;
                 yield return CanModifyServerSettings;
                 yield return CanModifyStoreSettings;
                 yield return CanViewStoreSettings;
@@ -104,6 +105,16 @@ namespace BTCPayServer.Client
         {
             return policy.StartsWith("btcpay.user", StringComparison.OrdinalIgnoreCase);
         }
+
+        private static readonly CultureInfo _culture = new (CultureInfo.InvariantCulture.Name);
+        public static string DisplayName(string policy)
+        {
+            var p = policy.Split(".");
+            if (p.Length < 3 || p[0] != "btcpay") return policy;
+            var constName = typeof(Policies).GetFields().Select(f => f.Name).FirstOrDefault(f => f.Equals(p[^1], StringComparison.OrdinalIgnoreCase));
+            var perm = string.IsNullOrEmpty(constName) ? string.Join(' ', p[2..]) : Regex.Replace(constName, "([A-Z])", " $1", RegexOptions.Compiled).Trim();
+            return $"{_culture.TextInfo.ToTitleCase(p[1])}: {_culture.TextInfo.ToTitleCase(perm)}";
+        }
     }
 
     public class PermissionSet
@@ -247,7 +258,7 @@ namespace BTCPayServer.Client
                 Policies.CanManagePullPayments,
                 Policies.CanModifyInvoices,
                 Policies.CanViewStoreSettings,
-                Policies.CanModifyStoreWebhooks,
+                Policies.CanModifyWebhooks,
                 Policies.CanModifyPaymentRequests,
                 Policies.CanManagePayouts,
                 Policies.CanUseLightningNodeInStore);

BTCPayServer.Client/PosDataParser.cs

@@ -0,0 +1,50 @@
+#nullable enable
+using System.Collections.Generic;
+using System.Linq;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Client;
+
+public static class PosDataParser
+{
+    public static Dictionary<string, object> ParsePosData(JToken? posData)
+    {
+        var result = new Dictionary<string, object>();
+        if (posData is JObject jobj)
+        {
+            foreach (var item in jobj)
+            {
+                ParsePosDataItem(item, ref result);
+            }
+        }
+        return result;
+    }
+
+    static void ParsePosDataItem(KeyValuePair<string, JToken?> item, ref Dictionary<string, object> result)
+    {
+        switch (item.Value?.Type)
+        {
+            case JTokenType.Array:
+                var items = item.Value.AsEnumerable().ToList();
+                var arrayResult = new List<object>();
+                for (var i = 0; i < items.Count; i++)
+                {
+                    arrayResult.Add(items[i] is JObject
+                        ? ParsePosData(items[i])
+                        : items[i].ToString());
+                }
+
+                result.TryAdd(item.Key, arrayResult);
+
+                break;
+            case JTokenType.Object:
+                result.TryAdd(item.Key, ParsePosData(item.Value));
+                break;
+            case null:
+                break;
+            default:
+                result.TryAdd(item.Key, item.Value.ToString());
+                break;
+        }
+    }
+}

BTCPayServer.Common/BTCPayNetwork.cs

@@ -4,8 +4,6 @@ using System.Globalization;
 using System.IO;
 using System.Linq;
 using BTCPayServer.Common;
-using Microsoft.AspNetCore.HttpOverrides;
-using Microsoft.Extensions.DependencyInjection;
 using NBitcoin;
 using NBXplorer;
 using NBXplorer.Models;
@@ -133,7 +131,7 @@ namespace BTCPayServer
 
         public string GetTrackedDestination(Script scriptPubKey)
         {
-            return scriptPubKey.Hash.ToString() + "#" + CryptoCode.ToUpperInvariant();
+            return scriptPubKey.Hash.ToString();
         }
     }
 

BTCPayServer.Common/BTCPayNetworkProvider.cs

@@ -3,13 +3,9 @@ using System.Collections.Generic;
 using System.Linq;
 using BTCPayServer.Configuration;
 using BTCPayServer.Logging;
-using Microsoft.AspNetCore.DataProtection.KeyManagement;
-using Microsoft.AspNetCore.HttpOverrides;
-using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using NBitcoin;
 using NBXplorer;
-using StandardConfiguration;
 
 namespace BTCPayServer
 {

BTCPayServer.Common/BTCPayServer.Common.csproj

@@ -1,16 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="../Build/Version.csproj" Condition="Exists('../Build/Version.csproj')" />
   <Import Project="../Build/Common.csproj" />
-
   <ItemGroup>
-    <FrameworkReference Include="Microsoft.AspNetCore.App" />
-    <PackageReference Include="NBXplorer.Client" Version="4.3.1" />
+    <PackageReference Include="NBXplorer.Client" Version="4.3.6" />
     <PackageReference Include="NicolasDorier.StandardConfiguration" Version="2.0.1" />
   </ItemGroup>
-  <ItemGroup Condition="'$(Altcoins)' != 'true'">
-    <Compile Remove="Altcoins\**\*.cs"></Compile>
-  </ItemGroup>
-  <ItemGroup>
-    <Folder Include="Altcoins\" />
-  </ItemGroup>
 </Project>

BTCPayServer.Common/CustomThreadPool.cs

@@ -1,97 +0,0 @@
-using System;
-using System.Collections.Concurrent;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace BTCPayServer
-{
-    public class CustomThreadPool : IDisposable
-    {
-        readonly CancellationTokenSource _Cancel = new CancellationTokenSource();
-        readonly TaskCompletionSource<bool> _Exited;
-        int _ExitedCount = 0;
-        readonly Thread[] _Threads;
-        Exception _UnhandledException;
-        readonly BlockingCollection<(Action, TaskCompletionSource<object>)> _Actions = new BlockingCollection<(Action, TaskCompletionSource<object>)>(new ConcurrentQueue<(Action, TaskCompletionSource<object>)>());
-
-        public CustomThreadPool(int threadCount, string threadName)
-        {
-            if (threadCount <= 0)
-                throw new ArgumentOutOfRangeException(nameof(threadCount));
-            _Exited = new TaskCompletionSource<bool>();
-            _Threads = Enumerable.Range(0, threadCount).Select(_ => new Thread(RunLoop) { Name = threadName }).ToArray();
-            foreach (var t in _Threads)
-                t.Start();
-        }
-
-        public void Do(Action act)
-        {
-            DoAsync(act).GetAwaiter().GetResult();
-        }
-
-        public T Do<T>(Func<T> act)
-        {
-            return DoAsync(act).GetAwaiter().GetResult();
-        }
-
-        public async Task<T> DoAsync<T>(Func<T> act)
-        {
-            TaskCompletionSource<object> done = new TaskCompletionSource<object>();
-            _Actions.Add((() =>
-            {
-                try
-                {
-                    done.TrySetResult(act());
-                }
-                catch (Exception ex) { done.TrySetException(ex); }
-            }
-            , done));
-            return (T)(await done.Task.ConfigureAwait(false));
-        }
-
-        public Task DoAsync(Action act)
-        {
-            return DoAsync<object>(() =>
-            {
-                act();
-                return null;
-            });
-        }
-
-        void RunLoop()
-        {
-            try
-            {
-                foreach (var act in _Actions.GetConsumingEnumerable(_Cancel.Token))
-                {
-                    act.Item1();
-                }
-            }
-            catch (OperationCanceledException) when (_Cancel.IsCancellationRequested) { }
-            catch (Exception ex)
-            {
-                _Cancel.Cancel();
-                _UnhandledException = ex;
-            }
-            if (Interlocked.Increment(ref _ExitedCount) == _Threads.Length)
-            {
-                foreach (var action in _Actions)
-                {
-                    try
-                    {
-                        action.Item2.TrySetCanceled();
-                    }
-                    catch { }
-                }
-                _Exited.TrySetResult(true);
-            }
-        }
-
-        public void Dispose()
-        {
-            _Cancel.Cancel();
-            _Exited.Task.GetAwaiter().GetResult();
-        }
-    }
-}

BTCPayServer.Common/MultiProcessingQueue.cs

@@ -1,7 +1,5 @@
-using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using System.Threading;
 using System.Threading.Channels;
 using System.Threading.Tasks;

BTCPayServer.Common/SelectedChains.cs

@@ -4,7 +4,6 @@ using System.Linq;
 using BTCPayServer.Logging;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
-using Newtonsoft.Json.Bson;
 
 namespace BTCPayServer
 {

BTCPayServer.Data/ApplicationDbContext.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations.Schema;
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
@@ -39,7 +41,6 @@ namespace BTCPayServer.Data
         public DbSet<PaymentRequestData> PaymentRequests { get; set; }
         public DbSet<PaymentData> Payments { get; set; }
         public DbSet<PayoutData> Payouts { get; set; }
-        public DbSet<PendingInvoiceData> PendingInvoices { get; set; }
         public DbSet<PlannedTransaction> PlannedTransactions { get; set; }
         public DbSet<PullPaymentData> PullPayments { get; set; }
         public DbSet<RefundData> Refunds { get; set; }
@@ -62,6 +63,7 @@ namespace BTCPayServer.Data
         public DbSet<LightningAddressData> LightningAddresses { get; set; }
         public DbSet<PayoutProcessorData> PayoutProcessors { get; set; }
         public DbSet<FormData> Forms { get; set; }
+        public DbSet<PendingTransaction> PendingTransactions { get; set; }
 
         protected override void OnModelCreating(ModelBuilder builder)
         {
@@ -83,9 +85,8 @@ namespace BTCPayServer.Data
             PairingCodeData.OnModelCreating(builder);
             //PayjoinLock.OnModelCreating(builder);
             PaymentRequestData.OnModelCreating(builder, Database);
-            PaymentData.OnModelCreating(builder, Database);
+            PaymentData.OnModelCreating(builder);
             PayoutData.OnModelCreating(builder, Database);
-            PendingInvoiceData.OnModelCreating(builder);
             //PlannedTransaction.OnModelCreating(builder);
             PullPaymentData.OnModelCreating(builder, Database);
             RefundData.OnModelCreating(builder);
@@ -108,7 +109,7 @@ namespace BTCPayServer.Data
             WebhookData.OnModelCreating(builder, Database);
             FormData.OnModelCreating(builder, Database);
             StoreRole.OnModelCreating(builder, Database);
+            PendingTransaction.OnModelCreating(builder, Database);
         }
     }
-
 }

BTCPayServer.Data/ApplicationDbContextFactory.cs

@@ -1,6 +1,4 @@
 using System;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
 using BTCPayServer.Abstractions.Contracts;
 using BTCPayServer.Abstractions.Models;
 using Microsoft.EntityFrameworkCore;
@@ -23,7 +21,7 @@ namespace BTCPayServer.Data
         {
             var builder = new DbContextOptionsBuilder<ApplicationDbContext>();
             builder.UseLoggerFactory(LoggerFactory);
-            builder.AddInterceptors(Data.InvoiceData.MigrationInterceptor.Instance);
+            builder.AddInterceptors(MigrationInterceptor.Instance);
             ConfigureBuilder(builder, npgsqlOptionsAction);
             return new ApplicationDbContext(builder.Options);
         }

BTCPayServer.Data/BTCPayServer.Data.csproj

@@ -3,12 +3,12 @@
   <Import Project="../Build/Common.csproj" />
   <ItemGroup>
     <FrameworkReference Include="Microsoft.AspNetCore.App" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="8.0.6">
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="8.0.11">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="8.0.7" />
-    <PackageReference Include="NBitcoin.Altcoins" Version="3.0.24" />
+    <PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="8.0.11" />
+    <PackageReference Include="NBitcoin.Altcoins" Version="3.0.31" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\BTCPayServer.Abstractions\BTCPayServer.Abstractions.csproj" />
@@ -20,5 +20,7 @@
   <ItemGroup>
     <None Remove="DBScripts\001.InvoiceFunctions.sql" />
     <None Remove="DBScripts\002.RefactorPayouts.sql" />
+    <None Remove="DBScripts\003.RefactorPendingInvoicesPayments.sql" />
+    <None Remove="DBScripts\004.MonitoredInvoices.sql" />
   </ItemGroup>
 </Project>

BTCPayServer.Data/DBScripts/002.RefactorPayouts.sql

@@ -7,6 +7,7 @@ UPDATE "Payouts" SET
     "Currency" = split_part("PayoutMethodId", '_', 1),
     "PayoutMethodId"=
         CASE
+            WHEN ("Blob"->>'Amount')::NUMERIC < 0 THEN 'TOPUP'
             WHEN split_part("PayoutMethodId", '_', 2) = 'LightningLike' THEN split_part("PayoutMethodId", '_', 1) || '-LN'
             ELSE split_part("PayoutMethodId", '_', 1) || '-CHAIN'
         END;

BTCPayServer.Data/DBScripts/003.RefactorPendingInvoicesPayments.sql

@@ -0,0 +1,9 @@
+CREATE OR REPLACE FUNCTION is_pending(status TEXT)
+RETURNS BOOLEAN AS $$
+    SELECT status = 'Processing' OR status = 'New';
+$$ LANGUAGE sql IMMUTABLE;
+
+CREATE INDEX "IX_Invoices_Pending" ON "Invoices"((1)) WHERE is_pending("Status");
+CREATE INDEX "IX_Payments_Pending" ON "Payments"((1)) WHERE is_pending("Status");
+DROP TABLE "PendingInvoices";
+ANALYZE "Invoices";

BTCPayServer.Data/DBScripts/004.MonitoredInvoices.sql

@@ -0,0 +1,23 @@
+CREATE OR REPLACE FUNCTION get_prompt(invoice_blob JSONB, payment_method_id TEXT)
+RETURNS JSONB AS $$
+    SELECT invoice_blob->'prompts'->payment_method_id
+$$ LANGUAGE sql IMMUTABLE;
+
+
+CREATE OR REPLACE FUNCTION get_monitored_invoices(arg_payment_method_id TEXT, include_non_activated BOOLEAN)
+RETURNS TABLE (invoice_id TEXT, payment_id TEXT, payment_method_id TEXT) AS $$
+WITH cte AS (
+-- Get all the invoices which are pending. Even if no payments.
+SELECT i."Id" invoice_id, p."Id" payment_id, p."PaymentMethodId" payment_method_id FROM "Invoices" i LEFT JOIN "Payments" p ON i."Id" = p."InvoiceDataId"
+        WHERE is_pending(i."Status")
+UNION ALL
+-- For invoices not pending, take all of those which have pending payments
+SELECT i."Id" invoice_id, p."Id" payment_id, p."PaymentMethodId" payment_method_id FROM "Invoices" i INNER JOIN "Payments" p ON i."Id" = p."InvoiceDataId"
+        WHERE is_pending(p."Status") AND NOT is_pending(i."Status"))
+SELECT cte.* FROM cte
+JOIN "Invoices" i ON cte.invoice_id=i."Id"
+LEFT JOIN "Payments" p ON cte.payment_id=p."Id" AND cte.payment_method_id=p."PaymentMethodId"
+WHERE (p."PaymentMethodId" IS NOT NULL AND p."PaymentMethodId" = arg_payment_method_id) OR
+      (p."PaymentMethodId" IS NULL AND get_prompt(i."Blob2", arg_payment_method_id) IS NOT NULL AND
+        (include_non_activated IS TRUE OR (get_prompt(i."Blob2", arg_payment_method_id)->'inactive')::BOOLEAN IS NOT TRUE));
+$$ LANGUAGE SQL STABLE;

BTCPayServer.Data/Data/AddressInvoiceData.cs

@@ -9,6 +9,7 @@ namespace BTCPayServer.Data
         public string Address { get; set; }
         public InvoiceData InvoiceData { get; set; }
         public string InvoiceDataId { get; set; }
+        public string PaymentMethodId { get; set; }
 
 
         internal static void OnModelCreating(ModelBuilder builder)
@@ -18,7 +19,7 @@ namespace BTCPayServer.Data
                    .WithMany(i => i.AddressInvoices).OnDelete(DeleteBehavior.Cascade);
             builder.Entity<AddressInvoiceData>()
 #pragma warning disable CS0618
-                .HasKey(o => o.Address);
+                .HasKey(o => new { o.Address, o.PaymentMethodId });
 #pragma warning restore CS0618
         }
     }

BTCPayServer.Data/Data/ApplicationUser.cs

@@ -46,5 +46,6 @@ namespace BTCPayServer.Data
         public bool ShowInvoiceStatusChangeHint { get; set; }
         public string ImageUrl { get; set; }
         public string Name { get; set; }
+        public string InvitationToken { get; set; }
     }
 }

BTCPayServer.Data/Data/InvoiceData.Migration.cs

@@ -15,32 +15,13 @@ using Microsoft.EntityFrameworkCore.Diagnostics;
 using BTCPayServer.Migrations;
 using Newtonsoft.Json.Serialization;
 using Microsoft.AspNetCore.Mvc.ModelBinding.Binders;
+using System.Threading.Tasks;
+using System.Threading;
 
 namespace BTCPayServer.Data
 {
-    public partial class InvoiceData
+    public partial class InvoiceData : MigrationInterceptor.IHasMigration
     {
-        /// <summary>
-        /// We have a migration running in the background that will migrate the data from the old blob to the new blob
-        /// Meanwhile, we need to make sure that invoices which haven't been migrated yet are migrated on the fly.
-        /// </summary>
-        public class MigrationInterceptor : IMaterializationInterceptor
-        {
-            public static readonly MigrationInterceptor Instance = new MigrationInterceptor();
-            public object InitializedInstance(MaterializationInterceptionData materializationData, object entity)
-            {
-                if (entity is InvoiceData invoiceData && invoiceData.Currency is null)
-                {
-                    invoiceData.Migrate();
-                }
-                else if (entity is PaymentData paymentData && paymentData.Currency is null)
-                {
-                    paymentData.Migrate();
-                }
-                return entity;
-            }
-        }
-
         static HashSet<string> superflousProperties = new HashSet<string>()
         {
             "availableAddressHashes",
@@ -74,13 +55,14 @@ namespace BTCPayServer.Data
         };
 
 #pragma warning disable CS0618 // Type or member is obsolete
-        public void Migrate()
+        public bool TryMigrate()
         {
             if (Currency is not null)
-                return;
+                return false;
             if (Blob is not (null or { Length: 0 }))
             {
                 Blob2 = MigrationExtensions.Unzip(Blob);
+                Blob2 = MigrationExtensions.SanitizeJSON(Blob2);
                 Blob = null;
             }
             var blob = JObject.Parse(Blob2);
@@ -228,7 +210,7 @@ namespace BTCPayServer.Data
             }
 
             blob.ConvertNumberToString("price");
-            Currency = blob["currency"].Value<string>();
+            Currency = blob["currency"].Value<string>().ToUpperInvariant();
             var isTopup = blob["type"]?.Value<string>() is "TopUp";
             var amount = decimal.Parse(blob["price"].Value<string>(), CultureInfo.InvariantCulture);
             Amount = isTopup && amount == 0 ? null : decimal.Parse(blob["price"].Value<string>(), CultureInfo.InvariantCulture);
@@ -368,7 +350,11 @@ namespace BTCPayServer.Data
             };
             blob["version"] = 3;
             Blob2 = blob.ToString(Formatting.None);
+            return true;
         }
+
+        [NotMapped]
+        public bool Migrated { get; set; }
         static string[] detailsRemoveDefault =
             [
                 "paymentMethodFeeRate",

BTCPayServer.Data/Data/InvoiceData.cs

@@ -5,6 +5,7 @@ using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Newtonsoft.Json.Linq;
 
+
 namespace BTCPayServer.Data
 {
     public partial class InvoiceData : IHasBlobUntyped
@@ -25,14 +26,14 @@ namespace BTCPayServer.Data
         public string ExceptionStatus { get; set; }
         public List<AddressInvoiceData> AddressInvoices { get; set; }
         public bool Archived { get; set; }
-        public List<PendingInvoiceData> PendingInvoices { get; set; }
         public List<InvoiceSearchData> InvoiceSearchData { get; set; }
         public List<RefundData> Refunds { get; set; }
 
 		public static string GetOrderId(string blob) => throw new NotSupportedException();
 		public static string GetItemCode(string blob) => throw new NotSupportedException();
+        public static bool IsPending(string status) => throw new NotSupportedException();
 
-		[Timestamp]
+        [Timestamp]
         // With this, update of InvoiceData will fail if the row was modified by another process
         public uint XMin { get; set; }
         internal static void OnModelCreating(ModelBuilder builder, DatabaseFacade databaseFacade)
@@ -50,7 +51,7 @@ namespace BTCPayServer.Data
                     .HasColumnType("NUMERIC");
 			builder.HasDbFunction(typeof(InvoiceData).GetMethod(nameof(GetOrderId), new[] { typeof(string) }), b => b.HasName("get_orderid"));
 			builder.HasDbFunction(typeof(InvoiceData).GetMethod(nameof(GetItemCode), new[] { typeof(string) }), b => b.HasName("get_itemcode"));
-
-		}
+            builder.HasDbFunction(typeof(InvoiceData).GetMethod(nameof(IsPending), new[] { typeof(string) }), b => b.HasName("is_pending"));
+        }
     }
 }

BTCPayServer.Data/Data/MigrationExtensions.cs

@@ -137,9 +137,10 @@ namespace BTCPayServer.Data
             {
                 return paymentType switch
                 {
-                    "BTCLike" => $"{cryptoCode}-CHAIN",
+                    "BTCLike" or "MoneroLike" or "ZcashLike" => $"{cryptoCode}-CHAIN",
                     "LightningLike" or "LightningNetwork" => $"{cryptoCode}-LN",
                     "LNURLPAY" => $"{cryptoCode}-LNURL",
+
                     _ => throw new NotSupportedException("Unknown payment type " + paymentType)
                 };
             }
@@ -147,5 +148,25 @@ namespace BTCPayServer.Data
                 return $"{splitted[0]}-CHAIN";
             throw new NotSupportedException("Unknown payment id " + paymentMethodId);
         }
+        public static string TryMigratePaymentMethodId(string paymentMethodId)
+        {
+            var splitted = paymentMethodId.Split(new[] { '_', '-' });
+            if (splitted is [var cryptoCode, var paymentType])
+            {
+                return paymentType switch
+                {
+                    "BTCLike" or "MoneroLike" or "ZcashLike" => $"{cryptoCode}-CHAIN",
+                    "LightningLike" or "LightningNetwork" => $"{cryptoCode}-LN",
+                    "LNURLPAY" => $"{cryptoCode}-LNURL",
+                    _ => paymentMethodId
+                };
+            }
+            if (splitted.Length == 1)
+                return $"{splitted[0]}-CHAIN";
+            return paymentMethodId;
+        }
+
+        // Make postgres happy
+        public static string SanitizeJSON(string json) => json.Replace("\\u0000", string.Empty, StringComparison.OrdinalIgnoreCase);
     }
 }

BTCPayServer.Data/Data/MigrationInterceptor.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+using Microsoft.EntityFrameworkCore;
+
+namespace BTCPayServer.Data
+{
+    /// <summary>
+    /// We have a migration running in the background that will migrate the data from the old blob to the new blob
+    /// Meanwhile, we need to make sure that invoices which haven't been migrated yet are migrated on the fly.
+    /// </summary>
+    public class MigrationInterceptor : IMaterializationInterceptor, ISaveChangesInterceptor
+    {
+        public interface IHasMigration
+        {
+            bool TryMigrate();
+            bool Migrated { get; set; }
+        }
+        public static readonly MigrationInterceptor Instance = new MigrationInterceptor();
+        public object InitializedInstance(MaterializationInterceptionData materializationData, object entity)
+        {
+            if (entity is IHasMigration hasMigration && hasMigration.TryMigrate())
+            {
+                hasMigration.Migrated = true;
+            }
+            return entity;
+        }
+
+        public ValueTask<InterceptionResult<int>> SavingChangesAsync(DbContextEventData eventData, InterceptionResult<int> result, CancellationToken cancellationToken = default(CancellationToken))
+        {
+
+            foreach (var entry in eventData.Context.ChangeTracker.Entries())
+            {
+                if (entry is { Entity: IHasMigration { Migrated: true }, State: EntityState.Modified })
+                    // It seems doing nothing, but this actually set all properties as modified
+                    entry.State = EntityState.Modified;
+            }
+            return new ValueTask<InterceptionResult<int>>(result);
+        }
+    }
+}

BTCPayServer.Data/Data/PaymentData.Migration.cs

@@ -1,10 +1,13 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
+using System.ComponentModel.DataAnnotations.Schema;
 using System.Linq;
 using System.Reflection.Metadata;
 using System.Text;
 using System.Threading.Tasks;
 using BTCPayServer.Migrations;
+using Microsoft.EntityFrameworkCore.ChangeTracking.Internal;
 using NBitcoin;
 using NBitcoin.Altcoins;
 using NBitcoin.DataEncoders;
@@ -13,16 +16,17 @@ using Newtonsoft.Json.Linq;
 
 namespace BTCPayServer.Data
 {
-    public partial class PaymentData
+    public partial class PaymentData : MigrationInterceptor.IHasMigration
     {
-        public void Migrate()
+        public bool TryMigrate()
         {
 #pragma warning disable CS0618 // Type or member is obsolete
             if (Currency is not null)
-                return;
+                return false;
             if (Blob is not (null or { Length: 0 }))
             {
                 Blob2 = MigrationExtensions.Unzip(Blob);
+                Blob2 = MigrationExtensions.SanitizeJSON(Blob2);
                 Blob = null;
             }
             var blob = JObject.Parse(Blob2);
@@ -42,9 +46,10 @@ namespace BTCPayServer.Data
             }
 
             var cryptoCode = blob["cryptoCode"].Value<string>();
-            Type = cryptoCode + "_" + blob["cryptoPaymentDataType"].Value<string>();
-            Type = MigrationExtensions.MigratePaymentMethodId(Type);
-            var divisibility = MigrationExtensions.GetDivisibility(Type);
+            MigratedPaymentMethodId = PaymentMethodId;
+            PaymentMethodId = cryptoCode + "_" + blob["cryptoPaymentDataType"].Value<string>();
+            PaymentMethodId = MigrationExtensions.MigratePaymentMethodId(PaymentMethodId);
+            var divisibility = MigrationExtensions.GetDivisibility(PaymentMethodId);
             Currency = blob["cryptoCode"].Value<string>();
             blob.Remove("cryptoCode");
             blob.Remove("cryptoPaymentDataType");
@@ -87,7 +92,7 @@ namespace BTCPayServer.Data
             blob.Remove("output");
             blob.Remove("outpoint");
             // Convert from sats to btc
-            if (cryptoData["value"] is not (null or { Type: JTokenType.Null }))
+            if (cryptoData["value"] is not (null or { Type: JTokenType.Null } or { Type: JTokenType.Object }))
             {
                 var v = cryptoData["value"].Value<long>();
                 Amount = (decimal)v / (decimal)Money.COIN;
@@ -98,7 +103,22 @@ namespace BTCPayServer.Data
                 blob.ConvertNumberToString("paymentMethodFee");
                 blob.Remove("networkFee");
                 blob.RemoveIfNull("paymentMethodFee");
-			}
+            }
+            // Liquid
+            else if (cryptoData["value"] is { Type: JTokenType.Object })
+            {
+                var v = cryptoData["value"]["value"].Value<long>();
+                var assetId = cryptoData["value"]["assetId"].Value<string>();
+                divisibility = GetDivisibility(assetId) ?? 8;
+                Amount = (decimal)v / (decimal)Math.Pow(10.0, divisibility);
+                cryptoData.Remove("value");
+                cryptoData["assetId"] = assetId;
+                blob["paymentMethodFee"] = blob["networkFee"];
+                blob.RemoveIfValue<decimal>("paymentMethodFee", 0.0m);
+                blob.ConvertNumberToString("paymentMethodFee");
+                blob.Remove("networkFee");
+                blob.RemoveIfNull("paymentMethodFee");
+            }
             // Convert from millisats to btc
             else if (cryptoData["amount"] is not (null or { Type: JTokenType.Null }))
             {
@@ -157,8 +177,25 @@ namespace BTCPayServer.Data
 			Blob2 = blob.ToString(Formatting.None);
             Accounted = null;
 #pragma warning restore CS0618 // Type or member is obsolete
+            return true;
         }
 
+        private int? GetDivisibility(string assetId) =>
+        assetId switch
+        {
+            "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2" => 8,
+            "aa775044c32a7df391902b3659f46dfe004ccb2644ce2ddc7dba31e889391caf" => 2,
+            "0e99c1a6da379d1f4151fb9df90449d40d0608f6cb33a5bcbfc8c265f42bab0a" => 8,
+            "6f0279e9ed041c3d710a9f57d0c02928416460c4b722ae3457a11eec381c526d" => 8,
+            _ => null,
+        };
+
+        [NotMapped]
+        public bool Migrated { get; set; }
+        [NotMapped]
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public string MigratedPaymentMethodId { get; set; }
+
         static readonly DateTimeOffset unixRef = new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero);
         public static long DateTimeToMilliUnixTime(in DateTime time)
         {

BTCPayServer.Data/Data/PaymentData.cs

@@ -1,4 +1,5 @@
 using System;
+using System.ComponentModel.DataAnnotations.Schema;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 
@@ -26,13 +27,15 @@ namespace BTCPayServer.Data
         [Obsolete("Use Blob2 instead")]
         public byte[] Blob { get; set; }
         public string Blob2 { get; set; }
-        public string Type { get; set; }
+        public string PaymentMethodId { get; set; }
         [Obsolete("Use Status instead")]
         public bool? Accounted { get; set; }
         public PaymentStatus? Status { get; set; }
-
-        internal static void OnModelCreating(ModelBuilder builder, DatabaseFacade databaseFacade)
+        public static bool IsPending(PaymentStatus? status) => throw new NotSupportedException();
+        internal static void OnModelCreating(ModelBuilder builder)
         {
+            builder.Entity<PaymentData>()
+                .HasKey(o => new { o.Id, o.PaymentMethodId });
             builder.Entity<PaymentData>()
                    .HasOne(o => o.InvoiceData)
                    .WithMany(i => i.Payments).OnDelete(DeleteBehavior.Cascade);
@@ -47,6 +50,7 @@ namespace BTCPayServer.Data
             builder.Entity<PaymentData>()
                     .Property(o => o.Amount)
                     .HasColumnType("NUMERIC");
+            builder.HasDbFunction(typeof(PaymentData).GetMethod(nameof(IsPending), new[] { typeof(PaymentStatus?) }), b => b.HasName("is_pending"));
         }
     }
 }

BTCPayServer.Data/Data/PaymentRequestData.Migration.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Linq;
+using System.Reflection.Metadata;
+using System.Text;
+using System.Threading.Tasks;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Data
+{
+    public partial class PaymentRequestData : MigrationInterceptor.IHasMigration
+    {
+        [NotMapped]
+        public bool Migrated { get; set; }
+
+        public bool TryMigrate()
+        {
+#pragma warning disable CS0618 // Type or member is obsolete
+            if (Blob is null && Blob2 is not null)
+                return false;
+            if (Blob2 is null)
+            {
+                Blob2 = Blob is not (null or { Length: 0 }) ? MigrationExtensions.Unzip(Blob) : "{}";
+                Blob2 = MigrationExtensions.SanitizeJSON(Blob2);
+            }
+            Blob = null;
+#pragma warning restore CS0618 // Type or member is obsolete
+            var jobj = JObject.Parse(Blob2);
+            // Fixup some legacy payment requests
+            if (jobj["expiryDate"].Type == JTokenType.Date)
+            {
+                jobj["expiryDate"] = new JValue(NBitcoin.Utils.DateTimeToUnixTime(jobj["expiryDate"].Value<DateTime>()));
+                Blob2 = jobj.ToString(Newtonsoft.Json.Formatting.None);
+            }
+            return true;
+        }
+    }
+}

BTCPayServer.Data/Data/PaymentRequestData.cs

@@ -4,7 +4,7 @@ using Microsoft.EntityFrameworkCore.Infrastructure;
 
 namespace BTCPayServer.Data
 {
-    public class PaymentRequestData : IHasBlobUntyped
+    public partial class PaymentRequestData : IHasBlobUntyped
     {
         public string Id { get; set; }
         public DateTimeOffset Created { get; set; }

BTCPayServer.Data/Data/PayoutData.cs

@@ -1,11 +1,9 @@
 using System;
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
-using System.Text;
 using BTCPayServer.Client.Models;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
 using NBitcoin;
 
 namespace BTCPayServer.Data
@@ -44,7 +42,14 @@ namespace BTCPayServer.Data
         public string Blob { get; set; }
         public string Proof { get; set; }
 #nullable enable
-        public string? Destination { get; set; }
+        /// <summary>
+        /// For example, BTC-CHAIN needs to ensure that only a single address is tied to an active payout.
+        /// If `PayoutBlob.Destination` is `bitcoin://1BvBMSeYstWetqTFn5Au4m4GFg7xJaNVN2?amount=0.1`
+        /// Then `DedupId` is `1BvBMSeYstWetqTFn5Au4m4GFg7xJaNVN2`
+        /// For Lightning, Destination could be the lightning address, BOLT11 or LNURL
+        /// But the `DedupId` would be the `PaymentHash`.
+        /// </summary>
+        public string? DedupId { get; set; }
 #nullable restore
         public StoreData StoreData { get; set; }
 
@@ -62,11 +67,11 @@ namespace BTCPayServer.Data
             builder.Entity<PayoutData>()
                 .HasIndex(o => o.State);
             builder.Entity<PayoutData>()
-                .HasIndex(x => new { DestinationId = x.Destination, x.State });
+                .HasIndex(x => new { DestinationId = x.DedupId, x.State });
 
             builder.Entity<PayoutData>()
                 .Property(o => o.Blob)
-                .HasColumnType("JSONB");
+                .HasColumnType("jsonb");
             builder.Entity<PayoutData>()
                 .Property(o => o.Proof)
                 .HasColumnType("JSONB");

BTCPayServer.Data/Data/PayoutProcessorData.cs

@@ -16,7 +16,7 @@ public class PayoutProcessorData : IHasBlobUntyped
     public string Id { get; set; }
     public string StoreId { get; set; }
     public StoreData Store { get; set; }
-    public string PaymentMethod { get; set; }
+    public string PayoutMethodId { get; set; }
     public string Processor { get; set; }
 
     [Obsolete("Use Blob2 instead")]
@@ -36,6 +36,6 @@ public class PayoutProcessorData : IHasBlobUntyped
 
     public override string ToString()
     {
-        return $"{Processor} {PaymentMethod} {StoreId}";
+        return $"{Processor} {PayoutMethodId} {StoreId}";
     }
 }

BTCPayServer.Data/Data/PendingInvoiceData.cs

@@ -1,18 +0,0 @@
-using Microsoft.EntityFrameworkCore;
-
-namespace BTCPayServer.Data
-{
-    public class PendingInvoiceData
-    {
-        public string Id { get; set; }
-        public InvoiceData InvoiceData { get; set; }
-
-        internal static void OnModelCreating(ModelBuilder builder)
-        {
-            builder.Entity<PendingInvoiceData>()
-                .HasOne(o => o.InvoiceData)
-                .WithMany(o => o.PendingInvoices)
-                .HasForeignKey(o => o.Id).OnDelete(DeleteBehavior.Cascade);
-        }
-    }
-}

BTCPayServer.Data/Data/PendingTransaction.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations.Schema;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+
+namespace BTCPayServer.Data;
+
+public class PendingTransaction: IHasBlob<PendingTransactionBlob>
+    {
+        public string TransactionId { get; set; }
+        public string CryptoCode { get; set; }
+        public string StoreId { get; set; }
+        public StoreData Store { get; set; }
+        public DateTimeOffset? Expiry { get; set; }
+        public PendingTransactionState State { get; set; }
+        public string[] OutpointsUsed { get; set; }
+
+        [NotMapped][Obsolete("Use Blob2 instead")]
+        public byte[] Blob { get; set; }
+
+        public string Blob2 { get; set; }
+        
+        
+        internal static void OnModelCreating(ModelBuilder builder, DatabaseFacade databaseFacade)
+        {
+            builder.Entity<PendingTransaction>()
+                .HasOne(o => o.Store)
+                .WithMany(i => i.PendingTransactions)
+                .HasForeignKey(i => i.StoreId)
+                .OnDelete(DeleteBehavior.Cascade);
+
+            builder.Entity<PendingTransaction>().HasKey(transaction => new {transaction.CryptoCode, transaction.TransactionId});
+
+            builder.Entity<PendingTransaction>()
+                .Property(o => o.Blob2)
+                .HasColumnType("JSONB"); 
+            builder.Entity<PendingTransaction>()
+                .Property(o => o.OutpointsUsed)
+                .HasColumnType("text[]");
+        }
+    }
+    public enum PendingTransactionState
+    {
+        Pending,
+        Cancelled,
+        Expired,
+        Invalidated,
+        Signed,
+        Broadcast
+    }
+
+    public class PendingTransactionBlob
+    {
+        public string PSBT { get; set; }
+        public List<CollectedSignature> CollectedSignatures { get; set; } = new();
+    }
+
+    public class CollectedSignature
+    {
+        public DateTimeOffset Timestamp { get; set; }
+        public string ReceivedPSBT { get; set; }
+    }

BTCPayServer.Data/Data/StoreData.cs

@@ -49,6 +49,7 @@ namespace BTCPayServer.Data
         public IEnumerable<FormData> Forms { get; set; }
         public IEnumerable<StoreRole> StoreRoles { get; set; }
         public bool Archived { get; set; }
+        public IEnumerable<PendingTransaction> PendingTransactions { get; set; }
 
         internal static void OnModelCreating(ModelBuilder builder, DatabaseFacade databaseFacade)
         {

BTCPayServer.Data/Migrations/20240405052858_cleanup_address_invoices.cs

@@ -1,30 +0,0 @@
-using System;
-using BTCPayServer.Data;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace BTCPayServer.Migrations
-{
-    [DbContext(typeof(ApplicationDbContext))]
-    [Migration("20240405052858_cleanup_address_invoices")]
-    public partial class cleanup_address_invoices : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.Sql(@"
-DELETE FROM ""AddressInvoices"" WHERE ""Address"" LIKE '%_LightningLike';
-ALTER TABLE ""AddressInvoices"" DROP COLUMN IF EXISTS ""CreatedTime"";
-");
-            migrationBuilder.Sql(@"VACUUM (FULL, ANALYZE) ""AddressInvoices"";", true);
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-        }
-    }
-}

BTCPayServer.Data/Migrations/20240827034505_migratepayouts.cs

@@ -11,5 +11,30 @@ namespace BTCPayServer.Migrations
     [DBScript("002.RefactorPayouts.sql")]
     public partial class migratepayouts : DBScriptsMigration
     {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            base.Up(migrationBuilder);
+            migrationBuilder.RenameColumn(
+                name: "Destination",
+                table: "Payouts",
+                newName: "DedupId");
+            migrationBuilder.RenameIndex(
+                name: "IX_Payouts_Destination_State",
+                table: "Payouts",
+                newName: "IX_Payouts_DedupId_State");
+            migrationBuilder.RenameColumn(
+             name: "PaymentMethod",
+             table: "PayoutProcessors",
+             newName: "PayoutMethodId");
+
+            migrationBuilder.Sql("""
+                UPDATE "PayoutProcessors"
+                SET
+                "PayoutMethodId" = CASE WHEN STRPOS("PayoutMethodId", '_') = 0 THEN "PayoutMethodId" || '-CHAIN'
+                                        WHEN STRPOS("PayoutMethodId", '_LightningLike') > 0 THEN split_part("PayoutMethodId", '_LightningLike', 1) || '-LN'
+                                        WHEN STRPOS("PayoutMethodId", '_LNURLPAY') > 0 THEN split_part("PayoutMethodId",'_LNURLPAY', 1) || '-LN'
+                                        ELSE "PayoutMethodId" END
+                """);
+        }
     }
 }

BTCPayServer.Data/Migrations/20240904092905_UpdateStoreOwnerRole.cs

@@ -0,0 +1,54 @@
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Newtonsoft.Json;
+
+#nullable disable
+
+namespace BTCPayServer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20240904092905_UpdateStoreOwnerRole")]
+    public partial class UpdateStoreOwnerRole : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.UpdateData(
+                "StoreRoles",
+                keyColumns: new[] { "Id" },
+                keyColumnTypes: new[] { "TEXT" },
+                keyValues: new[] { "Owner" },
+                columns: new[] { "Permissions" },
+                columnTypes: new[] { "TEXT[]" },
+                values: new object[]
+                {
+                    new[]
+                    {
+                        "btcpay.store.canmodifystoresettings"
+                    }
+                });
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.UpdateData(
+                "StoreRoles",
+                keyColumns: new[] { "Id" },
+                keyColumnTypes: new[] { "TEXT" },
+                keyValues: new[] { "Owner" },
+                columns: new[] { "Permissions" },
+                columnTypes: new[] { "TEXT[]" },
+                values: new object[]
+                {
+                    new[]
+                    {
+                        "btcpay.store.canmodifystoresettings",
+                        "btcpay.store.cantradecustodianaccount",
+                        "btcpay.store.canwithdrawfromcustodianaccount",
+                        "btcpay.store.candeposittocustodianaccount"
+                    }
+                });
+        }
+    }
+}

BTCPayServer.Data/Migrations/20240913034505_refactorpendinginvoicespayments.cs

@@ -0,0 +1,15 @@
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace BTCPayServer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20240913034505_refactorpendinginvoicespayments")]
+    [DBScript("003.RefactorPendingInvoicesPayments.sql")]
+    public partial class refactorpendinginvoicespayments : DBScriptsMigration
+    {
+    }
+}

BTCPayServer.Data/Migrations/20240919085726_refactorinvoiceaddress.cs

@@ -0,0 +1,80 @@
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace BTCPayServer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20240919085726_refactorinvoiceaddress")]
+    public partial class refactorinvoiceaddress : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_AddressInvoices",
+                table: "AddressInvoices");
+
+            migrationBuilder.AddColumn<string>(
+                name: "PaymentMethodId",
+                table: "AddressInvoices",
+                type: "text",
+                nullable: false,
+                defaultValue: "");
+
+            migrationBuilder.Sql("""
+                UPDATE "AddressInvoices"
+                SET 
+                "Address" = (string_to_array("Address", '#'))[1],
+                "PaymentMethodId" = CASE WHEN (string_to_array("Address", '#'))[2] IS NULL THEN 'BTC-CHAIN'
+                                         WHEN STRPOS((string_to_array("Address", '#'))[2], '_') = 0 THEN (string_to_array("Address", '#'))[2] || '-CHAIN'
+                                         WHEN STRPOS((string_to_array("Address", '#'))[2], '_MoneroLike') > 0 THEN replace((string_to_array("Address", '#'))[2],'_MoneroLike','-CHAIN')
+                                         WHEN STRPOS((string_to_array("Address", '#'))[2], '_ZcashLike') > 0 THEN replace((string_to_array("Address", '#'))[2],'_ZcashLike','-CHAIN')
+                                         ELSE '' END;
+                ALTER TABLE "AddressInvoices" DROP COLUMN IF EXISTS "CreatedTime";
+                DELETE FROM "AddressInvoices" WHERE "PaymentMethodId" = '';
+                """);
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_AddressInvoices",
+                table: "AddressInvoices",
+                columns: new[] { "Address", "PaymentMethodId" });
+            migrationBuilder.Sql("VACUUM (ANALYZE) \"AddressInvoices\";", true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_AddressInvoices",
+                table: "AddressInvoices");
+
+            migrationBuilder.DropColumn(
+                name: "PaymentMethodId",
+                table: "AddressInvoices");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_AddressInvoices",
+                table: "AddressInvoices",
+                column: "Address");
+
+            migrationBuilder.CreateTable(
+                name: "PendingInvoices",
+                columns: table => new
+                {
+                    Id = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_PendingInvoices", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_PendingInvoices_Invoices_Id",
+                        column: x => x.Id,
+                        principalTable: "Invoices",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+        }
+    }
+}

BTCPayServer.Data/Migrations/20240923065254_refactorpayments.cs

@@ -0,0 +1,38 @@
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace BTCPayServer.Migrations
+{
+
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20240923065254_refactorpayments")]
+    public partial class refactorpayments : DBScriptsMigration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_Payments",
+                table: "Payments");
+
+            migrationBuilder.RenameColumn(
+                name: "Type",
+                table: "Payments",
+                newName: "PaymentMethodId");
+            migrationBuilder.Sql("UPDATE \"Payments\" SET \"PaymentMethodId\"='' WHERE \"PaymentMethodId\" IS NULL;");
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_Payments",
+                table: "Payments",
+                columns: new[] { "Id", "PaymentMethodId" });
+            base.Up(migrationBuilder);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+        }
+    }
+}

BTCPayServer.Data/Migrations/20240924065254_monitoredinvoices.cs

@@ -0,0 +1,15 @@
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace BTCPayServer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20240924065254_monitoredinvoices")]
+    [DBScript("004.MonitoredInvoices.sql")]
+    public partial class monitoredinvoices : DBScriptsMigration
+    {
+    }
+}

BTCPayServer.Data/Migrations/20241029163147_AddingPendingTransactionsTable.cs

@@ -0,0 +1,53 @@
+using System;
+using BTCPayServer.Data;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace BTCPayServer.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20241029163147_AddingPendingTransactionsTable")]
+    public partial class AddingPendingTransactionsTable : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "PendingTransactions",
+                columns: table => new
+                {
+                    TransactionId = table.Column<string>(type: "text", nullable: false),
+                    CryptoCode = table.Column<string>(type: "text", nullable: false),
+                    StoreId = table.Column<string>(type: "text", nullable: true),
+                    Expiry = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: true),
+                    State = table.Column<int>(type: "integer", nullable: false),
+                    OutpointsUsed = table.Column<string[]>(type: "text[]", nullable: true),
+                    Blob2 = table.Column<string>(type: "JSONB", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_PendingTransactions", x => new { x.CryptoCode, x.TransactionId });
+                    table.ForeignKey(
+                        name: "FK_PendingTransactions_Stores_StoreId",
+                        column: x => x.StoreId,
+                        principalTable: "Stores",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_PendingTransactions_StoreId",
+                table: "PendingTransactions",
+                column: "StoreId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "PendingTransactions");
+        }
+    }
+}

BTCPayServer.Data/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -63,10 +63,13 @@ namespace BTCPayServer.Migrations
                     b.Property<string>("Address")
                         .HasColumnType("text");
 
+                    b.Property<string>("PaymentMethodId")
+                        .HasColumnType("text");
+
                     b.Property<string>("InvoiceDataId")
                         .HasColumnType("text");
 
-                    b.HasKey("Address");
+                    b.HasKey("Address", "PaymentMethodId");
 
                     b.HasIndex("InvoiceDataId");
 
@@ -479,6 +482,9 @@ namespace BTCPayServer.Migrations
                     b.Property<string>("Id")
                         .HasColumnType("text");
 
+                    b.Property<string>("PaymentMethodId")
+                        .HasColumnType("text");
+
                     b.Property<bool?>("Accounted")
                         .HasColumnType("boolean");
 
@@ -503,10 +509,7 @@ namespace BTCPayServer.Migrations
                     b.Property<string>("Status")
                         .HasColumnType("text");
 
-                    b.Property<string>("Type")
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
+                    b.HasKey("Id", "PaymentMethodId");
 
                     b.HasIndex("InvoiceDataId");
 
@@ -557,7 +560,7 @@ namespace BTCPayServer.Migrations
                         .HasColumnType("numeric");
 
                     b.Property<string>("Blob")
-                        .HasColumnType("JSONB");
+                        .HasColumnType("jsonb");
 
                     b.Property<string>("Currency")
                         .HasColumnType("text");
@@ -565,7 +568,7 @@ namespace BTCPayServer.Migrations
                     b.Property<DateTimeOffset>("Date")
                         .HasColumnType("timestamp with time zone");
 
-                    b.Property<string>("Destination")
+                    b.Property<string>("DedupId")
                         .HasColumnType("text");
 
                     b.Property<decimal>("OriginalAmount")
@@ -601,7 +604,7 @@ namespace BTCPayServer.Migrations
 
                     b.HasIndex("StoreDataId");
 
-                    b.HasIndex("Destination", "State");
+                    b.HasIndex("DedupId", "State");
 
                     b.ToTable("Payouts");
                 });
@@ -618,7 +621,7 @@ namespace BTCPayServer.Migrations
                     b.Property<string>("Blob2")
                         .HasColumnType("JSONB");
 
-                    b.Property<string>("PaymentMethod")
+                    b.Property<string>("PayoutMethodId")
                         .HasColumnType("text");
 
                     b.Property<string>("Processor")
@@ -634,14 +637,34 @@ namespace BTCPayServer.Migrations
                     b.ToTable("PayoutProcessors");
                 });
 
-            modelBuilder.Entity("BTCPayServer.Data.PendingInvoiceData", b =>
+            modelBuilder.Entity("BTCPayServer.Data.PendingTransaction", b =>
                 {
-                    b.Property<string>("Id")
+                    b.Property<string>("CryptoCode")
                         .HasColumnType("text");
 
-                    b.HasKey("Id");
+                    b.Property<string>("TransactionId")
+                        .HasColumnType("text");
 
-                    b.ToTable("PendingInvoices");
+                    b.Property<string>("Blob2")
+                        .HasColumnType("JSONB");
+
+                    b.Property<DateTimeOffset?>("Expiry")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string[]>("OutpointsUsed")
+                        .HasColumnType("text[]");
+
+                    b.Property<int>("State")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("StoreId")
+                        .HasColumnType("text");
+
+                    b.HasKey("CryptoCode", "TransactionId");
+
+                    b.HasIndex("StoreId");
+
+                    b.ToTable("PendingTransactions");
                 });
 
             modelBuilder.Entity("BTCPayServer.Data.PlannedTransaction", b =>
@@ -1331,15 +1354,14 @@ namespace BTCPayServer.Migrations
                     b.Navigation("Store");
                 });
 
-            modelBuilder.Entity("BTCPayServer.Data.PendingInvoiceData", b =>
+            modelBuilder.Entity("BTCPayServer.Data.PendingTransaction", b =>
                 {
-                    b.HasOne("BTCPayServer.Data.InvoiceData", "InvoiceData")
-                        .WithMany("PendingInvoices")
-                        .HasForeignKey("Id")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
+                    b.HasOne("BTCPayServer.Data.StoreData", "Store")
+                        .WithMany("PendingTransactions")
+                        .HasForeignKey("StoreId")
+                        .OnDelete(DeleteBehavior.Cascade);
 
-                    b.Navigation("InvoiceData");
+                    b.Navigation("Store");
                 });
 
             modelBuilder.Entity("BTCPayServer.Data.PullPaymentData", b =>
@@ -1572,8 +1594,6 @@ namespace BTCPayServer.Migrations
 
                     b.Navigation("Payments");
 
-                    b.Navigation("PendingInvoices");
-
                     b.Navigation("Refunds");
                 });
 
@@ -1602,6 +1622,8 @@ namespace BTCPayServer.Migrations
 
                     b.Navigation("Payouts");
 
+                    b.Navigation("PendingTransactions");
+
                     b.Navigation("PullPayments");
 
                     b.Navigation("Settings");

BTCPayServer.Rating/BTCPayServer.Rating.csproj

@@ -6,9 +6,10 @@
     <FrameworkReference Include="Microsoft.AspNetCore.App" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.10.0" />
     <PackageReference Include="Microsoft.AspNet.WebApi.Client" Version="6.0.0" />
-    <PackageReference Include="NBitcoin" Version="7.0.37" />
+    <PackageReference Include="NBitcoin" Version="7.0.46" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
-    <PackageReference Include="DigitalRuby.ExchangeSharp" Version="1.0.4" />
+    <PackageReference Include="System.Text.Json" Version="8.0.5" />
+    <PackageReference Include="DigitalRuby.ExchangeSharp" Version="1.2.0" />
   </ItemGroup>
 
   <ItemGroup>

BTCPayServer.Rating/Currencies.json

@@ -1175,13 +1175,6 @@
       "symbol":null,
       "crypto":true
    },
-   {
-      "name":"USDt",
-      "code":"USDT",
-      "divisibility":8,
-      "symbol":null,
-      "crypto":true
-   },
    {
       "name":"LCAD",
       "code":"LCAD",
@@ -1315,13 +1308,6 @@
        "symbol": null,
        "crypto": true
    },
-   {
-       "name":"USDt",
-       "code":"USDT20",
-       "divisibility":6,
-       "symbol":null,
-       "crypto":true
-   },
    {
        "name":"FaucetToken",
        "code":"FAU",

BTCPayServer.Rating/CurrencyNameTable.cs

@@ -5,6 +5,9 @@ using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
 using NBitcoin;
 using Newtonsoft.Json;
 
@@ -18,14 +21,74 @@ namespace BTCPayServer.Services.Rates
         public string Symbol { get; set; }
         public bool Crypto { get; set; }
     }
-    public class CurrencyNameTable
+    public interface CurrencyDataProvider
     {
-        public static CurrencyNameTable Instance = new();
-        public CurrencyNameTable()
+        Task<CurrencyData[]> LoadCurrencyData(CancellationToken cancellationToken);
+    }
+    public class InMemoryCurrencyDataProvider : CurrencyDataProvider
+    {
+        private readonly CurrencyData[] _currencyData;
+
+        public InMemoryCurrencyDataProvider(CurrencyData[] currencyData)
         {
-            _Currencies = LoadCurrency().ToDictionary(k => k.Code, StringComparer.InvariantCultureIgnoreCase);
+            _currencyData = currencyData;
         }
 
+        public Task<CurrencyData[]> LoadCurrencyData(CancellationToken cancellationToken) => Task.FromResult(_currencyData);
+    }
+    public class AssemblyCurrencyDataProvider : CurrencyDataProvider
+    {
+        private readonly Assembly _assembly;
+        private readonly string _manifestResourceStream;
+
+        public AssemblyCurrencyDataProvider(Assembly assembly, string manifestResourceStream)
+        {
+            _assembly = assembly;
+            _manifestResourceStream = manifestResourceStream;
+        }
+        public Task<CurrencyData[]> LoadCurrencyData(CancellationToken cancellationToken)
+        {
+            var stream = _assembly.GetManifestResourceStream(_manifestResourceStream);
+            if (stream is null)
+                throw new InvalidOperationException("Unknown manifestResourceStream");
+            string content = null;
+            using (var reader = new StreamReader(stream, Encoding.UTF8))
+            {
+                content = reader.ReadToEnd();
+            }
+
+            var currencies = JsonConvert.DeserializeObject<CurrencyData[]>(content);
+            return Task.FromResult(currencies.ToArray());
+        }
+    }
+    public class CurrencyNameTable
+    {
+        public CurrencyNameTable(IEnumerable<CurrencyDataProvider> currencyDataProviders, ILogger<CurrencyNameTable> logger)
+        {
+            _currencyDataProviders = currencyDataProviders;
+            _logger = logger;
+        }
+
+        public async Task ReloadCurrencyData(CancellationToken cancellationToken)
+        {
+            var currencies = new Dictionary<string, CurrencyData>(StringComparer.InvariantCultureIgnoreCase);
+            var loadings = _currencyDataProviders.Select(c => (Task: c.LoadCurrencyData(cancellationToken), Prov: c)).ToList();
+            foreach (var loading in loadings)
+            {
+                try
+                {
+                    foreach (var curr in await loading.Task)
+                    {
+                        currencies.TryAdd(curr.Code, curr);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogWarning(ex, "Error loading currency data for " + loading.Prov.GetType().FullName);
+                }
+            }
+            _Currencies = currencies;
+        }
         static readonly Dictionary<string, IFormatProvider> _CurrencyProviders = new();
 
         public NumberFormatInfo GetNumberFormatInfo(string currency, bool useFallback)
@@ -123,20 +186,9 @@ namespace BTCPayServer.Services.Rates
             currencyProviders.TryAdd(code, number);
         }
 
-        readonly Dictionary<string, CurrencyData> _Currencies;
-
-        static CurrencyData[] LoadCurrency()
-        {
-            var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("BTCPayServer.Rating.Currencies.json");
-            string content = null;
-            using (var reader = new StreamReader(stream, Encoding.UTF8))
-            {
-                content = reader.ReadToEnd();
-            }
-
-            var currencies = JsonConvert.DeserializeObject<CurrencyData[]>(content);
-            return currencies;
-        }
+        Dictionary<string, CurrencyData> _Currencies = new();
+        private readonly IEnumerable<CurrencyDataProvider> _currencyDataProviders;
+        private readonly ILogger<CurrencyNameTable> _logger;
 
         public IEnumerable<CurrencyData> Currencies => _Currencies.Values;
 

BTCPayServer.Rating/CurrencyPair.cs

@@ -1,11 +1,22 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 using BTCPayServer.Services.Rates;
 
 namespace BTCPayServer.Rating
 {
     public class CurrencyPair
     {
+        private static readonly HashSet<string> _knownCurrencies;
+
+        static CurrencyPair()
+        {
+            var prov = new AssemblyCurrencyDataProvider(typeof(BTCPayServer.Rating.BidAsk).Assembly, "BTCPayServer.Rating.Currencies.json");
+            // It's OK this is sync function
+            _knownCurrencies = prov.LoadCurrencyData(default).GetAwaiter().GetResult()
+                .Select(c => c.Code).ToHashSet(StringComparer.OrdinalIgnoreCase);
+        }
         public CurrencyPair(string left, string right)
         {
             ArgumentNullException.ThrowIfNull(right);
@@ -49,10 +60,9 @@ namespace BTCPayServer.Rating
                 for (int i = 3; i < 5; i++)
                 {
                     var potentialCryptoName = currencyPair.Substring(0, i);
-                    var currency = CurrencyNameTable.Instance.GetCurrencyData(potentialCryptoName, false);
-                    if (currency != null)
+                    if (_knownCurrencies.Contains(potentialCryptoName))
                     {
-                        value = new CurrencyPair(currency.Code, currencyPair.Substring(i));
+                        value = new CurrencyPair(potentialCryptoName, currencyPair.Substring(i));
                         return true;
                     }
                 }

BTCPayServer.Rating/Providers/BareBitcoinRateProvider.cs

@@ -0,0 +1,39 @@
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Rating;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Services.Rates
+{
+    public class BareBitcoinRateProvider : IRateProvider
+    {
+        private readonly HttpClient _httpClient;
+        
+        public RateSourceInfo RateSourceInfo => new("barebitcoin", "Bare Bitcoin", "https://api.bb.no/price");
+
+        public BareBitcoinRateProvider(HttpClient httpClient)
+        {
+            _httpClient = httpClient ?? new HttpClient();
+        }
+
+        public async Task<PairRate[]> GetRatesAsync(CancellationToken cancellationToken)
+        {
+            using var response = await _httpClient.GetAsync(RateSourceInfo.Url, cancellationToken);
+            response.EnsureSuccessStatusCode();
+            
+            var jobj = await response.Content.ReadAsAsync<JObject>(cancellationToken);
+            
+            // Extract market and otc prices
+            var market = jobj["market"].Value<decimal>();
+            var buy = jobj["buy"].Value<decimal>();
+            var sell = jobj["sell"].Value<decimal>();
+
+            // Create currency pair for BTC/NOK
+            var pair = new CurrencyPair("BTC", "NOK");
+            
+            // Return single pair rate with sell/buy as bid/ask
+            return new[] { new PairRate(pair, new BidAsk(sell, buy)) };
+        }
+    }
+}

BTCPayServer.Rating/Providers/BitmyntRateProvider.cs

@@ -0,0 +1,39 @@
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Rating;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Services.Rates
+{
+    public class BitmyntRateProvider : IRateProvider
+    {
+        private readonly HttpClient _httpClient;
+        
+        public RateSourceInfo RateSourceInfo => new("bitmynt", "Bitmynt", "https://ny.bitmynt.no/data/rates.json");
+
+        public BitmyntRateProvider(HttpClient httpClient)
+        {
+            _httpClient = httpClient ?? new HttpClient();
+        }
+
+        public async Task<PairRate[]> GetRatesAsync(CancellationToken cancellationToken)
+        {
+            using var response = await _httpClient.GetAsync(RateSourceInfo.Url, cancellationToken);
+            response.EnsureSuccessStatusCode();
+            
+            var jobj = await response.Content.ReadAsAsync<JObject>(cancellationToken);
+            
+            // Extract bid and ask prices from current_rate object
+            var currentRate = jobj["current_rate"];
+            var bid = currentRate["bid"].Value<decimal>();
+            var ask = currentRate["ask"].Value<decimal>();
+
+            // Create currency pair for BTC/NOK
+            var pair = new CurrencyPair("BTC", "NOK");
+            
+            // Return single pair rate with bid/ask
+            return new[] { new PairRate(pair, new BidAsk(bid, ask)) };
+        }
+    }
+}

BTCPayServer.Tests/AltcoinTests/AltcoinTests.cs

@@ -3,10 +3,9 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
+using BTCPayServer.Client.Models;
 using BTCPayServer.Controllers;
 using BTCPayServer.Data;
-using BTCPayServer.Events;
-using BTCPayServer.HostedServices;
 using BTCPayServer.Hosting;
 using BTCPayServer.Lightning;
 using BTCPayServer.Models.AppViewModels;
@@ -25,7 +24,7 @@ using Newtonsoft.Json.Linq;
 using OpenQA.Selenium;
 using Xunit;
 using Xunit.Abstractions;
-using Xunit.Sdk;
+using PosViewType = BTCPayServer.Plugins.PointOfSale.PosViewType;
 using WalletSettingsViewModel = BTCPayServer.Models.StoreViewModels.WalletSettingsViewModel;
 
 namespace BTCPayServer.Tests
@@ -94,16 +93,16 @@ namespace BTCPayServer.Tests
                 Assert.IsType<ViewResult>(response);
 
                 // Get enabled state from settings
-                response = controller.WalletSettings(user.StoreId, cryptoCode).GetAwaiter().GetResult();
+                response = await controller.WalletSettings(user.StoreId, cryptoCode);
                 var onchainSettingsModel = (WalletSettingsViewModel)Assert.IsType<ViewResult>(response).Model;
                 Assert.NotNull(onchainSettingsModel?.DerivationScheme);
                 Assert.True(onchainSettingsModel.Enabled);
 
                 // Disable wallet
                 onchainSettingsModel.Enabled = false;
-                response = controller.UpdateWalletSettings(onchainSettingsModel).GetAwaiter().GetResult();
+                response = await controller.UpdateWalletSettings(onchainSettingsModel);
                 Assert.IsType<RedirectToActionResult>(response);
-                response = controller.WalletSettings(user.StoreId, cryptoCode).GetAwaiter().GetResult();
+                response = await controller.WalletSettings(user.StoreId, cryptoCode);
                 onchainSettingsModel = (WalletSettingsViewModel)Assert.IsType<ViewResult>(response).Model;
                 Assert.NotNull(onchainSettingsModel?.DerivationScheme);
                 Assert.False(onchainSettingsModel.Enabled);
@@ -125,7 +124,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 = await controller.ConfirmDeleteWallet(user.StoreId, cryptoCode);
                 Assert.IsType<RedirectToActionResult>(response);
 
                 // Setting it again should show the confirmation page
@@ -175,7 +174,7 @@ namespace BTCPayServer.Tests
                 Assert.Equal("ElectrumFile", settingsVm.Source);
 
                 // Now let's check that no data has been lost in the process
-                var store = tester.PayTester.StoreRepository.FindStore(storeId).GetAwaiter().GetResult();
+                var store = await tester.PayTester.StoreRepository.FindStore(storeId);
                 var handlers = tester.PayTester.GetService<PaymentMethodHandlerDictionary>();
                 var pmi = PaymentTypes.CHAIN.GetPaymentMethodId("BTC");
                 var onchainBTC = store.GetPaymentMethodConfig<DerivationSchemeSettings>(pmi, handlers);
@@ -207,7 +206,7 @@ namespace BTCPayServer.Tests
                     Assert.Equal("paid", invoice.Status);
                 });
                 var wallet = tester.PayTester.GetController<UIWalletsController>();
-                var psbt = wallet.CreatePSBT(btcNetwork, onchainBTC,
+                var psbt = await wallet.CreatePSBT(btcNetwork, onchainBTC,
                     new WalletSendModel()
                     {
                         Outputs = new List<WalletSendModel.TransactionOutput>
@@ -220,7 +219,7 @@ namespace BTCPayServer.Tests
                             }
                         },
                         FeeSatoshiPerByte = 1
-                    }, default).GetAwaiter().GetResult();
+                    }, default);
 
                 Assert.NotNull(psbt);
 
@@ -320,10 +319,10 @@ namespace BTCPayServer.Tests
 
                 var controller = tester.PayTester.GetController<UIInvoiceController>(null);
                 var checkout =
-                    (Models.InvoicingModels.PaymentModel)((JsonResult)controller.GetStatus(invoice.Id)
+                    (Models.InvoicingModels.CheckoutModel)((JsonResult)controller.GetStatus(invoice.Id)
                         .GetAwaiter().GetResult()).Value;
-                Assert.Single(checkout.AvailableCryptos);
-                Assert.Equal("LTC", checkout.CryptoCode);
+                Assert.Single(checkout.AvailablePaymentMethods);
+                Assert.Equal("LTC", checkout.PaymentMethodCurrency);
 
                 //////////////////////
 
@@ -337,7 +336,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.CheckoutModel)((JsonResult)controller.GetStatus(invoice.Id)
                         .GetAwaiter().GetResult()).Value;
                     Assert.Equal("Processing", checkout.Status);
                 });
@@ -441,136 +440,135 @@ namespace BTCPayServer.Tests
         [Trait("Altcoins", "Altcoins")]
         public async Task CanPayWithTwoCurrencies()
         {
-            using (var tester = CreateServerTester())
+            using var tester = CreateServerTester();
+            
+            tester.ActivateLTC();
+            await tester.StartAsync();
+            var user = tester.NewAccount();
+            await user.GrantAccessAsync();
+            user.RegisterDerivationScheme("BTC");
+            // First we try payment with a merchant having only BTC
+            var invoice = await user.BitPay.CreateInvoiceAsync(
+                new Invoice
+                {
+                    Price = 5000.0m,
+                    Currency = "USD",
+                    PosData = "posData",
+                    OrderId = "orderId",
+                    ItemDesc = "Some description",
+                    FullNotifications = true
+                }, Facade.Merchant);
+
+            var cashCow = tester.ExplorerNode;
+            await cashCow.GenerateAsync(2); // get some money in case
+            var invoiceAddress = BitcoinAddress.Create(invoice.BitcoinAddress, cashCow.Network);
+            var firstPayment = Money.Coins(0.04m);
+            await cashCow.SendToAddressAsync(invoiceAddress, firstPayment);
+            TestUtils.Eventually(() =>
             {
-                tester.ActivateLTC();
-                await tester.StartAsync();
-                var user = tester.NewAccount();
-                await user.GrantAccessAsync();
-                user.RegisterDerivationScheme("BTC");
-                // First we try payment with a merchant having only BTC
-                var invoice = await user.BitPay.CreateInvoiceAsync(
-                    new Invoice
-                    {
-                        Price = 5000.0m,
-                        Currency = "USD",
-                        PosData = "posData",
-                        OrderId = "orderId",
-                        ItemDesc = "Some description",
-                        FullNotifications = true
-                    }, Facade.Merchant);
+                invoice = user.BitPay.GetInvoice(invoice.Id);
+                Assert.True(invoice.BtcPaid == firstPayment);
+            });
 
-                var cashCow = tester.ExplorerNode;
-                await cashCow.GenerateAsync(2); // get some money in case
-                var invoiceAddress = BitcoinAddress.Create(invoice.BitcoinAddress, cashCow.Network);
-                var firstPayment = Money.Coins(0.04m);
-                await cashCow.SendToAddressAsync(invoiceAddress, firstPayment);
-                TestUtils.Eventually(() =>
-                {
-                    invoice = user.BitPay.GetInvoice(invoice.Id);
-                    Assert.True(invoice.BtcPaid == firstPayment);
-                });
+            Assert.Single(invoice.CryptoInfo); // Only BTC should be presented
 
-                Assert.Single(invoice.CryptoInfo); // Only BTC should be presented
-
-                var controller = tester.PayTester.GetController<UIInvoiceController>(null);
-                var checkout =
-                    (Models.InvoicingModels.PaymentModel)((JsonResult)controller.GetStatus(invoice.Id, null)
-                        .GetAwaiter().GetResult()).Value;
-                Assert.Single(checkout.AvailableCryptos);
-                Assert.Equal("BTC", checkout.CryptoCode);
-
-                Assert.Single(invoice.PaymentCodes);
-                Assert.Single(invoice.SupportedTransactionCurrencies);
-                Assert.Single(invoice.SupportedTransactionCurrencies);
-                Assert.Single(invoice.PaymentSubtotals);
-                Assert.Single(invoice.PaymentTotals);
-                Assert.True(invoice.PaymentCodes.ContainsKey("BTC"));
-                Assert.True(invoice.SupportedTransactionCurrencies.ContainsKey("BTC"));
-                Assert.True(invoice.SupportedTransactionCurrencies["BTC"].Enabled);
-                Assert.True(invoice.PaymentSubtotals.ContainsKey("BTC"));
-                Assert.True(invoice.PaymentTotals.ContainsKey("BTC"));
-                //////////////////////
-
-                // Retry now with LTC enabled
-                user.RegisterDerivationScheme("LTC");
-                invoice = await user.BitPay.CreateInvoiceAsync(
-                    new Invoice
-                    {
-                        Price = 5000.0m,
-                        Currency = "USD",
-                        PosData = "posData",
-                        OrderId = "orderId",
-                        ItemDesc = "Some description",
-                        FullNotifications = true
-                    }, Facade.Merchant);
-
-                cashCow = tester.ExplorerNode;
-                invoiceAddress = BitcoinAddress.Create(invoice.BitcoinAddress, cashCow.Network);
-                firstPayment = Money.Coins(0.04m);
-                await cashCow.SendToAddressAsync(invoiceAddress, firstPayment);
-                TestLogs.LogInformation("First payment sent to " + invoiceAddress);
-                TestUtils.Eventually(() =>
-                {
-                    invoice = user.BitPay.GetInvoice(invoice.Id);
-                    Assert.True(invoice.BtcPaid == firstPayment);
-                });
-
-                cashCow = tester.LTCExplorerNode;
-                var ltcCryptoInfo = invoice.CryptoInfo.FirstOrDefault(c => c.CryptoCode == "LTC");
-                Assert.NotNull(ltcCryptoInfo);
-                invoiceAddress = BitcoinAddress.Create(ltcCryptoInfo.Address, cashCow.Network);
-                var secondPayment = Money.Coins(decimal.Parse(ltcCryptoInfo.Due, CultureInfo.InvariantCulture));
-                await cashCow.GenerateAsync(4); // LTC is not worth a lot, so just to make sure we have money...
-                await cashCow.SendToAddressAsync(invoiceAddress, secondPayment);
-                TestLogs.LogInformation("Second payment sent to " + invoiceAddress);
-                TestUtils.Eventually(() =>
-                {
-                    invoice = user.BitPay.GetInvoice(invoice.Id);
-                    Assert.Equal(Money.Zero, invoice.BtcDue);
-                    var ltcPaid = invoice.CryptoInfo.First(c => c.CryptoCode == "LTC");
-                    Assert.Equal(Money.Zero, ltcPaid.Due);
-                    Assert.Equal(secondPayment, ltcPaid.CryptoPaid);
-                    Assert.Equal("paid", invoice.Status);
-                    Assert.False((bool)((JValue)invoice.ExceptionStatus).Value);
-                });
-
-                controller = tester.PayTester.GetController<UIInvoiceController>(null);
-                checkout = (Models.InvoicingModels.PaymentModel)((JsonResult)controller.GetStatus(invoice.Id, "LTC")
+            var controller = tester.PayTester.GetController<UIInvoiceController>(null);
+            var checkout =
+                (Models.InvoicingModels.CheckoutModel)((JsonResult)controller.GetStatus(invoice.Id, null)
                     .GetAwaiter().GetResult()).Value;
-                Assert.Equal(2, checkout.AvailableCryptos.Count);
-                Assert.Equal("LTC", checkout.CryptoCode);
+            Assert.Single(checkout.AvailablePaymentMethods);
+            Assert.Equal("BTC", checkout.PaymentMethodCurrency);
 
-                Assert.Equal(2, invoice.PaymentCodes.Count());
-                Assert.Equal(2, invoice.SupportedTransactionCurrencies.Count());
-                Assert.Equal(2, invoice.SupportedTransactionCurrencies.Count());
-                Assert.Equal(2, invoice.PaymentSubtotals.Count());
-                Assert.Equal(2, invoice.PaymentTotals.Count());
-                Assert.True(invoice.PaymentCodes.ContainsKey("LTC"));
-                Assert.True(invoice.SupportedTransactionCurrencies.ContainsKey("LTC"));
-                Assert.True(invoice.SupportedTransactionCurrencies["LTC"].Enabled);
-                Assert.True(invoice.PaymentSubtotals.ContainsKey("LTC"));
-                Assert.True(invoice.PaymentTotals.ContainsKey("LTC"));
+            Assert.Single(invoice.PaymentCodes);
+            Assert.Single(invoice.SupportedTransactionCurrencies);
+            Assert.Single(invoice.SupportedTransactionCurrencies);
+            Assert.Single(invoice.PaymentSubtotals);
+            Assert.Single(invoice.PaymentTotals);
+            Assert.True(invoice.PaymentCodes.ContainsKey("BTC"));
+            Assert.True(invoice.SupportedTransactionCurrencies.ContainsKey("BTC"));
+            Assert.True(invoice.SupportedTransactionCurrencies["BTC"].Enabled);
+            Assert.True(invoice.PaymentSubtotals.ContainsKey("BTC"));
+            Assert.True(invoice.PaymentTotals.ContainsKey("BTC"));
+            //////////////////////
 
-                // Check if we can disable LTC
-                invoice = await user.BitPay.CreateInvoiceAsync(
-                    new Invoice
+            // Retry now with LTC enabled
+            user.RegisterDerivationScheme("LTC");
+            invoice = await user.BitPay.CreateInvoiceAsync(
+                new Invoice
+                {
+                    Price = 5000.0m,
+                    Currency = "USD",
+                    PosData = "posData",
+                    OrderId = "orderId",
+                    ItemDesc = "Some description",
+                    FullNotifications = true
+                }, Facade.Merchant);
+
+            cashCow = tester.ExplorerNode;
+            invoiceAddress = BitcoinAddress.Create(invoice.BitcoinAddress, cashCow.Network);
+            firstPayment = Money.Coins(0.04m);
+            await cashCow.SendToAddressAsync(invoiceAddress, firstPayment);
+            TestLogs.LogInformation("First payment sent to " + invoiceAddress);
+            TestUtils.Eventually(() =>
+            {
+                invoice = user.BitPay.GetInvoice(invoice.Id);
+                Assert.True(invoice.BtcPaid == firstPayment);
+            });
+
+            cashCow = tester.LTCExplorerNode;
+            var ltcCryptoInfo = invoice.CryptoInfo.FirstOrDefault(c => c.CryptoCode == "LTC");
+            Assert.NotNull(ltcCryptoInfo);
+            invoiceAddress = BitcoinAddress.Create(ltcCryptoInfo.Address, cashCow.Network);
+            var secondPayment = Money.Coins(decimal.Parse(ltcCryptoInfo.Due, CultureInfo.InvariantCulture));
+            await cashCow.GenerateAsync(4); // LTC is not worth a lot, so just to make sure we have money...
+            await cashCow.SendToAddressAsync(invoiceAddress, secondPayment);
+            TestLogs.LogInformation("Second payment sent to " + invoiceAddress);
+            TestUtils.Eventually(() =>
+            {
+                invoice = user.BitPay.GetInvoice(invoice.Id);
+                Assert.Equal(Money.Zero, invoice.BtcDue);
+                var ltcPaid = invoice.CryptoInfo.First(c => c.CryptoCode == "LTC");
+                Assert.Equal(Money.Zero, ltcPaid.Due);
+                Assert.Equal(secondPayment, ltcPaid.CryptoPaid);
+                Assert.Equal("paid", invoice.Status);
+                Assert.False((bool)((JValue)invoice.ExceptionStatus).Value);
+            });
+
+            controller = tester.PayTester.GetController<UIInvoiceController>(null);
+            checkout = (Models.InvoicingModels.CheckoutModel)((JsonResult)controller.GetStatus(invoice.Id, "LTC")
+                .GetAwaiter().GetResult()).Value;
+            Assert.Equal(2, checkout.AvailablePaymentMethods.Count);
+            Assert.Equal("LTC", checkout.PaymentMethodCurrency);
+
+            Assert.Equal(2, invoice.PaymentCodes.Count());
+            Assert.Equal(2, invoice.SupportedTransactionCurrencies.Count());
+            Assert.Equal(2, invoice.SupportedTransactionCurrencies.Count());
+            Assert.Equal(2, invoice.PaymentSubtotals.Count());
+            Assert.Equal(2, invoice.PaymentTotals.Count());
+            Assert.True(invoice.PaymentCodes.ContainsKey("LTC"));
+            Assert.True(invoice.SupportedTransactionCurrencies.ContainsKey("LTC"));
+            Assert.True(invoice.SupportedTransactionCurrencies["LTC"].Enabled);
+            Assert.True(invoice.PaymentSubtotals.ContainsKey("LTC"));
+            Assert.True(invoice.PaymentTotals.ContainsKey("LTC"));
+
+            // Check if we can disable LTC
+            invoice = await user.BitPay.CreateInvoiceAsync(
+                new Invoice
+                {
+                    Price = 5000.0m,
+                    Currency = "USD",
+                    PosData = "posData",
+                    OrderId = "orderId",
+                    ItemDesc = "Some description",
+                    FullNotifications = true,
+                    SupportedTransactionCurrencies = new Dictionary<string, InvoiceSupportedTransactionCurrency>()
                     {
-                        Price = 5000.0m,
-                        Currency = "USD",
-                        PosData = "posData",
-                        OrderId = "orderId",
-                        ItemDesc = "Some description",
-                        FullNotifications = true,
-                        SupportedTransactionCurrencies = new Dictionary<string, InvoiceSupportedTransactionCurrency>()
-                        {
-                            {"BTC", new InvoiceSupportedTransactionCurrency() {Enabled = true}}
-                        }
-                    }, Facade.Merchant);
+                        {"BTC", new InvoiceSupportedTransactionCurrency() {Enabled = true}}
+                    }
+                }, Facade.Merchant);
 
-                Assert.Single(invoice.CryptoInfo.Where(c => c.CryptoCode == "BTC"));
-                Assert.Empty(invoice.CryptoInfo.Where(c => c.CryptoCode == "LTC"));
-            }
+            Assert.Single(invoice.CryptoInfo, c => c.CryptoCode == "BTC");
+            Assert.DoesNotContain(invoice.CryptoInfo, c => c.CryptoCode == "LTC");
         }
 
         [Fact]
@@ -745,7 +743,7 @@ noninventoryitem:
                 invoices = user.BitPay.GetInvoices();
                 Assert.Equal(2, invoices.Count(invoice => invoice.ItemCode.Equals("noninventoryitem")));
                 var inventoryItemInvoice =
-                    Assert.Single(invoices.Where(invoice => invoice.ItemCode.Equals("inventoryitem")));
+                    Assert.Single(invoices, invoice => invoice.ItemCode.Equals("inventoryitem"));
                 Assert.NotNull(inventoryItemInvoice);
 
                 //let's mark the inventoryitem invoice as invalid, this should return the item to back in stock
@@ -759,39 +757,6 @@ noninventoryitem:
                         AppService.Parse(vmpos.Template).Single(item => item.Id == "inventoryitem").Inventory);
                 }, 10000);
 
-                //test payment methods option
-                vmpos = await pos.UpdatePointOfSale(app.Id).AssertViewModelAsync<UpdatePointOfSaleViewModel>();
-                vmpos.Title = "hello";
-                vmpos.Currency = "BTC";
-                vmpos.Template = @"
-btconly:
-  price: 1.0
-  title: good apple
-  payment_methods:
-    - BTC
-normal:
-  price: 1.0";
-                vmpos.Template = AppService.SerializeTemplate(MigrationStartupTask.ParsePOSYML(vmpos.Template));
-                Assert.IsType<RedirectToActionResult>(pos.UpdatePointOfSale(app.Id, vmpos).Result);
-                Assert.IsType<RedirectToActionResult>(publicApps
-                    .ViewPointOfSale(app.Id, PosViewType.Cart, 1, choiceKey: "btconly").Result);
-                Assert.IsType<RedirectToActionResult>(publicApps
-                    .ViewPointOfSale(app.Id, PosViewType.Cart, 1, choiceKey: "normal").Result);
-                invoices = user.BitPay.GetInvoices();
-                var normalInvoice = invoices.Single(invoice => invoice.ItemCode == "normal");
-                var btcOnlyInvoice = invoices.Single(invoice => invoice.ItemCode == "btconly");
-                Assert.Single(btcOnlyInvoice.CryptoInfo);
-                Assert.Equal("BTC",
-                    btcOnlyInvoice.CryptoInfo.First().CryptoCode);
-                Assert.Equal("BTC-CHAIN",
-                    btcOnlyInvoice.CryptoInfo.First().PaymentType);
-
-                Assert.Equal(2, normalInvoice.CryptoInfo.Length);
-                Assert.Contains(
-                    normalInvoice.CryptoInfo,
-                    s => "BTC-CHAIN" == s.PaymentType && new[] { "BTC", "LTC" }.Contains(
-                             s.CryptoCode));
-
                 //test topup option
                 vmpos.Template = @"
 a:
@@ -821,13 +786,13 @@ g:
                 vmpos = await pos.UpdatePointOfSale(app.Id).AssertViewModelAsync<UpdatePointOfSaleViewModel>();
                 Assert.DoesNotContain("custom", vmpos.Template);
                 var items = AppService.Parse(vmpos.Template);
-                Assert.Contains(items, item => item.Id == "a" && item.PriceType == ViewPointOfSaleViewModel.ItemPriceType.Fixed);
-                Assert.Contains(items, item => item.Id == "b" && item.PriceType == ViewPointOfSaleViewModel.ItemPriceType.Fixed);
-                Assert.Contains(items, item => item.Id == "c" && item.PriceType == ViewPointOfSaleViewModel.ItemPriceType.Minimum);
-                Assert.Contains(items, item => item.Id == "d" && item.PriceType == ViewPointOfSaleViewModel.ItemPriceType.Fixed);
-                Assert.Contains(items, item => item.Id == "e" && item.PriceType == ViewPointOfSaleViewModel.ItemPriceType.Minimum);
-                Assert.Contains(items, item => item.Id == "f" && item.PriceType == ViewPointOfSaleViewModel.ItemPriceType.Topup);
-                Assert.Contains(items, item => item.Id == "g" && item.PriceType == ViewPointOfSaleViewModel.ItemPriceType.Topup);
+                Assert.Contains(items, item => item.Id == "a" && item.PriceType == AppItemPriceType.Fixed);
+                Assert.Contains(items, item => item.Id == "b" && item.PriceType == AppItemPriceType.Fixed);
+                Assert.Contains(items, item => item.Id == "c" && item.PriceType == AppItemPriceType.Minimum);
+                Assert.Contains(items, item => item.Id == "d" && item.PriceType == AppItemPriceType.Fixed);
+                Assert.Contains(items, item => item.Id == "e" && item.PriceType == AppItemPriceType.Minimum);
+                Assert.Contains(items, item => item.Id == "f" && item.PriceType == AppItemPriceType.Topup);
+                Assert.Contains(items, item => item.Id == "g" && item.PriceType == AppItemPriceType.Topup);
 
                 Assert.IsType<RedirectToActionResult>(publicApps
                     .ViewPointOfSale(app.Id, PosViewType.Static, choiceKey: "g").Result);

BTCPayServer.Tests/AltcoinTests/ElementsTests.cs

@@ -63,7 +63,6 @@ namespace BTCPayServer.Tests
                 //no tether on our regtest, lets create it and set it
                 var tether = tester.NetworkProvider.GetNetwork<ElementsBTCPayNetwork>("USDT");
                 var lbtc = tester.NetworkProvider.GetNetwork<ElementsBTCPayNetwork>("LBTC");
-                var etb = tester.NetworkProvider.GetNetwork<ElementsBTCPayNetwork>("ETB");
                 var issueAssetResult = await tester.LBTCExplorerNode.SendCommandAsync("issueasset", 100000, 0);
                 tether.AssetId = uint256.Parse(issueAssetResult.Result["asset"].ToString());
                 ((ElementsBTCPayNetwork)tester.PayTester.GetService<BTCPayWalletProvider>().GetWallet("USDT").Network)
@@ -71,15 +70,10 @@ namespace BTCPayServer.Tests
                 Assert.Equal(tether.AssetId, tester.NetworkProvider.GetNetwork<ElementsBTCPayNetwork>("USDT").AssetId);
                 Assert.Equal(tether.AssetId, ((ElementsBTCPayNetwork)tester.PayTester.GetService<BTCPayWalletProvider>().GetWallet("USDT").Network).AssetId);
 
-                var issueAssetResult2 = await tester.LBTCExplorerNode.SendCommandAsync("issueasset", 100000, 0);
-                etb.AssetId = uint256.Parse(issueAssetResult2.Result["asset"].ToString());
-                ((ElementsBTCPayNetwork)tester.PayTester.GetService<BTCPayWalletProvider>().GetWallet("ETB").Network)
-                    .AssetId = etb.AssetId;
 
 
                 user.RegisterDerivationScheme("LBTC");
                 user.RegisterDerivationScheme("USDT");
-                user.RegisterDerivationScheme("ETB");
                 
                 //test: register 2 assets on the same elements network and make sure paying an invoice on one does not affect the other in any way
                 var invoice = await user.BitPay.CreateInvoiceAsync(new Invoice(0.1m, "BTC"));
@@ -109,11 +103,7 @@ namespace BTCPayServer.Tests
                     Assert.Equal("paid", localInvoice.Status);
                     Assert.Single(localInvoice.CryptoInfo.Single(info => info.CryptoCode.Equals("USDT", StringComparison.InvariantCultureIgnoreCase)).Payments);
                 });
-
-                //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);
-                //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);
                 //precision = 8, 0.1 = 0.1

BTCPayServer.Tests/BTCPayServer.Tests.csproj

@@ -7,6 +7,15 @@
     <!--https://devblogs.microsoft.com/aspnet/testing-asp-net-core-mvc-web-apps-in-memory/-->
     <PreserveCompilationContext>true</PreserveCompilationContext>
   </PropertyGroup>
+
+  <ItemGroup>
+    <AssemblyAttribute Include="BTCPayServer.Tests.OutputPathAttribute">
+      <!-- _Parameter1, _Parameter2, etc. correspond to the
+        matching parameter of a constructor of that .NET attribute type -->
+      <_Parameter1>$([System.IO.Path]::Combine('$(MSBuildProjectDirectory)', '$(OutputPath)'))</_Parameter1>
+    </AssemblyAttribute>
+  </ItemGroup>
+
   <!--https://devblogs.microsoft.com/aspnet/testing-asp-net-core-mvc-web-apps-in-memory/-->
   <Target Name="CopyAditionalFiles" AfterTargets="Build" Condition="'$(TargetFramework)'!=''">
     <ItemGroup>
@@ -30,20 +39,18 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
-    <PackageReference Include="Newtonsoft.Json.Schema" Version="3.0.15" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="Newtonsoft.Json.Schema" Version="3.0.16" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation" Version="8.0.11" />
     <PackageReference Include="Selenium.Support" Version="4.1.1" />
     <PackageReference Include="Selenium.WebDriver" Version="4.22.0" />
-	<PackageReference Include="Selenium.WebDriver.ChromeDriver" Version="125.0.6422.14100" />
-	<PackageReference Include="xunit" Version="2.6.6" />
-	<PackageReference Include="xunit.runner.visualstudio" Version="2.5.6">
+	<PackageReference Include="Selenium.WebDriver.ChromeDriver" Version="128.0.6613.11900" />
+	<PackageReference Include="xunit" Version="2.9.2" />
+	<PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
   </ItemGroup>
-  <ItemGroup Condition="'$(Altcoins)' != 'true'">
-    <Compile Remove="AltcoinTests\**\*.cs"></Compile>
-  </ItemGroup>
   <ItemGroup>
     <None Update=".dockerignore">
       <DependentUpon>Dockerfile</DependentUpon>
@@ -64,4 +71,7 @@
     <ProjectReference Include="..\BTCPayServer\BTCPayServer.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Folder Include="obj\Debug\net8.0\" />
+  </ItemGroup>
 </Project>

BTCPayServer.Tests/BTCPayServerTester.cs

@@ -7,12 +7,14 @@ using System.Security.Claims;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using BTCPayServer.Abstractions.Constants;
 using BTCPayServer.Configuration;
 using BTCPayServer.HostedServices;
 using BTCPayServer.Hosting;
 using BTCPayServer.Rating;
 using BTCPayServer.Services;
 using BTCPayServer.Services.Invoices;
+using BTCPayServer.Services.Mails;
 using BTCPayServer.Services.Rates;
 using BTCPayServer.Services.Stores;
 using BTCPayServer.Tests.Logging;
@@ -27,16 +29,9 @@ using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Logging;
 using NBitcoin;
 using NBXplorer;
-using AuthenticationSchemes = BTCPayServer.Abstractions.Constants.AuthenticationSchemes;
 
 namespace BTCPayServer.Tests
 {
-    public enum TestDatabases
-    {
-        Postgres,
-        MySQL,
-    }
-
     public class BTCPayServerTester : IDisposable
     {
         internal readonly string _Directory;
@@ -69,11 +64,6 @@ namespace BTCPayServer.Tests
             set;
         }
 
-        public string MySQL
-        {
-            get; set;
-        }
-
         public string Postgres
         {
             get; set;
@@ -89,11 +79,6 @@ namespace BTCPayServer.Tests
             get; set;
         }
 
-        public TestDatabases TestDatabase
-        {
-            get; set;
-        }
-
         public async Task RestartStartupTask<T>()
         {
             var startupTask = GetService<IServiceProvider>().GetServices<Abstractions.Contracts.IStartupTask>()
@@ -164,9 +149,7 @@ namespace BTCPayServer.Tests
             if (!string.IsNullOrEmpty(SSHConnection))
                 config.AppendLine($"sshconnection={SSHConnection}");
 
-            if (TestDatabase == TestDatabases.MySQL && !String.IsNullOrEmpty(MySQL))
-                config.AppendLine($"mysql=" + MySQL);
-            else if (!String.IsNullOrEmpty(Postgres))
+            if (!String.IsNullOrEmpty(Postgres))
                 config.AppendLine($"postgres=" + Postgres);
 
             if (!string.IsNullOrEmpty(ExplorerPostgres))
@@ -180,6 +163,8 @@ namespace BTCPayServer.Tests
             HttpClient.BaseAddress = ServerUri;
             Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development");
             var confBuilder = new DefaultConfiguration() { Logger = LoggerProvider.CreateLogger("Console") }.CreateConfigurationBuilder(new[] { "--datadir", _Directory, "--conf", confPath, "--disable-registration", DisableRegistration ? "true" : "false" });
+            // This make sure that tests work outside of this assembly (ie, test project it a plugin)
+            confBuilder.SetBasePath(TestUtils.TestDirectory);
 #if DEBUG
             confBuilder.AddJsonFile("appsettings.dev.json", true, false);
 #endif
@@ -195,7 +180,7 @@ namespace BTCPayServer.Tests
                             l.AddFilter("System.Net.Http.HttpClient", LogLevel.Critical);
                             l.SetMinimumLevel(LogLevel.Information)
                             .AddFilter("Microsoft", LogLevel.Error)
-                            .AddFilter("Hangfire", LogLevel.Error)
+                            .AddFilter("Microsoft.EntityFrameworkCore.Migrations", LogLevel.Information)
                             .AddFilter("Fido2NetLib.DistributedCacheMetadataService", LogLevel.Error)
                             .AddProvider(LoggerProvider);
                         });
@@ -283,7 +268,7 @@ namespace BTCPayServer.Tests
 
         private string FindBTCPayServerDirectory()
         {
-            var solutionDirectory = TestUtils.TryGetSolutionDirectoryInfo(Directory.GetCurrentDirectory());
+            var solutionDirectory = TestUtils.TryGetSolutionDirectoryInfo();
             return Path.Combine(solutionDirectory.FullName, "BTCPayServer");
         }
 

BTCPayServer.Tests/CheckoutUITests.cs

@@ -58,8 +58,8 @@ namespace BTCPayServer.Tests
             var qrValue = s.Driver.FindElement(By.CssSelector(".qr-container")).GetAttribute("data-qr-value");
             var clipboard = s.Driver.FindElement(By.CssSelector(".qr-container")).GetAttribute("data-clipboard");
             var payUrl = s.Driver.FindElement(By.Id("PayInWallet")).GetAttribute("href");
-            var address = s.Driver.FindElement(By.CssSelector("#Address_BTC-CHAIN .truncate-center-start")).Text;
-            Assert.StartsWith("bcrt", s.Driver.FindElement(By.CssSelector("#Address_BTC-CHAIN .truncate-center-start")).Text);
+            var address = s.Driver.FindElement(By.CssSelector("#Address_BTC-CHAIN .truncate-center")).GetAttribute("data-text");
+            Assert.StartsWith("bcrt", address);
             Assert.DoesNotContain("lightning=", payUrl);
             Assert.Equal($"bitcoin:{address}", payUrl);
             Assert.Equal($"bitcoin:{address}", clipboard);
@@ -80,7 +80,7 @@ namespace BTCPayServer.Tests
             {
                 payUrl = s.Driver.FindElement(By.Id("PayInWallet")).GetAttribute("href");
                 Assert.StartsWith("lightning:lnurl", payUrl);
-                Assert.StartsWith("lnurl", s.Driver.WaitForElement(By.CssSelector("#Lightning_BTC-CHAIN .truncate-center-start")).Text);
+                Assert.StartsWith("lnurl", s.Driver.WaitForElement(By.CssSelector("#Lightning_BTC-CHAIN .truncate-center")).GetAttribute("data-text"));
                 s.Driver.ElementDoesNotExist(By.Id("Address_BTC-CHAIN"));
             });
 
@@ -94,7 +94,7 @@ namespace BTCPayServer.Tests
             qrValue = s.Driver.FindElement(By.CssSelector(".qr-container")).GetAttribute("data-qr-value");
             clipboard = s.Driver.FindElement(By.CssSelector(".qr-container")).GetAttribute("data-clipboard");
             payUrl = s.Driver.FindElement(By.Id("PayInWallet")).GetAttribute("href");
-            address = s.Driver.FindElement(By.CssSelector("#Lightning_BTC-LN .truncate-center-start")).Text;
+            address = s.Driver.FindElement(By.CssSelector("#Lightning_BTC-LN .truncate-center")).GetAttribute("data-text");
             Assert.Equal($"lightning:{address}", payUrl);
             Assert.Equal($"lightning:{address}", clipboard);
             Assert.Equal($"lightning:{address.ToUpperInvariant()}", qrValue);
@@ -147,7 +147,7 @@ namespace BTCPayServer.Tests
             invoiceId = s.CreateInvoice(2100, "EUR");
             s.GoToInvoiceCheckout(invoiceId);
             await Task.Delay(200);
-            address = s.Driver.FindElement(By.CssSelector("#Address_BTC-CHAIN .truncate-center-start")).Text;
+            address = s.Driver.FindElement(By.CssSelector("#Address_BTC-CHAIN .truncate-center")).GetAttribute("data-text");
             var amountFraction = "0.00001";
             await s.Server.ExplorerNode.SendToAddressAsync(BitcoinAddress.Create(address, Network.RegTest),
                 Money.Parse(amountFraction));
@@ -261,8 +261,8 @@ namespace BTCPayServer.Tests
             qrValue = s.Driver.FindElement(By.CssSelector(".qr-container")).GetAttribute("data-qr-value");
             clipboard = s.Driver.FindElement(By.CssSelector(".qr-container")).GetAttribute("data-clipboard");
             payUrl = s.Driver.FindElement(By.Id("PayInWallet")).GetAttribute("href");
-            var copyAddressOnchain = s.Driver.FindElement(By.CssSelector("#Address_BTC-CHAIN .truncate-center-start")).Text;
-            var copyAddressLightning = s.Driver.FindElement(By.CssSelector("#Lightning_BTC-CHAIN .truncate-center-start")).Text;
+            var copyAddressOnchain = s.Driver.FindElement(By.CssSelector("#Address_BTC-CHAIN .truncate-center")).GetAttribute("data-text");
+            var copyAddressLightning = s.Driver.FindElement(By.CssSelector("#Lightning_BTC-CHAIN .truncate-center")).GetAttribute("data-text");
             Assert.StartsWith($"bitcoin:{copyAddressOnchain}?amount=", payUrl);
             Assert.Contains("?amount=", payUrl);
             Assert.Contains("&lightning=", payUrl);
@@ -327,8 +327,8 @@ namespace BTCPayServer.Tests
             qrValue = s.Driver.FindElement(By.CssSelector(".qr-container")).GetAttribute("data-qr-value");
             clipboard = s.Driver.FindElement(By.CssSelector(".qr-container")).GetAttribute("data-clipboard");
             payUrl = s.Driver.FindElement(By.Id("PayInWallet")).GetAttribute("href");
-            copyAddressOnchain = s.Driver.FindElement(By.CssSelector("#Address_BTC-CHAIN .truncate-center-start")).Text;
-            copyAddressLightning = s.Driver.FindElement(By.CssSelector("#Lightning_BTC-CHAIN .truncate-center-start")).Text;
+            copyAddressOnchain = s.Driver.FindElement(By.CssSelector("#Address_BTC-CHAIN .truncate-center")).GetAttribute("data-text");
+            copyAddressLightning = s.Driver.FindElement(By.CssSelector("#Lightning_BTC-CHAIN .truncate-center")).GetAttribute("data-text");
             Assert.StartsWith($"bitcoin:{copyAddressOnchain}", payUrl);
             Assert.Contains("?lightning=lnurl", payUrl);
             Assert.DoesNotContain("amount=", payUrl);