support more ln methods

# Conflicts:
#	BTCPayApp.CommonServer/IBTCPayAppHubClient.cs
#	BTCPayApp.CommonServer/Models/AppUserInfo.cs
#	BTCPayServer/App/BTCPayAppHub.cs
#	BTCPayServer/App/BTCPayAppState.cs
#	BTCPayServer/BTCPayServer.csproj

.circleci/config.yml

@@ -31,79 +31,23 @@ jobs:
       - run:
           command: |
             curl -X POST -H "Authorization: token $GH_PAT" -H "Accept: application/vnd.github.everest-preview+json" -H "Content-Type: application/json" https://api.github.com/repos/btcpayserver/btcpayserver-doc/dispatches --data '{"event_type": "build_docs"}'
-
   # publish jobs require $DOCKERHUB_REPO, $DOCKERHUB_USER, $DOCKERHUB_PASS defined
-  amd64:
-    machine:
-      image: ubuntu-2004:202111-02
+  docker:
+    docker:
+      - image: cimg/base:stable
     steps:
+      - setup_remote_docker
       - checkout
       - run:
           command: |
             LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
             GIT_COMMIT=$(git rev-parse HEAD)
             #
-            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --pull -t $DOCKERHUB_REPO:$LATEST_TAG-amd64 -f amd64.Dockerfile .
-            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --pull --build-arg CONFIGURATION_NAME=Altcoins-Release -t $DOCKERHUB_REPO:$LATEST_TAG-altcoins-amd64 -f amd64.Dockerfile .
-            sudo docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
-            sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-amd64
-            sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-altcoins-amd64
-
-  arm32v7:
-    machine:
-      image: ubuntu-2004:202111-02
-    steps:
-      - checkout
-      - run:
-          command: |
-            sudo docker run --rm --privileged multiarch/qemu-user-static:register --reset
-            LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
-            GIT_COMMIT=$(git rev-parse HEAD)
-            #
-            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --pull -t $DOCKERHUB_REPO:$LATEST_TAG-arm32v7 -f arm32v7.Dockerfile .
-            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --pull --build-arg CONFIGURATION_NAME=Altcoins-Release -t $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm32v7 -f arm32v7.Dockerfile .
-            sudo docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
-            sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-arm32v7
-            sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm32v7
-
-  arm64v8:
-    machine:
-      image: ubuntu-2004:202111-02
-    steps:
-      - checkout
-      - run:
-          command: |
-            sudo docker run --rm --privileged multiarch/qemu-user-static:register --reset
-            LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
-            GIT_COMMIT=$(git rev-parse HEAD)
-            #
-            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --pull -t $DOCKERHUB_REPO:$LATEST_TAG-arm64v8 -f arm64v8.Dockerfile .
-            sudo docker build --build-arg GIT_COMMIT=${GIT_COMMIT} --build-arg CONFIGURATION_NAME=Altcoins-Release --pull -t $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm64v8 -f arm64v8.Dockerfile .
-            sudo docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
-            sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-arm64v8
-            sudo docker push $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm64v8
-
-  multiarch:
-    machine:
-      image: ubuntu-2004:202201-02
-    steps:
-      - run:
-          command: |
-            sudo docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
-            #
-            LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
-            sudo docker manifest create --amend $DOCKERHUB_REPO:$LATEST_TAG $DOCKERHUB_REPO:$LATEST_TAG-amd64 $DOCKERHUB_REPO:$LATEST_TAG-arm32v7 $DOCKERHUB_REPO:$LATEST_TAG-arm64v8
-            sudo docker manifest annotate $DOCKERHUB_REPO:$LATEST_TAG $DOCKERHUB_REPO:$LATEST_TAG-amd64 --os linux --arch amd64
-            sudo docker manifest annotate $DOCKERHUB_REPO:$LATEST_TAG $DOCKERHUB_REPO:$LATEST_TAG-arm32v7 --os linux --arch arm --variant v7
-            sudo docker manifest annotate $DOCKERHUB_REPO:$LATEST_TAG $DOCKERHUB_REPO:$LATEST_TAG-arm64v8 --os linux --arch arm64 --variant v8
-            sudo docker manifest push $DOCKERHUB_REPO:$LATEST_TAG -p
-
-            sudo docker manifest create --amend $DOCKERHUB_REPO:$LATEST_TAG-altcoins $DOCKERHUB_REPO:$LATEST_TAG-altcoins-amd64 $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm32v7 $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm64v8
-            sudo docker manifest annotate $DOCKERHUB_REPO:$LATEST_TAG-altcoins $DOCKERHUB_REPO:$LATEST_TAG-altcoins-amd64 --os linux --arch amd64
-            sudo docker manifest annotate $DOCKERHUB_REPO:$LATEST_TAG-altcoins $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm32v7 --os linux --arch arm --variant v7
-            sudo docker manifest annotate $DOCKERHUB_REPO:$LATEST_TAG-altcoins $DOCKERHUB_REPO:$LATEST_TAG-altcoins-arm64v8 --os linux --arch arm64 --variant v8
-            sudo docker manifest push $DOCKERHUB_REPO:$LATEST_TAG-altcoins -p
-
+            docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
+            docker buildx create --use
+            DOCKER_BUILDX_OPTS="--platform linux/amd64,linux/arm64,linux/arm/v7 --build-arg GIT_COMMIT=${GIT_COMMIT} --push"
+            docker buildx build $DOCKER_BUILDX_OPTS -t $DOCKERHUB_REPO:$LATEST_TAG .
+            docker buildx build $DOCKER_BUILDX_OPTS -t $DOCKERHUB_REPO:$LATEST_TAG-altcoins --build-arg CONFIGURATION_NAME=Altcoins-Release .
 workflows:
   version: 2
   build_and_test:
@@ -120,7 +64,7 @@ workflows:
             # only act on version tags
             tags:
               only: /(v[1-9]+(\.[0-9]+)*(-[a-z0-9-]+)?)|(v[a-z0-9-]+)/
-      - amd64:
+      - docker:
           filters:
             # ignore any commit on any branch by default
             branches:
@@ -130,25 +74,3 @@ workflows:
             # OR features on specific versions like v1.0.0.88-lndseedbackup-1
             tags:
               only: /(v[1-9]+(\.[0-9]+)*(-[a-z0-9-]+)?)|(v[a-z0-9-]+)/
-      - arm32v7:
-          filters:
-            branches:
-              ignore: /.*/
-            tags:
-              only: /(v[1-9]+(\.[0-9]+)*(-[a-z0-9-]+)?)|(v[a-z0-9-]+)/
-      - arm64v8:
-          filters:
-            branches:
-              ignore: /.*/
-            tags:
-              only: /(v[1-9]+(\.[0-9]+)*(-[a-z0-9-]+)?)|(v[a-z0-9-]+)/
-      - multiarch:
-          requires:
-            - amd64
-            - arm32v7
-            - arm64v8
-          filters:
-            branches:
-              ignore: /.*/
-            tags:
-              only: /(v[1-9]+(\.[0-9]+)*(-[a-z0-9-]+)?)|(v[a-z0-9-]+)/

.gitignore

@@ -298,4 +298,6 @@ Packed Plugins
 Plugins/packed
 
 BTCPayServer/wwwroot/swagger/v1/openapi.json
-BTCPayServer/appsettings.dev.json
+BTCPayServer/appsettings.dev.json
+BTCPayServer.Tests/monero_wallet
+/BTCPayServer.Tests/NewBlocks.bat

.vscode/launch.json

@@ -10,7 +10,7 @@
             "request": "launch",
             "preLaunchTask": "build",
             // If you have changed target frameworks, make sure to update the program path.
-            "program": "${workspaceFolder}/BTCPayServer/bin/Debug/net6.0/BTCPayServer.dll",
+            "program": "${workspaceFolder}/BTCPayServer/bin/Debug/net8.0/BTCPayServer.dll",
             "args": [],
             "cwd": "${workspaceFolder}/BTCPayServer",
             "stopAtEntry": false,

BTCPayApp.CommonServer/AuthenticationSchemes.cs

@@ -1,11 +1,12 @@
-namespace BTCPayServer.Abstractions.Constants
+namespace BTCPayApp.CommonServer
 {
     public class AuthenticationSchemes
     {
         public const string Cookie = "Identity.Application";
         public const string Bitpay = "Bitpay";
-        public const string Greenfield = "Greenfield.APIKeys,Greenfield.Basic";
+        public const string Greenfield = "Greenfield.APIKeys,Greenfield.Basic,Greenfield.Bearer";
         public const string GreenfieldAPIKeys = "Greenfield.APIKeys";
         public const string GreenfieldBasic = "Greenfield.Basic";
+        public const string GreenfieldBearer = "Greenfield.Bearer";
     }
 }

BTCPayApp.CommonServer/BTCPayApp.CommonServer.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <LangVersion>latest</LangVersion>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\BTCPayServer.Client\BTCPayServer.Client.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <PackageReference Include="Microsoft.AspNetCore.Authorization" Version="8.0.6" />
+    </ItemGroup>
+</Project>

BTCPayApp.CommonServer/IBTCPayAppHubClient.cs

@@ -0,0 +1,122 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using BTCPayServer.Client.Models;
+using BTCPayServer.Lightning;
+using NBitcoin;
+
+namespace BTCPayApp.CommonServer;
+
+//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<LightningInvoice> CreateInvoice(CreateLightningInvoiceRequest createLightningInvoiceRequest);
+    Task<LightningInvoice?> GetLightningInvoice(uint256 paymentHash);
+    Task<LightningPayment?> GetLightningPayment(uint256 paymentHash);
+    Task<List<LightningPayment>> GetLightningPayments(ListPaymentsParams request);
+    Task<List<LightningInvoice>> GetLightningInvoices(ListInvoicesParams request);
+    Task<PayResponse> PayInvoice(string bolt11, long? amountMilliSatoshi);
+    Task MasterUpdated(long? deviceIdentifier);
+    Task<LightningNodeInformation> GetLightningNodeInfo();
+    Task<LightningNodeBalance> GetLightningBalance();
+}
+
+//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[] txIds);
+    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(string identifier, LightningInvoice lightningInvoice);
+}
+
+public class ServerEvent(string type)
+{
+    public string Type { get; } = type;
+    public string? StoreId { get; init; }
+    public string? UserId { get; init; }
+    public string? InvoiceId { get; init; }
+}
+
+public record TxResp(long Confirmations, long? Height, decimal BalanceChange, DateTimeOffset Timestamp, string TransactionId)
+{
+    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> Blocks { get; set; }
+    public Dictionary<string,int> BlockHeghts { get; set; }
+}
+
+public class TransactionResponse
+{
+    public string? BlockHash { get; set; }
+    public int? BlockHeight { get; set; }
+    public string Transaction { get; set; }
+}
+
+public class BestBlockResponse
+{
+    public required string BlockHash { get; set; }
+    public required 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();
+}

BTCPayApp.CommonServer/Models/AcceptInviteRequest.cs

@@ -0,0 +1,12 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace BTCPayApp.CommonServer.Models;
+
+public class AcceptInviteRequest
+{
+    [Required]
+    public string? UserId { get; init; }
+    
+    [Required]
+    public string? Code { get; init; }
+}

BTCPayApp.CommonServer/Models/AcceptInviteResult.cs

@@ -0,0 +1,9 @@
+namespace BTCPayApp.CommonServer.Models;
+
+public class AcceptInviteResult(string email)
+{
+    public string Email { get; init; } = email;
+    public bool? RequiresUserApproval { get; set; }
+    public bool? EmailHasBeenConfirmed { get; set; }
+    public string? PasswordSetCode { get; set; }
+}

BTCPayApp.CommonServer/Models/AccessTokenResult.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace BTCPayApp.CommonServer.Models;
+
+public class AccessTokenResult(string accessToken, string refreshToken, DateTimeOffset expiry)
+{
+    public string AccessToken { get; init; } = accessToken;
+    public string RefreshToken { get; init; } = refreshToken;
+    public DateTimeOffset Expiry { get; init; } = expiry;
+}

BTCPayApp.CommonServer/Models/AppInstanceInfo.cs

@@ -0,0 +1,12 @@
+namespace BTCPayApp.CommonServer.Models;
+
+public class AppInstanceInfo
+{
+    public string BaseUrl { get; set; }
+    public string ServerName { get; set; }
+    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; }
+}

BTCPayApp.CommonServer/Models/AppUserInfo.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+using System.Text.Json;
+using BTCPayServer.Lightning;
+using NBitcoin;
+using NBitcoin.JsonConverters;
+using Newtonsoft.Json;
+
+namespace BTCPayApp.CommonServer.Models;
+
+// public partial class LightningPayment
+// {
+//     public string PaymentHash { get; set; }
+//     public string? PaymentId { get; set; }
+//     public string? Preimage { get; set; }
+//     public string? Secret { get; set; }
+//     public bool Inbound { get; set; }
+//     public DateTimeOffset Timestamp { get; set; }
+//     public long Value { get; set; }
+//     public LightningPaymentStatus Status { get; set; }
+//
+//     //you can have multiple requests generated for the same payment hash, but once you reveal the preimage, you should reject any attempt to pay the same payment hash
+//     public List<string> PaymentRequests { get; set; }
+//     [JsonIgnore]
+//     public Dictionary<string, JsonDocument> AdditionalData { get; set; } 
+//     
+// }
+
+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; }
+    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; }
+}

BTCPayApp.CommonServer/Models/CreateStoreData.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace BTCPayApp.CommonServer.Models;
+
+public class CreateStoreData
+{
+    public string? DefaultCurrency { get; set; }
+    public string? RecommendedExchangeId { get; set; }
+    public Dictionary<string, string>? Exchanges { get; set; }
+}

BTCPayApp.CommonServer/Models/SignupRequest.cs

@@ -0,0 +1,12 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace BTCPayApp.CommonServer.Models;
+
+public class SignupRequest
+{
+    [Required]
+    public string? Email { get; init; }
+    
+    [Required]
+    public string? Password { get; init; }
+}

BTCPayApp.CommonServer/Models/SignupResult.cs

@@ -0,0 +1,8 @@
+namespace BTCPayApp.CommonServer.Models;
+
+public class SignupResult
+{
+    public string? Email { get; set; }
+    public bool RequiresConfirmedEmail { get; set; }
+    public bool RequiresUserApproval { get; set; }
+}

BTCPayApp.CommonServer/PolicyRequirement.cs

@@ -1,7 +1,7 @@
 using System;
 using Microsoft.AspNetCore.Authorization;
 
-namespace BTCPayServer.Security
+namespace BTCPayApp.CommonServer
 {
     public class PolicyRequirement : IAuthorizationRequirement
     {

BTCPayApp.CommonServer/PosDataParser.cs

@@ -0,0 +1,49 @@
+using System.Collections.Generic;
+using System.Linq;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayApp.CommonServer;
+
+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;
+        }
+    }
+}

BTCPayApp.CommonServer/Roles.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace BTCPayApp.CommonServer;
+
+public class Roles
+{
+    public const string ServerAdmin = "ServerAdmin";
+    public static bool HasServerAdmin(IList<string> roles)
+    {
+        return roles.Contains(Roles.ServerAdmin, StringComparer.Ordinal);
+    }
+}

BTCPayApp.CommonServer/ServerPolicies.cs

@@ -1,7 +1,7 @@
 using BTCPayServer.Client;
 using Microsoft.AspNetCore.Authorization;
 
-namespace BTCPayServer.Security
+namespace BTCPayApp.CommonServer
 {
     public static class ServerPolicies
     {

BTCPayServer.Abstractions/BTCPayServer.Abstractions.csproj

@@ -31,13 +31,12 @@
     <None Include="icon.png" Pack="true" PackagePath="\" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="HtmlSanitizer" Version="5.0.372" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="6.0.9" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="6.0.9" />
-    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="6.0.7" />
-    <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="6.0.1" />
+    <PackageReference Include="HtmlSanitizer" Version="8.0.838" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.6" />
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="8.0.4" />
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\BTCPayApp.CommonServer\BTCPayApp.CommonServer.csproj" />
     <ProjectReference Include="..\BTCPayServer.Client\BTCPayServer.Client.csproj" />
   </ItemGroup>
 </Project>

BTCPayServer.Abstractions/Configuration/DataDirectories.cs

@@ -9,6 +9,7 @@ namespace BTCPayServer.Configuration
         public string TempStorageDir { get; set; }
         public string StorageDir { get; set; }
         public string TempDir { get; set; }
+        public string LangsDir { get; set; }
 
         public string ToDatadirFullPath(string path)
         {

BTCPayServer.Abstractions/Contracts/BaseDbContextFactory.cs

@@ -1,10 +1,11 @@
 using System;
-using System.Data.Common;
 using BTCPayServer.Abstractions.Models;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata;
 using Microsoft.EntityFrameworkCore.Migrations;
 using Microsoft.Extensions.Options;
+using Npgsql;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Infrastructure;
 using Npgsql.EntityFrameworkCore.PostgreSQL.Migrations;
 using Npgsql.EntityFrameworkCore.PostgreSQL.Migrations.Operations;
 
@@ -13,15 +14,16 @@ namespace BTCPayServer.Abstractions.Contracts
     public abstract class BaseDbContextFactory<T> where T : DbContext
     {
         private readonly IOptions<DatabaseOptions> _options;
-        private readonly string _schemaPrefix;
+        private readonly string _migrationTableName;
 
-        public BaseDbContextFactory(IOptions<DatabaseOptions> options, string schemaPrefix)
+        public BaseDbContextFactory(IOptions<DatabaseOptions> options, string migrationTableName)
         {
             _options = options;
-            _schemaPrefix = schemaPrefix;
+            _migrationTableName = migrationTableName;
         }
 
-        public abstract T CreateContext();
+        public T CreateContext() => CreateContext(null);
+        public abstract T CreateContext(Action<NpgsqlDbContextOptionsBuilder> npgsqlOptionsAction = null);
         class CustomNpgsqlMigrationsSqlGenerator : NpgsqlMigrationsSqlGenerator
         {
 #pragma warning disable EF1001 // Internal EF Core API usage.
@@ -66,46 +68,27 @@ namespace BTCPayServer.Abstractions.Contracts
             }
         }
 
-        public void ConfigureBuilder(DbContextOptionsBuilder builder)
+        public void ConfigureBuilder(DbContextOptionsBuilder builder) => ConfigureBuilder(builder, null);
+        public void ConfigureBuilder(DbContextOptionsBuilder builder, Action<NpgsqlDbContextOptionsBuilder> npgsqlOptionsAction = null)
         {
-            switch (_options.Value.DatabaseType)
+            builder
+            .UseNpgsql(_options.Value.ConnectionString, o =>
             {
-                case DatabaseType.Sqlite:
-                    builder.UseSqlite(_options.Value.ConnectionString, o =>
-                    {
-                        if (!string.IsNullOrEmpty(_schemaPrefix))
-                        {
-                            o.MigrationsHistoryTable(_schemaPrefix);
-                        }
-                    });
-                    break;
-                case DatabaseType.Postgres:
-                    builder
-                        .UseNpgsql(_options.Value.ConnectionString, o =>
-                        {
-                            o.EnableRetryOnFailure(10);
-                            if (!string.IsNullOrEmpty(_schemaPrefix))
-                            {
-                                o.MigrationsHistoryTable(_schemaPrefix);
-                            }
-                        })
-                        .ReplaceService<IMigrationsSqlGenerator, CustomNpgsqlMigrationsSqlGenerator>();
-                    break;
-                case DatabaseType.MySQL:
-                    builder.UseMySql(_options.Value.ConnectionString, ServerVersion.AutoDetect(_options.Value.ConnectionString), o =>
-                    {
-                        o.EnableRetryOnFailure(10);
-
-                        if (!string.IsNullOrEmpty(_schemaPrefix))
-                        {
-                            o.MigrationsHistoryTable(_schemaPrefix);
-                        }
-                    });
-                    break;
-                default:
-                    throw new ArgumentOutOfRangeException();
-            }
+                o.EnableRetryOnFailure(10);
+                o.SetPostgresVersion(12, 0);
+                npgsqlOptionsAction?.Invoke(o);
+                var mainSearchPath = GetSearchPath(_options.Value.ConnectionString);
+                var schemaPrefix = string.IsNullOrEmpty(_migrationTableName) ? "__EFMigrationsHistory" : _migrationTableName;
+                o.MigrationsHistoryTable(schemaPrefix, mainSearchPath);
+            })
+            .ReplaceService<IMigrationsSqlGenerator, CustomNpgsqlMigrationsSqlGenerator>();
         }
 
+        private string GetSearchPath(string connectionString)
+        {
+            var connectionStringBuilder = new NpgsqlConnectionStringBuilder(connectionString);
+            var searchPaths = connectionStringBuilder.SearchPath?.Split(',');
+            return searchPaths is not { Length: > 0 } ? null : searchPaths[0];
+        }
     }
 }

BTCPayServer.Abstractions/Contracts/INotificationHandler.cs

@@ -25,5 +25,6 @@ namespace BTCPayServer.Abstractions.Contracts
         public string Body { get; set; }
         public string ActionLink { get; set; }
         public bool Seen { get; set; }
+        public string StoreId { get; set; }
     }
 }

BTCPayServer.Abstractions/Custodians/Client/AssetQuoteResult.cs

@@ -1,19 +0,0 @@
-namespace BTCPayServer.Abstractions.Custodians.Client;
-
-public class AssetQuoteResult
-{
-    public string FromAsset { get; set; }
-    public string ToAsset { get; set; }
-    public decimal Bid { get; set; }
-    public decimal Ask { get; set; }
-
-    public AssetQuoteResult() { }
-
-    public AssetQuoteResult(string fromAsset, string toAsset, decimal bid, decimal ask)
-    {
-        FromAsset = fromAsset;
-        ToAsset = toAsset;
-        Bid = bid;
-        Ask = ask;
-    }
-}

BTCPayServer.Abstractions/Custodians/Client/Exception/AssetBalancesUnavailableException.cs

@@ -1,12 +0,0 @@
-namespace BTCPayServer.Abstractions.Custodians;
-
-public class AssetBalancesUnavailableException : CustodianApiException
-{
-    public AssetBalancesUnavailableException(System.Exception e) : base(500, "asset-balances-unavailable", $"Cannot fetch the asset balances: {e.Message}", e)
-    {
-    }
-
-    public AssetBalancesUnavailableException(string errorMsg) : base(500, "asset-balances-unavailable", $"Cannot fetch the asset balances: {errorMsg}")
-    {
-    }
-}

BTCPayServer.Abstractions/Custodians/Client/Exception/AssetQuoteUnavailableException.cs

@@ -1,13 +0,0 @@
-using BTCPayServer.Client.Models;
-
-namespace BTCPayServer.Abstractions.Custodians;
-
-public class AssetQuoteUnavailableException : CustodianApiException
-{
-    public AssetPairData AssetPair { get; }
-
-    public AssetQuoteUnavailableException(AssetPairData assetPair) : base(400, "asset-price-unavailable", "Cannot find a quote for pair " + assetPair)
-    {
-        this.AssetPair = assetPair;
-    }
-}

BTCPayServer.Abstractions/Custodians/Client/Exception/BadConfigException.cs

@@ -1,13 +0,0 @@
-using System;
-
-namespace BTCPayServer.Abstractions.Custodians;
-
-public class BadConfigException : CustodianApiException
-{
-    public string[] BadConfigKeys { get; set; }
-
-    public BadConfigException(string[] badConfigKeys) : base(500, "bad-custodian-account-config", "Wrong config values: " + String.Join(", ", badConfigKeys))
-    {
-        this.BadConfigKeys = badConfigKeys;
-    }
-}

BTCPayServer.Abstractions/Custodians/Client/Exception/CannotWithdrawException.cs

@@ -1,13 +0,0 @@
-namespace BTCPayServer.Abstractions.Custodians;
-
-public class CannotWithdrawException : CustodianApiException
-
-{
-    public CannotWithdrawException(ICustodian custodian, string paymentMethod, string message) : base(403, "cannot-withdraw", message)
-    {
-    }
-
-    public CannotWithdrawException(ICustodian custodian, string paymentMethod, string targetAddress, CustodianApiException originalException) : base(403, "cannot-withdraw", $"{custodian.Name} cannot withdraw {paymentMethod} to '{targetAddress}': {originalException.Message}")
-    {
-    }
-}

BTCPayServer.Abstractions/Custodians/Client/Exception/CustodianApiException.cs

@@ -1,18 +0,0 @@
-using System;
-namespace BTCPayServer.Abstractions.Custodians;
-public class CustodianApiException : Exception
-{
-    public int HttpStatus { get; }
-    public string Code { get; }
-
-    public CustodianApiException(int httpStatus, string code, string message, System.Exception ex) : base(message, ex)
-    {
-        HttpStatus = httpStatus;
-        Code = code;
-    }
-
-    public CustodianApiException(int httpStatus, string code, string message) : this(httpStatus, code, message, null)
-    {
-    }
-}
-

BTCPayServer.Abstractions/Custodians/Client/Exception/CustodianFeatureNotImplementedException.cs

@@ -1,8 +0,0 @@
-namespace BTCPayServer.Abstractions.Custodians;
-
-public class CustodianFeatureNotImplementedException : CustodianApiException
-{
-    public CustodianFeatureNotImplementedException(string message) : base(400, "not-implemented", message)
-    {
-    }
-}

BTCPayServer.Abstractions/Custodians/Client/Exception/DepositsUnavailableException.cs

@@ -1,8 +0,0 @@
-namespace BTCPayServer.Abstractions.Custodians;
-
-public class DepositsUnavailableException : CustodianApiException
-{
-    public DepositsUnavailableException(string message) : base(404, "deposits-unavailable", message)
-    {
-    }
-}

BTCPayServer.Abstractions/Custodians/Client/Exception/InsufficientFundsException.cs

@@ -1,8 +0,0 @@
-namespace BTCPayServer.Abstractions.Custodians;
-
-public class InsufficientFundsException : CustodianApiException
-{
-    public InsufficientFundsException(string message) : base(400, "insufficient-funds", message)
-    {
-    }
-}

BTCPayServer.Abstractions/Custodians/Client/Exception/InvalidWithdrawalTargetException.cs

@@ -1,9 +0,0 @@
-namespace BTCPayServer.Abstractions.Custodians;
-
-public class InvalidWithdrawalTargetException : CustodianApiException
-
-{
-    public InvalidWithdrawalTargetException(ICustodian custodian, string paymentMethod, string targetAddress, CustodianApiException originalException) : base(403, "invalid-withdrawal-target", $"{custodian.Name} cannot withdraw {paymentMethod} to '{targetAddress}': {originalException.Message}")
-    {
-    }
-}

BTCPayServer.Abstractions/Custodians/Client/Exception/PermissionDeniedCustodianApiException.cs

@@ -1,9 +0,0 @@
-namespace BTCPayServer.Abstractions.Custodians;
-
-public class PermissionDeniedCustodianApiException : CustodianApiException
-
-{
-    public PermissionDeniedCustodianApiException(ICustodian custodian) : base(403, "custodian-api-permission-denied", $"{custodian.Name}'s API reported that you don't have permission.")
-    {
-    }
-}

BTCPayServer.Abstractions/Custodians/Client/Exception/TradeNotFoundException.cs

@@ -1,11 +0,0 @@
-namespace BTCPayServer.Abstractions.Custodians;
-
-public class TradeNotFoundException : CustodianApiException
-{
-    private string tradeId { get; }
-
-    public TradeNotFoundException(string tradeId) : base(404, "trade-not-found", "Could not find trade ID " + tradeId)
-    {
-        this.tradeId = tradeId;
-    }
-}

BTCPayServer.Abstractions/Custodians/Client/Exception/WithdrawalNotFoundException.cs

@@ -1,11 +0,0 @@
-namespace BTCPayServer.Abstractions.Custodians;
-
-public class WithdrawalNotFoundException : CustodianApiException
-{
-    private string WithdrawalId { get; }
-
-    public WithdrawalNotFoundException(string withdrawalId) : base(404, "withdrawal-not-found", $"Could not find withdrawal ID {withdrawalId}.")
-    {
-        WithdrawalId = withdrawalId;
-    }
-}

BTCPayServer.Abstractions/Custodians/Client/Exception/WrongTradingPairException.cs

@@ -1,9 +0,0 @@
-namespace BTCPayServer.Abstractions.Custodians;
-
-public class WrongTradingPairException : CustodianApiException
-{
-    public const int HttpCode = 404;
-    public WrongTradingPairException(string fromAsset, string toAsset) : base(HttpCode, "wrong-trading-pair", $"Cannot find a trading pair for converting {fromAsset} into {toAsset}.")
-    {
-    }
-}

BTCPayServer.Abstractions/Custodians/Client/MarketTradeResult.cs

@@ -1,29 +0,0 @@
-using System.Collections.Generic;
-using BTCPayServer.Client.Models;
-
-namespace BTCPayServer.Abstractions.Custodians.Client;
-
-/**
- * The result of a market trade. Used as a return type for custodians implementing ICanTrade
- */
-public class MarketTradeResult
-{
-    public string FromAsset { get; }
-    public string ToAsset { get; }
-    /**
-     * The ledger entries that show the balances that were affected by the trade.
-     */
-    public List<LedgerEntryData> LedgerEntries { get; }
-    /**
-     * The unique ID of the trade that was executed.
-     */
-    public string TradeId { get; }
-
-    public MarketTradeResult(string fromAsset, string toAsset, List<LedgerEntryData> ledgerEntries, string tradeId)
-    {
-        this.FromAsset = fromAsset;
-        this.ToAsset = toAsset;
-        this.LedgerEntries = ledgerEntries;
-        this.TradeId = tradeId;
-    }
-}

BTCPayServer.Abstractions/Custodians/Client/SimulateWithdrawalResult.cs

@@ -1,28 +0,0 @@
-using System.Collections.Generic;
-using BTCPayServer.Client.Models;
-using BTCPayServer.JsonConverters;
-
-namespace BTCPayServer.Abstractions.Custodians.Client;
-
-public class SimulateWithdrawalResult
-{
-    public string PaymentMethod { get; }
-    public string Asset { get; }
-    public decimal MinQty { get; }
-    public decimal MaxQty { get; }
-
-    public List<LedgerEntryData> LedgerEntries { get; }
-
-    // Fee can be NULL if unknown.
-    public decimal? Fee { get; }
-
-    public SimulateWithdrawalResult(string paymentMethod, string asset, List<LedgerEntryData> ledgerEntries,
-        decimal minQty, decimal maxQty)
-    {
-        PaymentMethod = paymentMethod;
-        Asset = asset;
-        LedgerEntries = ledgerEntries;
-        MinQty = minQty;
-        MaxQty = maxQty;
-    }
-}

BTCPayServer.Abstractions/Custodians/Client/WithdrawResult.cs

@@ -1,29 +0,0 @@
-using System;
-using System.Collections.Generic;
-using BTCPayServer.Client.Models;
-
-namespace BTCPayServer.Abstractions.Custodians.Client;
-
-public class WithdrawResult
-{
-    public string PaymentMethod { get; }
-    public string Asset { get; set; }
-    public List<LedgerEntryData> LedgerEntries { get; }
-    public string WithdrawalId { get; }
-    public WithdrawalResponseData.WithdrawalStatus Status { get; }
-    public DateTimeOffset CreatedTime { get; }
-    public string TargetAddress { get; }
-    public string TransactionId { get; }
-
-    public WithdrawResult(string paymentMethod, string asset, List<LedgerEntryData> ledgerEntries, string withdrawalId, WithdrawalResponseData.WithdrawalStatus status, DateTimeOffset createdTime, string targetAddress, string transactionId)
-    {
-        PaymentMethod = paymentMethod;
-        Asset = asset;
-        LedgerEntries = ledgerEntries;
-        WithdrawalId = withdrawalId;
-        CreatedTime = createdTime;
-        Status = status;
-        TargetAddress = targetAddress;
-        TransactionId = transactionId;
-    }
-}

BTCPayServer.Abstractions/Custodians/ICanDeposit.cs

@@ -1,17 +0,0 @@
-using System.Threading;
-using System.Threading.Tasks;
-using BTCPayServer.Client.Models;
-using Newtonsoft.Json.Linq;
-
-namespace BTCPayServer.Abstractions.Custodians;
-
-public interface ICanDeposit
-{
-    /**
-     * Get the address where we can deposit for the chosen payment method (crypto code + network).
-     * The result can be a string in different formats like a bitcoin address or even a LN invoice.
-     */
-    public Task<DepositAddressData> GetDepositAddressAsync(string paymentMethod, JObject config, CancellationToken cancellationToken);
-
-    public string[] GetDepositablePaymentMethods();
-}

BTCPayServer.Abstractions/Custodians/ICanTrade.cs

@@ -1,31 +0,0 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using BTCPayServer.Abstractions.Custodians.Client;
-using BTCPayServer.Client.Models;
-using Newtonsoft.Json.Linq;
-
-namespace BTCPayServer.Abstractions.Custodians;
-
-public interface ICanTrade
-{
-    /**
-     * A list of tradable asset pairs, or NULL if the custodian cannot trade/convert assets. if thr asset pair contains fiat, fiat is always put last. If both assets are a cyrptocode or both are fiat, the pair is written alphabetically. Always in uppercase. Example: ["BTC/EUR","BTC/USD", "EUR/USD", "BTC/ETH",...]
-     */
-    public List<AssetPairData> GetTradableAssetPairs();
-
-    /**
-     * Execute a market order right now.
-     */
-    public Task<MarketTradeResult> TradeMarketAsync(string fromAsset, string toAsset, decimal qty, JObject config, CancellationToken cancellationToken);
-
-    /**
-     * Get the details about a previous market trade.
-     */
-    public Task<MarketTradeResult> GetTradeInfoAsync(string tradeId, JObject config, CancellationToken cancellationToken);
-
-    public Task<AssetQuoteResult> GetQuoteForAssetAsync(string fromAsset, string toAsset, JObject config, CancellationToken cancellationToken);
-}
-
-
-

BTCPayServer.Abstractions/Custodians/ICanWithdraw.cs

@@ -1,20 +0,0 @@
-using System.Threading;
-using System.Threading.Tasks;
-using BTCPayServer.Abstractions.Custodians.Client;
-using Newtonsoft.Json.Linq;
-
-namespace BTCPayServer.Abstractions.Custodians;
-
-/// <summary>
-/// Interface for custodians that can move funds to the store wallet.
-/// </summary>
-public interface ICanWithdraw
-{
-    public Task<WithdrawResult> WithdrawToStoreWalletAsync(string paymentMethod, decimal amount, JObject config, CancellationToken cancellationToken);
-
-    public Task<SimulateWithdrawalResult> SimulateWithdrawalAsync(string paymentMethod, decimal qty, JObject config, CancellationToken cancellationToken);
-
-    public Task<WithdrawResult> GetWithdrawalInfoAsync(string paymentMethod, string withdrawalId, JObject config, CancellationToken cancellationToken);
-
-    public string[] GetWithdrawablePaymentMethods();
-}

BTCPayServer.Abstractions/Custodians/ICustodian.cs

@@ -1,26 +0,0 @@
-#nullable enable
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using BTCPayServer.Client.Models;
-using Newtonsoft.Json.Linq;
-
-namespace BTCPayServer.Abstractions.Custodians;
-
-public interface ICustodian
-{
-    /**
-     * Get the unique code that identifies this custodian.
-     */
-    string Code { get; }
-
-    string Name { get; }
-
-    /**
-     * Get a list of assets and their qty in custody.
-     */
-    Task<Dictionary<string, decimal>> GetAssetBalancesAsync(JObject config, CancellationToken cancellationToken);
-
-    public Task<Form.Form> GetConfigForm(JObject config, CancellationToken cancellationToken = default);
-
-}

BTCPayServer.Abstractions/Extensions/CustodianExtensions.cs

@@ -1,14 +0,0 @@
-#nullable enable
-using System.Collections.Generic;
-using System.Linq;
-using BTCPayServer.Abstractions.Custodians;
-
-namespace BTCPayServer.Abstractions.Extensions;
-
-public static class CustodianExtensions
-{
-    public static ICustodian? GetCustodianByCode(this IEnumerable<ICustodian> custodians, string code)
-    {
-        return custodians.FirstOrDefault(custodian => custodian.Code == code);
-    }
-}

BTCPayServer.Abstractions/Extensions/HttpRequestExtensions.cs

@@ -36,6 +36,17 @@ public static class HttpRequestExtensions
             request.Path.ToUriComponent());
     }
 
+    public static string GetCurrentUrlWithQueryString(this HttpRequest request)
+    {
+        return string.Concat(
+            request.Scheme,
+            "://",
+            request.Host.ToUriComponent(),
+            request.PathBase.ToUriComponent(),
+            request.Path.ToUriComponent(),
+            request.QueryString.ToUriComponent());
+    }
+
     public static string GetCurrentPath(this HttpRequest request)
     {
         return string.Concat(

BTCPayServer.Abstractions/Extensions/ViewsRazor.cs

@@ -12,7 +12,7 @@ namespace BTCPayServer.Abstractions.Extensions
         private const string ACTIVE_CATEGORY_KEY = "ActiveCategory";
         private const string ACTIVE_PAGE_KEY = "ActivePage";
         private const string ACTIVE_ID_KEY = "ActiveId";
-        private const string ActivePageClass = "active";
+        private const string ACTIVE_CLASS = "active";
 
         public enum DateDisplayFormat
         {
@@ -20,6 +20,15 @@ namespace BTCPayServer.Abstractions.Extensions
             Relative
         }
 
+        public static void SetBlazorAllowed(this ViewDataDictionary viewData, bool allowed)
+        {
+            viewData["BlazorAllowed"] = allowed;
+        }
+        public static bool IsBlazorAllowed(this ViewDataDictionary viewData)
+        {
+            return viewData["BlazorAllowed"] is not false;
+        }
+
         public static void SetActivePage<T>(this ViewDataDictionary viewData, T activePage, string title = null, string activeId = null)
             where T : IConvertible
         {
@@ -46,50 +55,71 @@ namespace BTCPayServer.Abstractions.Extensions
             viewData[ACTIVE_CATEGORY_KEY] = activeCategory;
         }
 
-        public static string IsActiveCategory<T>(this ViewDataDictionary viewData, T category, object id = null)
+        public static bool IsActiveCategory(this ViewDataDictionary viewData, string category, object id = null)
         {
-            return IsActiveCategory(viewData, category.ToString(), id);
-        }
-
-        public static string IsActiveCategory(this ViewDataDictionary viewData, string category, object id = null)
-        {
-            if (!viewData.ContainsKey(ACTIVE_CATEGORY_KEY))
-            {
-                return null;
-            }
+            if (!viewData.ContainsKey(ACTIVE_CATEGORY_KEY)) return false;
             var activeId = viewData[ACTIVE_ID_KEY];
             var activeCategory = viewData[ACTIVE_CATEGORY_KEY]?.ToString();
             var categoryMatch = category.Equals(activeCategory, StringComparison.InvariantCultureIgnoreCase);
             var idMatch = id == null || activeId == null || id.Equals(activeId);
-            return categoryMatch && idMatch ? ActivePageClass : null;
+            return categoryMatch && idMatch;
         }
 
-        public static string IsActivePage<T>(this ViewDataDictionary viewData, T page, object id = null)
-            where T : IConvertible
+        public static bool IsActiveCategory<T>(this ViewDataDictionary viewData, T category, object id = null)
         {
-            return IsActivePage(viewData, page.ToString(), page.GetType().ToString(), id);
+            return IsActiveCategory(viewData, category.ToString(), id);
         }
 
-        public static string IsActivePage<T>(this ViewDataDictionary viewData, IEnumerable<T> pages, object id = null)
-            where T : IConvertible
+        public static bool IsActivePage(this ViewDataDictionary viewData, string page, string category, object id = null)
         {
-            return pages.Any(page => IsActivePage(viewData, page.ToString(), page.GetType().ToString(), id) == ActivePageClass)
-                ? ActivePageClass
-                : null;
-        }
-
-        public static string IsActivePage(this ViewDataDictionary viewData, string page, string category, object id = null)
-        {
-            if (!viewData.ContainsKey(ACTIVE_PAGE_KEY))
-            {
-                return null;
-            }
+            if (!viewData.ContainsKey(ACTIVE_PAGE_KEY)) return false;
             var activeId = viewData[ACTIVE_ID_KEY];
             var activePage = viewData[ACTIVE_PAGE_KEY]?.ToString();
             var activeCategory = viewData[ACTIVE_CATEGORY_KEY]?.ToString();
-            var categoryAndPageMatch = (category == null || activeCategory.Equals(category, StringComparison.InvariantCultureIgnoreCase)) && page.Equals(activePage, StringComparison.InvariantCultureIgnoreCase);
+            var categoryAndPageMatch = page.Equals(activePage, StringComparison.InvariantCultureIgnoreCase) &&
+                (category == null || activeCategory != null && activeCategory.Equals(category, StringComparison.InvariantCultureIgnoreCase));
             var idMatch = id == null || activeId == null || id.Equals(activeId);
-            return categoryAndPageMatch && idMatch ? ActivePageClass : null;
+            return categoryAndPageMatch && idMatch;
+        }
+        
+        public static bool IsActivePage<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);
+        }
+
+        public static string ActiveCategoryClass<T>(this ViewDataDictionary viewData, T category, object id = null)
+        {
+            return ActiveCategoryClass(viewData, category.ToString(), id);
+        }
+
+        public static string ActiveCategoryClass(this ViewDataDictionary viewData, string category, object id = null)
+        {
+            return IsActiveCategory(viewData, category, id) ? ACTIVE_CLASS : null;
+        }
+
+        public static string ActivePageClass<T>(this ViewDataDictionary viewData, T page, object id = null)
+            where T : IConvertible
+        {
+            return ActivePageClass(viewData, page.ToString(), page.GetType().ToString(), id);
+        }
+
+        public static string ActivePageClass(this ViewDataDictionary viewData, string page, string category, object id = null)
+        {
+            return IsActivePage(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;
+        }
+
+        public static HtmlString ToBrowserDate(this DateTimeOffset date, string netFormat, string jsDateFormat = "short", string jsTimeFormat = "short")
+        {
+            var dateTime = date.ToString("o", CultureInfo.InvariantCulture);
+            var displayDate = date.ToString(netFormat, CultureInfo.InvariantCulture);
+            var tooltip = dateTime.Replace("T", " ");
+            return new HtmlString($"<time datetime=\"{dateTime}\" data-date-style=\"{jsDateFormat}\" data-time-style=\"{jsTimeFormat}\" data-initial=\"localized\" data-bs-toggle=\"tooltip\" data-bs-title=\"{tooltip}\">{displayDate}</time>");
         }
 
         public static HtmlString ToBrowserDate(this DateTimeOffset date, DateDisplayFormat format = DateDisplayFormat.Localized)

BTCPayServer.Abstractions/Form/Form.cs

@@ -5,7 +5,6 @@ using System.Reflection;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.Primitives;
 using Newtonsoft.Json.Linq;
-using Npgsql.Internal.TypeHandlers.GeometricHandlers;
 
 namespace BTCPayServer.Abstractions.Form;
 
@@ -105,31 +104,7 @@ public class Form
         }
     }
 
-    public void SetValues(JObject values)
-    {
-        var fields = GetAllFields().ToDictionary(k => k.FullName, k => k.Field);
-        SetValues(fields, new List<string>(), values);
-    }
-
-    private void SetValues(Dictionary<string, Field> fields, List<string> path, JObject values)
-    {
-        foreach (var prop in values.Properties())
-        {
-            List<string> propPath = new List<string>(path.Count + 1);
-            propPath.AddRange(path);
-            propPath.Add(prop.Name);
-            if (prop.Value.Type == JTokenType.Object)
-            {
-                SetValues(fields, propPath, (JObject)prop.Value);
-            }
-            else if (prop.Value.Type == JTokenType.String)
-            {
-                var fullName = string.Join('_', propPath.Where(s => !string.IsNullOrEmpty(s)));
-                if (fields.TryGetValue(fullName, out var f) && !f.Constant)
-                    f.Value = prop.Value.Value<string>();
-            }
-        }
-    }
+    
 
 
 }

BTCPayServer.Abstractions/Models/DatabaseOptions.cs

@@ -2,7 +2,6 @@ namespace BTCPayServer.Abstractions.Models
 {
     public class DatabaseOptions
     {
-        public DatabaseType DatabaseType { get; set; }
         public string ConnectionString { get; set; }
     }
 }

BTCPayServer.Abstractions/Models/DatabaseType.cs

@@ -1,9 +0,0 @@
-namespace BTCPayServer.Abstractions.Models
-{
-    public enum DatabaseType
-    {
-        Sqlite,
-        Postgres,
-        MySQL,
-    }
-}

BTCPayServer.Abstractions/Security/AuthorizationFilterHandle.cs

@@ -1,3 +1,4 @@
+using BTCPayApp.CommonServer;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Http;
 

BTCPayServer.Abstractions/Services/Safe.cs

@@ -1,5 +1,5 @@
 using System.Web;
-using Ganss.XSS;
+using Ganss.Xss;
 using Microsoft.AspNetCore.Html;
 using Microsoft.AspNetCore.Mvc.Rendering;
 

BTCPayServer.Abstractions/TagHelpers/PermissionTagHelper.cs

@@ -2,12 +2,13 @@ using System.Threading.Tasks;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Razor.TagHelpers;
-using Microsoft.Extensions.Logging;
+using System;
+using System.Linq;
 
 namespace BTCPayServer.Abstractions.TagHelpers;
 
 [HtmlTargetElement(Attributes = "[permission]")]
-[HtmlTargetElement(Attributes = "[not-permission]"  )]
+[HtmlTargetElement(Attributes = "[not-permission]")]
 public class PermissionTagHelper : TagHelper
 {
     private readonly IAuthorizationService _authorizationService;
@@ -22,29 +23,72 @@ public class PermissionTagHelper : TagHelper
     public string Permission { get; set; }
     public string NotPermission { get; set; }
     public string PermissionResource { get; set; }
-    
+    public bool AndMode { get; set; } = false;
 
     public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
     {
-        if (string.IsNullOrEmpty(Permission) && string.IsNullOrEmpty(NotPermission))
+        var permissions = Permission?.Split(',', StringSplitOptions.RemoveEmptyEntries) ?? Array.Empty<string>();
+        var notPermissions = NotPermission?.Split(',', StringSplitOptions.RemoveEmptyEntries) ?? Array.Empty<string>();
+
+        if (!permissions.Any() && !notPermissions.Any())
             return;
         if (_httpContextAccessor.HttpContext is null)
             return;
 
-        var expectedResult = !string.IsNullOrEmpty(Permission);
-        var key = $"{Permission??NotPermission}_{PermissionResource}";
-        if (!_httpContextAccessor.HttpContext.Items.TryGetValue(key, out var o) ||
-            o is not AuthorizationResult res)
+        bool shouldRender = true; // Assume tag should be rendered unless a check fails
+
+        // Process 'Permission' - User must have these permissions
+        if (permissions.Any())
         {
-            res = await _authorizationService.AuthorizeAsync(_httpContextAccessor.HttpContext.User,
-                PermissionResource,
-                Permission);
-            _httpContextAccessor.HttpContext.Items.Add(key, res);
+            bool finalResult = AndMode;
+            foreach (var perm in permissions)
+            {
+                var key = $"{perm}_{PermissionResource}";
+                AuthorizationResult res = await GetOrAddAuthorizationResult(key, perm);
+
+                if (AndMode)
+                    finalResult &= res.Succeeded;
+                else
+                    finalResult |= res.Succeeded;
+
+                if (!AndMode && finalResult) break;
+            }
+
+            shouldRender = finalResult;
         }
-        if (expectedResult != res.Succeeded)
+
+        // Process 'NotPermission' - User must not have these permissions
+        if (shouldRender && notPermissions.Any())
+        {
+            foreach (var notPerm in notPermissions)
+            {
+                var key = $"{notPerm}_{PermissionResource}";
+                AuthorizationResult res = await GetOrAddAuthorizationResult(key, notPerm);
+
+                if (res.Succeeded) // If the user has a 'NotPermission', they should not see the tag
+                {
+                    shouldRender = false;
+                    break;
+                }
+            }
+        }
+
+        if (!shouldRender)
         {
             output.SuppressOutput();
         }
+    }
 
+    private async Task<AuthorizationResult> GetOrAddAuthorizationResult(string key, string permission)
+    {
+        if (!_httpContextAccessor.HttpContext.Items.TryGetValue(key, out var cachedResult))
+        {
+            var res = await _authorizationService.AuthorizeAsync(_httpContextAccessor.HttpContext.User,
+                PermissionResource, permission);
+            _httpContextAccessor.HttpContext.Items[key] = res;
+            return res;
+        }
+
+        return cachedResult as AuthorizationResult;
     }
 }

BTCPayServer.Abstractions/TagHelpers/PermissionedFormTagHelper.cs

@@ -0,0 +1,35 @@
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Razor.TagHelpers;
+
+namespace BTCPayServer.Abstractions.TagHelpers;
+
+[HtmlTargetElement("form", Attributes = "[permissioned]")]
+public partial class PermissionedFormTagHelper(
+    IAuthorizationService authorizationService,
+    IHttpContextAccessor httpContextAccessor)
+    : TagHelper
+{
+    public string Permissioned { get; set; }
+    public string PermissionResource { get; set; }
+
+    public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
+    {
+        if (httpContextAccessor.HttpContext is null || string.IsNullOrEmpty(Permissioned))
+            return;
+
+        var res = await authorizationService.AuthorizeAsync(httpContextAccessor.HttpContext.User,
+            PermissionResource, Permissioned);
+        if (!res.Succeeded)
+        {
+            var content = await output.GetChildContentAsync();
+            var html = SubmitButtonRegex().Replace(content.GetContent(), "");
+            output.Content.SetHtmlContent($"<fieldset disabled>{html}</fieldset>");
+        }
+    }
+
+    [GeneratedRegex("<(button|input).*?type=\"submit\".*?>.*?</\\1>")]
+    private static partial Regex SubmitButtonRegex();
+}

BTCPayServer.Client/BTCPayServer.Client.csproj

@@ -16,7 +16,7 @@
         <Platforms>AnyCPU</Platforms>
     </PropertyGroup>
   <PropertyGroup>
-    <Version Condition=" '$(Version)' == '' ">1.7.3</Version>
+    <Version Condition=" '$(Version)' == '' ">1.7.4</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.3.21" />
-      <PackageReference Include="NBitcoin" Version="7.0.24" />
+      <PackageReference Include="BTCPayServer.Lightning.Common" Version="1.5.1" />
+      <PackageReference Include="NBitcoin" Version="7.0.37" />
       <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
     </ItemGroup>
   <ItemGroup>

BTCPayServer.Client/BTCPayServerClient.APIKeys.cs

@@ -1,58 +1,44 @@
 using System;
-using System.Collections.Generic;
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
 {
-    public partial class BTCPayServerClient
+    public virtual async Task<ApiKeyData> GetCurrentAPIKeyInfo(CancellationToken token = default)
     {
-        public virtual async Task<ApiKeyData> GetCurrentAPIKeyInfo(CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest("api/v1/api-keys/current"), token);
-            return await HandleResponse<ApiKeyData>(response);
-        }
+        return await SendHttpRequest<ApiKeyData>("api/v1/api-keys/current", null, HttpMethod.Get, token);
+    }
 
-        public virtual async Task<ApiKeyData> CreateAPIKey(CreateApiKeyRequest request, CancellationToken token = default)
-        {
-            if (request == null)
-                throw new ArgumentNullException(nameof(request));
-            var response = await _httpClient.SendAsync(CreateHttpRequest("api/v1/api-keys", bodyPayload: request, method: HttpMethod.Post), token);
-            return await HandleResponse<ApiKeyData>(response);
-        }
+    public virtual async Task<ApiKeyData> CreateAPIKey(CreateApiKeyRequest request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<ApiKeyData>("api/v1/api-keys", request, HttpMethod.Post, token);
+    }
 
-        public virtual async Task<ApiKeyData> CreateAPIKey(string userId, CreateApiKeyRequest request, CancellationToken token = default)
-        {
-            if (request == null)
-                throw new ArgumentNullException(nameof(request));
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/users/{userId}/api-keys",
-            bodyPayload: request, method: HttpMethod.Post), token);
-            return await HandleResponse<ApiKeyData>(response);
-        }
+    public virtual async Task<ApiKeyData> CreateAPIKey(string userId, CreateApiKeyRequest request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<ApiKeyData>($"api/v1/users/{userId}/api-keys", request, HttpMethod.Post, token);
+    }
 
-        public virtual async Task RevokeCurrentAPIKeyInfo(CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest("api/v1/api-keys/current", null, HttpMethod.Delete), token);
-            await HandleResponse(response);
-        }
+    public virtual async Task RevokeCurrentAPIKeyInfo(CancellationToken token = default)
+    {
+        await SendHttpRequest("api/v1/api-keys/current", null, HttpMethod.Delete, token);
+    }
 
-        public virtual async Task RevokeAPIKey(string apikey, CancellationToken token = default)
-        {
-            if (apikey == null)
-                throw new ArgumentNullException(nameof(apikey));
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/api-keys/{apikey}", null, HttpMethod.Delete), token);
-            await HandleResponse(response);
-        }
-        public virtual async Task RevokeAPIKey(string userId, string apikey, CancellationToken token = default)
-        {
-            if (apikey == null)
-                throw new ArgumentNullException(nameof(apikey));
-            if (userId is null)
-                throw new ArgumentNullException(nameof(userId));
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/users/{userId}/api-keys/{apikey}", null, HttpMethod.Delete), token);
-            await HandleResponse(response);
-        }
+    public virtual async Task RevokeAPIKey(string apikey, CancellationToken token = default)
+    {
+        if (apikey == null) throw new ArgumentNullException(nameof(apikey));
+        await SendHttpRequest($"api/v1/api-keys/{apikey}", null, HttpMethod.Delete, token);
+    }
+    public virtual async Task RevokeAPIKey(string userId, string apikey, CancellationToken token = default)
+    {
+        if (apikey == null) throw new ArgumentNullException(nameof(apikey));
+        if (userId is null) throw new ArgumentNullException(nameof(userId));
+        await SendHttpRequest($"api/v1/users/{userId}/api-keys/{apikey}", null, HttpMethod.Delete, token);
     }
 }

BTCPayServer.Client/BTCPayServerClient.Apps.cs

@@ -4,100 +4,63 @@ using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
 {
-    public partial class BTCPayServerClient
+    public virtual async Task<PointOfSaleAppData> CreatePointOfSaleApp(string storeId,
+        PointOfSaleAppRequest request, CancellationToken token = default)
     {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<PointOfSaleAppData>($"api/v1/stores/{storeId}/apps/pos", request, HttpMethod.Post, token);
+    }
 
-        public virtual async Task<PointOfSaleAppData> CreatePointOfSaleApp(string storeId,
-            CreatePointOfSaleAppRequest request, CancellationToken token = default)
-        {
-            if (request == null)
-                throw new ArgumentNullException(nameof(request));
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/apps/pos", bodyPayload: request,
-                    method: HttpMethod.Post), token);
-            return await HandleResponse<PointOfSaleAppData>(response);
-        }
+    public virtual async Task<CrowdfundAppData> CreateCrowdfundApp(string storeId,
+        CrowdfundAppRequest request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<CrowdfundAppData>($"api/v1/stores/{storeId}/apps/crowdfund", request, HttpMethod.Post, token);
+    }
 
-        public virtual async Task<CrowdfundAppData> CreateCrowdfundApp(string storeId,
-            CreateCrowdfundAppRequest request, CancellationToken token = default)
-        {
-            if (request == null)
-                throw new ArgumentNullException(nameof(request));
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/apps/crowdfund", bodyPayload: request,
-                    method: HttpMethod.Post), token);
-            return await HandleResponse<CrowdfundAppData>(response);
-        }
+    public virtual async Task<PointOfSaleAppData> UpdatePointOfSaleApp(string appId,
+        PointOfSaleAppRequest request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<PointOfSaleAppData>($"api/v1/apps/pos/{appId}", request, HttpMethod.Put, token);
+    }
 
-        public virtual async Task<PointOfSaleAppData> UpdatePointOfSaleApp(string appId,
-            CreatePointOfSaleAppRequest request, CancellationToken token = default)
-        {
-            if (request == null)
-                throw new ArgumentNullException(nameof(request));
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/apps/pos/{appId}", bodyPayload: request,
-                    method: HttpMethod.Put), token);
-            return await HandleResponse<PointOfSaleAppData>(response);
-        }
+    public virtual async Task<AppBaseData> GetApp(string appId, CancellationToken token = default)
+    {
+        if (appId == null) throw new ArgumentNullException(nameof(appId));
+        return await SendHttpRequest<AppBaseData>($"api/v1/apps/{appId}", null, HttpMethod.Get, token);
+    }
 
-        public virtual async Task<AppDataBase> GetApp(string appId, CancellationToken token = default)
-        {
-            if (appId == null)
-                throw new ArgumentNullException(nameof(appId));
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/apps/{appId}",
-                    method: HttpMethod.Get), token);
-            return await HandleResponse<AppDataBase>(response);
-        }
+    public virtual async Task<AppBaseData[]> GetAllApps(string storeId, CancellationToken token = default)
+    {
+        if (storeId == null) throw new ArgumentNullException(nameof(storeId));
+        return await SendHttpRequest<AppBaseData[]>($"api/v1/stores/{storeId}/apps", null, HttpMethod.Get, token);
+    }
 
-        public virtual async Task<AppDataBase[]> GetAllApps(string storeId, CancellationToken token = default)
-        {
-            if (storeId == null)
-                throw new ArgumentNullException(nameof(storeId));
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/apps",
-                    method: HttpMethod.Get), token);
-            return await HandleResponse<AppDataBase[]>(response);
-        }
+    public virtual async Task<AppBaseData[]> GetAllApps(CancellationToken token = default)
+    {
+        return await SendHttpRequest<AppBaseData[]>("api/v1/apps", null, HttpMethod.Get, token);
+    }
 
-        public virtual async Task<AppDataBase[]> GetAllApps(CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/apps",
-                    method: HttpMethod.Get), token);
-            return await HandleResponse<AppDataBase[]>(response);
-        }
+    public virtual async Task<PointOfSaleAppData> GetPosApp(string appId, CancellationToken token = default)
+    {
+        if (appId == null) throw new ArgumentNullException(nameof(appId));
+        return await SendHttpRequest<PointOfSaleAppData>($"api/v1/apps/pos/{appId}", null, HttpMethod.Get, token);
+    }
 
-        public virtual async Task<PointOfSaleAppData> GetPosApp(string appId, CancellationToken token = default)
-        {
-            if (appId == null)
-                throw new ArgumentNullException(nameof(appId));
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/apps/pos/{appId}",
-                    method: HttpMethod.Get), token);
-            return await HandleResponse<PointOfSaleAppData>(response);
-        }
+    public virtual async Task<CrowdfundAppData> GetCrowdfundApp(string appId, CancellationToken token = default)
+    {
+        if (appId == null) throw new ArgumentNullException(nameof(appId));
+        return await SendHttpRequest<CrowdfundAppData>($"api/v1/apps/crowdfund/{appId}", null, HttpMethod.Get, token);
+    }
 
-        public virtual async Task<CrowdfundAppData> GetCrowdfundApp(string appId, CancellationToken token = default)
-        {
-            if (appId == null)
-                throw new ArgumentNullException(nameof(appId));
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/apps/crowdfund/{appId}",
-                    method: HttpMethod.Get), token);
-            return await HandleResponse<CrowdfundAppData>(response);
-        }
-
-        public virtual async Task DeleteApp(string appId, CancellationToken token = default)
-        {
-            if (appId == null)
-                throw new ArgumentNullException(nameof(appId));
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/apps/{appId}",
-                    method: HttpMethod.Delete), token);
-            await HandleResponse(response);
-        }
+    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);
     }
 }

BTCPayServer.Client/BTCPayServerClient.Authorization.cs

@@ -1,34 +1,29 @@
 using System;
 using System.Collections.Generic;
-using System.Threading.Tasks;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
 {
-    public partial class BTCPayServerClient
+    public static Uri GenerateAuthorizeUri(Uri btcpayHost, string[] permissions, bool strict = true,
+        bool selectiveStores = false, (string ApplicationIdentifier, Uri Redirect) applicationDetails = default)
     {
-
-        public static Uri GenerateAuthorizeUri(Uri btcpayHost, string[] permissions, bool strict = true,
-            bool selectiveStores = false, (string ApplicationIdentifier, Uri Redirect) applicationDetails = default)
-        {
-            var result = new UriBuilder(btcpayHost);
-            result.Path = "api-keys/authorize";
-
-            AppendPayloadToQuery(result,
-                new Dictionary<string, object>()
-                {
-                    {"strict", strict}, {"selectiveStores", selectiveStores}, {"permissions", permissions}
-                });
-
-            if (applicationDetails.Redirect != null)
+        var result = new UriBuilder(btcpayHost) { Path = "api-keys/authorize" };
+        AppendPayloadToQuery(result,
+            new Dictionary<string, object>
             {
-                AppendPayloadToQuery(result, new KeyValuePair<string, object>("redirect", applicationDetails.Redirect));
-                if (!string.IsNullOrEmpty(applicationDetails.ApplicationIdentifier))
-                {
-                    AppendPayloadToQuery(result, new KeyValuePair<string, object>("applicationIdentifier", applicationDetails.ApplicationIdentifier));
-                }
-            }
+                {"strict", strict}, {"selectiveStores", selectiveStores}, {"permissions", permissions}
+            });
 
-            return result.Uri;
+        if (applicationDetails.Redirect != null)
+        {
+            AppendPayloadToQuery(result, new KeyValuePair<string, object>("redirect", applicationDetails.Redirect));
+            if (!string.IsNullOrEmpty(applicationDetails.ApplicationIdentifier))
+            {
+                AppendPayloadToQuery(result, new KeyValuePair<string, object>("applicationIdentifier", applicationDetails.ApplicationIdentifier));
+            }
         }
+
+        return result.Uri;
     }
 }

BTCPayServer.Client/BTCPayServerClient.CustodianAccounts.cs

@@ -1,102 +0,0 @@
-using System.Collections.Generic;
-using System.Net.Http;
-using System.Threading;
-using System.Threading.Tasks;
-using BTCPayServer.Client.Models;
-
-namespace BTCPayServer.Client
-{
-    public partial class BTCPayServerClient
-    {
-        public virtual async Task<IEnumerable<CustodianAccountData>> GetCustodianAccounts(string storeId, bool includeAssetBalances = false, CancellationToken token = default)
-        {
-            var queryPayload = new Dictionary<string, object>();
-            if (includeAssetBalances)
-            {
-                queryPayload.Add("assetBalances", "true");
-            }
-
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts", queryPayload), token);
-            return await HandleResponse<IEnumerable<CustodianAccountData>>(response);
-        }
-
-        public virtual async Task<CustodianAccountResponse> GetCustodianAccount(string storeId, string accountId, bool includeAssetBalances = false, CancellationToken token = default)
-        {
-            var queryPayload = new Dictionary<string, object>();
-            if (includeAssetBalances)
-            {
-                queryPayload.Add("assetBalances", "true");
-            }
-
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}", queryPayload), token);
-            return await HandleResponse<CustodianAccountResponse>(response);
-        }
-
-        public virtual async Task<CustodianAccountData> CreateCustodianAccount(string storeId, CreateCustodianAccountRequest request, CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts", bodyPayload: request, method: HttpMethod.Post), token);
-            return await HandleResponse<CustodianAccountData>(response);
-        }
-
-        public virtual async Task<CustodianAccountData> UpdateCustodianAccount(string storeId, string accountId, CreateCustodianAccountRequest request, CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}", bodyPayload: request, method: HttpMethod.Put), token);
-            return await HandleResponse<CustodianAccountData>(response);
-        }
-
-        public virtual async Task DeleteCustodianAccount(string storeId, string accountId, CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}", method: HttpMethod.Delete), token);
-            await HandleResponse(response);
-        }
-
-        public virtual async Task<DepositAddressData> GetCustodianAccountDepositAddress(string storeId, string accountId, string paymentMethod, CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/addresses/{paymentMethod}"), token);
-            return await HandleResponse<DepositAddressData>(response);
-        }
-
-        public virtual async Task<MarketTradeResponseData> MarketTradeCustodianAccountAsset(string storeId, string accountId, TradeRequestData request, CancellationToken token = default)
-        {
-            //var response = await _httpClient.SendAsync(CreateHttpRequest("api/v1/users", null, request, HttpMethod.Post), token);
-            //return await HandleResponse<ApplicationUserData>(response);
-            var internalRequest = CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/trades/market", null,
-                    request, HttpMethod.Post);
-            var response = await _httpClient.SendAsync(internalRequest, token);
-            return await HandleResponse<MarketTradeResponseData>(response);
-        }
-
-        public virtual async Task<MarketTradeResponseData> GetCustodianAccountTradeInfo(string storeId, string accountId, string tradeId, CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/trades/{tradeId}", method: HttpMethod.Get), token);
-            return await HandleResponse<MarketTradeResponseData>(response);
-        }
-
-        public virtual async Task<TradeQuoteResponseData> GetCustodianAccountTradeQuote(string storeId, string accountId, string fromAsset, string toAsset, CancellationToken token = default)
-        {
-            var queryPayload = new Dictionary<string, object>();
-            queryPayload.Add("fromAsset", fromAsset);
-            queryPayload.Add("toAsset", toAsset);
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/trades/quote", queryPayload), token);
-            return await HandleResponse<TradeQuoteResponseData>(response);
-        }
-
-        public virtual async Task<WithdrawalResponseData> CreateCustodianAccountWithdrawal(string storeId, string accountId, WithdrawRequestData request, CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/withdrawals", bodyPayload: request, method: HttpMethod.Post), token);
-            return await HandleResponse<WithdrawalResponseData>(response);
-        }
-
-        public virtual async Task<WithdrawalSimulationResponseData> SimulateCustodianAccountWithdrawal(string storeId, string accountId, WithdrawRequestData request, CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/withdrawals/simulation", bodyPayload: request, method: HttpMethod.Post), token);
-            return await HandleResponse<WithdrawalSimulationResponseData>(response);
-        }
-
-        public virtual async Task<WithdrawalResponseData> GetCustodianAccountWithdrawalInfo(string storeId, string accountId, string paymentMethod, string withdrawalId, CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/custodian-accounts/{accountId}/withdrawals/{paymentMethod}/{withdrawalId}", method: HttpMethod.Get), token);
-            return await HandleResponse<WithdrawalResponseData>(response);
-        }
-    }
-}

BTCPayServer.Client/BTCPayServerClient.Custodians.cs

@@ -1,16 +0,0 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using BTCPayServer.Client.Models;
-
-namespace BTCPayServer.Client
-{
-    public partial class BTCPayServerClient
-    {
-        public virtual async Task<IEnumerable<CustodianData>> GetCustodians(CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest("api/v1/custodians"), token);
-            return await HandleResponse<IEnumerable<CustodianData>>(response);
-        }
-    }
-}

BTCPayServer.Client/BTCPayServerClient.Files.cs

@@ -0,0 +1,29 @@
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Client.Models;
+
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
+{
+    public virtual async Task<FileData[]> GetFiles(CancellationToken token = default)
+    {
+        return await SendHttpRequest<FileData[]>("api/v1/files", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<FileData> GetFile(string fileId, CancellationToken token = default)
+    {
+        return await SendHttpRequest<FileData>($"api/v1/files/{fileId}", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<FileData> UploadFile(string filePath, string mimeType, CancellationToken token = default)
+    {
+        return await UploadFileRequest<FileData>("api/v1/files", filePath, mimeType, "file", HttpMethod.Post, token);
+    }
+
+    public virtual async Task DeleteFile(string fileId, CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/files/{fileId}", null, HttpMethod.Delete, token);
+    }
+}

BTCPayServer.Client/BTCPayServerClient.Health.cs

@@ -1,15 +1,14 @@
+using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
 {
-    public partial class BTCPayServerClient
+    public virtual async Task<ApiHealthData> GetHealth(CancellationToken token = default)
     {
-        public virtual async Task<ApiHealthData> GetHealth(CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest("api/v1/health"), token);
-            return await HandleResponse<ApiHealthData>(response);
-        }
+        return await SendHttpRequest<ApiHealthData>("api/v1/health", null, HttpMethod.Get, token);
     }
 }

BTCPayServer.Client/BTCPayServerClient.Invoices.cs

@@ -7,139 +7,95 @@ using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 using NBitcoin;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
 {
-    public partial class BTCPayServerClient
+    public virtual async Task<IEnumerable<InvoiceData>> GetInvoices(string storeId, string[] orderId = null,
+        InvoiceStatus[] status = null,
+        DateTimeOffset? startDate = null,
+        DateTimeOffset? endDate = null,
+        string textSearch = null,
+        bool includeArchived = false,
+        int? skip = null,
+        int? take = null,
+        CancellationToken token = default)
     {
-        public virtual async Task<IEnumerable<InvoiceData>> GetInvoices(string storeId, string[] orderId = null,
-            InvoiceStatus[] status = null,
-            DateTimeOffset? startDate = null,
-            DateTimeOffset? endDate = null,
-            string textSearch = null,
-            bool includeArchived = false,
-            int? skip = null,
-            int? take = null,
-            CancellationToken token = default)
-        {
-            Dictionary<string, object> queryPayload = new Dictionary<string, object>();
-            queryPayload.Add(nameof(includeArchived), includeArchived);
+        var queryPayload = new Dictionary<string, object> { { nameof(includeArchived), includeArchived } };
+        if (startDate is { } s)
+            queryPayload.Add(nameof(startDate), Utils.DateTimeToUnixTime(s));
+        if (endDate is { } e)
+            queryPayload.Add(nameof(endDate), Utils.DateTimeToUnixTime(e));
+        if (orderId != null)
+            queryPayload.Add(nameof(orderId), orderId);
+        if (textSearch != null)
+            queryPayload.Add(nameof(textSearch), textSearch);
+        if (status != null)
+            queryPayload.Add(nameof(status), status.Select(s => s.ToString().ToLower()).ToArray());
+        if (skip != null)
+            queryPayload.Add(nameof(skip), skip);
+        if (take != null)
+            queryPayload.Add(nameof(take), take);
 
-            if (startDate is DateTimeOffset s)
-                queryPayload.Add(nameof(startDate), Utils.DateTimeToUnixTime(s));
+        return await SendHttpRequest<IEnumerable<InvoiceData>>($"api/v1/stores/{storeId}/invoices", queryPayload, HttpMethod.Get, token);
+    }
 
-            if (endDate is DateTimeOffset e)
-                queryPayload.Add(nameof(endDate), Utils.DateTimeToUnixTime(e));
+    public virtual async Task<InvoiceData> GetInvoice(string storeId, string invoiceId,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<InvoiceData>($"api/v1/stores/{storeId}/invoices/{invoiceId}", null, HttpMethod.Get, token);
+    }
+    public virtual async Task<InvoicePaymentMethodDataModel[]> GetInvoicePaymentMethods(string storeId, string invoiceId,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<InvoicePaymentMethodDataModel[]>($"api/v1/stores/{storeId}/invoices/{invoiceId}/payment-methods", null, HttpMethod.Get, token);
+    }
 
-            if (orderId != null)
-                queryPayload.Add(nameof(orderId), orderId);
-            if (textSearch != null)
-                queryPayload.Add(nameof(textSearch), textSearch);
-            if (status != null)
-                queryPayload.Add(nameof(status), status.Select(s => s.ToString().ToLower()).ToArray());
+    public virtual async Task ArchiveInvoice(string storeId, string invoiceId,
+        CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{storeId}/invoices/{invoiceId}", null, HttpMethod.Delete, token);
+    }
 
-            if (skip != null)
-            {
-                queryPayload.Add(nameof(skip), skip);
-            }
+    public virtual async Task<InvoiceData> CreateInvoice(string storeId,
+        CreateInvoiceRequest request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<InvoiceData>($"api/v1/stores/{storeId}/invoices", request, HttpMethod.Post, token);
+    }
 
-            if (take != null)
-            {
-                queryPayload.Add(nameof(take), take);
-            }
+    public virtual async Task<InvoiceData> UpdateInvoice(string storeId, string invoiceId,
+        UpdateInvoiceRequest request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<InvoiceData>($"api/v1/stores/{storeId}/invoices/{invoiceId}", request, HttpMethod.Put, token);
+    }
 
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/invoices",
-                        queryPayload), token);
-            return await HandleResponse<IEnumerable<InvoiceData>>(response);
-        }
+    public virtual async Task<InvoiceData> MarkInvoiceStatus(string storeId, string invoiceId,
+        MarkInvoiceStatusRequest request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        if (request.Status != InvoiceStatus.Settled && request.Status != InvoiceStatus.Invalid) throw new ArgumentOutOfRangeException(nameof(request.Status), "Status can only be Invalid or Complete");
+        return await SendHttpRequest<InvoiceData>($"api/v1/stores/{storeId}/invoices/{invoiceId}/status", request, HttpMethod.Post, token);
+    }
 
-        public virtual async Task<InvoiceData> GetInvoice(string storeId, string invoiceId,
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/invoices/{invoiceId}"), token);
-            return await HandleResponse<InvoiceData>(response);
-        }
-        public virtual async Task<InvoicePaymentMethodDataModel[]> GetInvoicePaymentMethods(string storeId, string invoiceId,
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/invoices/{invoiceId}/payment-methods"), token);
-            return await HandleResponse<InvoicePaymentMethodDataModel[]>(response);
-        }
+    public virtual async Task<InvoiceData> UnarchiveInvoice(string storeId, string invoiceId, CancellationToken token = default)
+    {
+        return await SendHttpRequest<InvoiceData>($"api/v1/stores/{storeId}/invoices/{invoiceId}/unarchive", null, HttpMethod.Post, token);
+    }
 
-        public virtual async Task ArchiveInvoice(string storeId, string invoiceId,
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/invoices/{invoiceId}",
-                    method: HttpMethod.Delete), token);
-            await HandleResponse(response);
-        }
+    public virtual async Task ActivateInvoicePaymentMethod(string storeId, string invoiceId, string paymentMethod, CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{storeId}/invoices/{invoiceId}/payment-methods/{paymentMethod}/activate", null, HttpMethod.Post, token);
+    }
 
-        public virtual async Task<InvoiceData> CreateInvoice(string storeId,
-            CreateInvoiceRequest request, CancellationToken token = default)
-        {
-            if (request == null)
-                throw new ArgumentNullException(nameof(request));
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/invoices", bodyPayload: request,
-                    method: HttpMethod.Post), token);
-            return await HandleResponse<InvoiceData>(response);
-        }
-
-        public virtual async Task<InvoiceData> UpdateInvoice(string storeId, string invoiceId,
-            UpdateInvoiceRequest request, CancellationToken token = default)
-        {
-            if (request == null)
-                throw new ArgumentNullException(nameof(request));
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/invoices/{invoiceId}", bodyPayload: request,
-                    method: HttpMethod.Put), token);
-            return await HandleResponse<InvoiceData>(response);
-        }
-
-        public virtual async Task<InvoiceData> MarkInvoiceStatus(string storeId, string invoiceId,
-            MarkInvoiceStatusRequest request, CancellationToken token = default)
-        {
-            if (request == null)
-                throw new ArgumentNullException(nameof(request));
-            if (request.Status != InvoiceStatus.Settled && request.Status != InvoiceStatus.Invalid)
-                throw new ArgumentOutOfRangeException(nameof(request.Status), "Status can only be Invalid or Complete");
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/invoices/{invoiceId}/status", bodyPayload: request,
-                    method: HttpMethod.Post), token);
-            return await HandleResponse<InvoiceData>(response);
-        }
-
-        public virtual async Task<InvoiceData> UnarchiveInvoice(string storeId, string invoiceId, CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/invoices/{invoiceId}/unarchive",
-                    method: HttpMethod.Post), token);
-            return await HandleResponse<InvoiceData>(response);
-        }
-
-        public virtual async Task ActivateInvoicePaymentMethod(string storeId, string invoiceId, string paymentMethod, CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/invoices/{invoiceId}/payment-methods/{paymentMethod}/activate",
-                    method: HttpMethod.Post), token);
-            await HandleResponse(response);
-        }
-
-        public virtual async Task<PullPaymentData> RefundInvoice(
-            string storeId,
-            string invoiceId,
-            RefundInvoiceRequest request,
-            CancellationToken token = default
-        )
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/invoices/{invoiceId}/refund", bodyPayload: request,
-                    method: HttpMethod.Post), token);
-            return await HandleResponse<PullPaymentData>(response);
-        }
+    public virtual async Task<PullPaymentData> RefundInvoice(
+        string storeId,
+        string invoiceId,
+        RefundInvoiceRequest request,
+        CancellationToken token = default
+    )
+    {
+        return await SendHttpRequest<PullPaymentData>($"api/v1/stores/{storeId}/invoices/{invoiceId}/refund", request, HttpMethod.Post, token);
     }
 }

BTCPayServer.Client/BTCPayServerClient.LNURLPayPaymentMethods.cs

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

BTCPayServer.Client/BTCPayServerClient.Lightning.Internal.cs

@@ -5,142 +5,101 @@ using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
 {
-    public partial class BTCPayServerClient
+    public virtual async Task<LightningNodeInformationData> GetLightningNodeInfo(string cryptoCode,
+        CancellationToken token = default)
     {
-        public virtual async Task<LightningNodeInformationData> GetLightningNodeInfo(string cryptoCode,
-            CancellationToken token = default)
+        return await SendHttpRequest<LightningNodeInformationData>($"api/v1/server/lightning/{cryptoCode}/info", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<LightningNodeBalanceData> GetLightningNodeBalance(string cryptoCode,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<LightningNodeBalanceData>($"api/v1/server/lightning/{cryptoCode}/balance", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task ConnectToLightningNode(string cryptoCode, ConnectToNodeRequest request,
+        CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        await SendHttpRequest($"api/v1/server/lightning/{cryptoCode}/connect", request, HttpMethod.Post, token);
+    }
+
+    public virtual async Task<IEnumerable<LightningChannelData>> GetLightningNodeChannels(string cryptoCode,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<IEnumerable<LightningChannelData>>($"api/v1/server/lightning/{cryptoCode}/channels", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task OpenLightningChannel(string cryptoCode, OpenLightningChannelRequest request,
+        CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/server/lightning/{cryptoCode}/channels", request, HttpMethod.Post, token);
+    }
+
+    public virtual async Task<string> GetLightningDepositAddress(string cryptoCode, CancellationToken token = default)
+    {
+        return await SendHttpRequest<string>($"api/v1/server/lightning/{cryptoCode}/address", null, HttpMethod.Post, token);
+    }
+
+    public virtual async Task<LightningPaymentData> PayLightningInvoice(string cryptoCode, PayLightningInvoiceRequest request,
+        CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<LightningPaymentData>($"api/v1/server/lightning/{cryptoCode}/invoices/pay", request, HttpMethod.Post, token);
+    }
+
+    public virtual async Task<LightningPaymentData> GetLightningPayment(string cryptoCode,
+        string paymentHash, CancellationToken token = default)
+    {
+        if (paymentHash == null) throw new ArgumentNullException(nameof(paymentHash));
+        return await SendHttpRequest<LightningPaymentData>($"api/v1/server/lightning/{cryptoCode}/payments/{paymentHash}", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<LightningInvoiceData> GetLightningInvoice(string cryptoCode,
+        string invoiceId, CancellationToken token = default)
+    {
+        if (invoiceId == null) throw new ArgumentNullException(nameof(invoiceId));
+        return await SendHttpRequest<LightningInvoiceData>($"api/v1/server/lightning/{cryptoCode}/invoices/{invoiceId}", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<LightningInvoiceData[]> GetLightningInvoices(string cryptoCode,
+        bool? pendingOnly = null, long? offsetIndex = null, CancellationToken token = default)
+    {
+        var queryPayload = new Dictionary<string, object>();
+        if (pendingOnly is bool v)
         {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/info",
-                    method: HttpMethod.Get), token);
-            return await HandleResponse<LightningNodeInformationData>(response);
+            queryPayload.Add("pendingOnly", v.ToString());
         }
-
-        public virtual async Task<LightningNodeBalanceData> GetLightningNodeBalance(string cryptoCode,
-            CancellationToken token = default)
+        if (offsetIndex is > 0)
         {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/balance",
-                    method: HttpMethod.Get), token);
-            return await HandleResponse<LightningNodeBalanceData>(response);
+            queryPayload.Add("offsetIndex", offsetIndex);
         }
+        return await SendHttpRequest<LightningInvoiceData[]>($"api/v1/server/lightning/{cryptoCode}/invoices", queryPayload, HttpMethod.Get, token);
+    }
 
-        public virtual async Task ConnectToLightningNode(string cryptoCode, ConnectToNodeRequest request,
-            CancellationToken token = default)
+    public virtual async Task<LightningPaymentData[]> GetLightningPayments(string cryptoCode,
+        bool? includePending = null, long? offsetIndex = null, CancellationToken token = default)
+    {
+        var queryPayload = new Dictionary<string, object>();
+        if (includePending is bool v)
         {
-            if (request == null)
-                throw new ArgumentNullException(nameof(request));
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/connect", bodyPayload: request,
-                    method: HttpMethod.Post), token);
-            await HandleResponse(response);
+            queryPayload.Add("includePending", v.ToString());
         }
-
-        public virtual async Task<IEnumerable<LightningChannelData>> GetLightningNodeChannels(string cryptoCode,
-            CancellationToken token = default)
+        if (offsetIndex is > 0)
         {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/channels",
-                    method: HttpMethod.Get), token);
-            return await HandleResponse<IEnumerable<LightningChannelData>>(response);
+            queryPayload.Add("offsetIndex", offsetIndex);
         }
+        return await SendHttpRequest<LightningPaymentData[]>($"api/v1/server/lightning/{cryptoCode}/payments", queryPayload, HttpMethod.Get, token);
+    }
 
-        public virtual async Task OpenLightningChannel(string cryptoCode, OpenLightningChannelRequest request,
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/channels", bodyPayload: request,
-                    method: HttpMethod.Post), token);
-            await HandleResponse(response);
-        }
-
-        public virtual async Task<string> GetLightningDepositAddress(string cryptoCode, CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/address", method: HttpMethod.Post), token);
-            return await HandleResponse<string>(response);
-        }
-
-        public virtual async Task<LightningPaymentData> PayLightningInvoice(string cryptoCode, PayLightningInvoiceRequest request,
-            CancellationToken token = default)
-        {
-            if (request == null)
-                throw new ArgumentNullException(nameof(request));
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/invoices/pay", bodyPayload: request,
-                    method: HttpMethod.Post), token);
-            return await HandleResponse<LightningPaymentData>(response);
-        }
-
-        public virtual async Task<LightningPaymentData> GetLightningPayment(string cryptoCode,
-            string paymentHash, CancellationToken token = default)
-        {
-            if (paymentHash == null)
-                throw new ArgumentNullException(nameof(paymentHash));
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/payments/{paymentHash}",
-                    method: HttpMethod.Get), token);
-            return await HandleResponse<LightningPaymentData>(response);
-        }
-
-        public virtual async Task<LightningInvoiceData> GetLightningInvoice(string cryptoCode,
-            string invoiceId, CancellationToken token = default)
-        {
-            if (invoiceId == null)
-                throw new ArgumentNullException(nameof(invoiceId));
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/invoices/{invoiceId}",
-                    method: HttpMethod.Get), token);
-            return await HandleResponse<LightningInvoiceData>(response);
-        }
-
-        public virtual async Task<LightningInvoiceData[]> GetLightningInvoices(string cryptoCode,
-            bool? pendingOnly = null, long? offsetIndex = null, CancellationToken token = default)
-        {
-            var queryPayload = new Dictionary<string, object>();
-            if (pendingOnly is bool v)
-            {
-                queryPayload.Add("pendingOnly", v.ToString());
-            }
-            if (offsetIndex is > 0)
-            {
-                queryPayload.Add("offsetIndex", offsetIndex);
-            }
-
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/invoices", queryPayload), token);
-            return await HandleResponse<LightningInvoiceData[]>(response);
-        }
-
-        public virtual async Task<LightningPaymentData[]> GetLightningPayments(string cryptoCode,
-            bool? includePending = null, long? offsetIndex = null, CancellationToken token = default)
-        {
-            var queryPayload = new Dictionary<string, object>();
-            if (includePending is bool v)
-            {
-                queryPayload.Add("includePending", v.ToString());
-            }
-            if (offsetIndex is > 0)
-            {
-                queryPayload.Add("offsetIndex", offsetIndex);
-            }
-
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/payments", queryPayload), token);
-            return await HandleResponse<LightningPaymentData[]>(response);
-        }
-
-        public virtual async Task<LightningInvoiceData> CreateLightningInvoice(string cryptoCode, CreateLightningInvoiceRequest request,
-            CancellationToken token = default)
-        {
-            if (request == null)
-                throw new ArgumentNullException(nameof(request));
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/invoices", bodyPayload: request,
-                    method: HttpMethod.Post), token);
-            return await HandleResponse<LightningInvoiceData>(response);
-        }
+    public virtual async Task<LightningInvoiceData> CreateLightningInvoice(string cryptoCode, CreateLightningInvoiceRequest request,
+        CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<LightningInvoiceData>($"api/v1/server/lightning/{cryptoCode}/invoices", request, HttpMethod.Post, token);
     }
 }

BTCPayServer.Client/BTCPayServerClient.Lightning.Store.cs

@@ -5,144 +5,102 @@ using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
 {
-    public partial class BTCPayServerClient
+    public virtual async Task<LightningNodeInformationData> GetLightningNodeInfo(string storeId, string cryptoCode,
+        CancellationToken token = default)
     {
-        public virtual async Task<LightningNodeInformationData> GetLightningNodeInfo(string storeId, string cryptoCode,
-            CancellationToken token = default)
+        return await SendHttpRequest<LightningNodeInformationData>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/info", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<LightningNodeBalanceData> GetLightningNodeBalance(string storeId, string cryptoCode,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<LightningNodeBalanceData>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/balance", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task ConnectToLightningNode(string storeId, string cryptoCode, ConnectToNodeRequest request,
+        CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        await SendHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/connect", request, HttpMethod.Post, token);
+    }
+
+    public virtual async Task<IEnumerable<LightningChannelData>> GetLightningNodeChannels(string storeId, string cryptoCode,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<IEnumerable<LightningChannelData>>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/channels", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task OpenLightningChannel(string storeId, string cryptoCode, OpenLightningChannelRequest request,
+        CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/channels", request, HttpMethod.Post, token);
+    }
+
+    public virtual async Task<string> GetLightningDepositAddress(string storeId, string cryptoCode,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<string>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/address", null, HttpMethod.Post, token);
+    }
+
+    public virtual async Task<LightningPaymentData> PayLightningInvoice(string storeId, string cryptoCode, PayLightningInvoiceRequest request,
+        CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<LightningPaymentData>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/invoices/pay", request, HttpMethod.Post, token);
+    }
+
+    public virtual async Task<LightningPaymentData> GetLightningPayment(string storeId, string cryptoCode,
+        string paymentHash, CancellationToken token = default)
+    {
+        if (paymentHash == null) throw new ArgumentNullException(nameof(paymentHash));
+        return await SendHttpRequest<LightningPaymentData>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/payments/{paymentHash}", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<LightningInvoiceData> GetLightningInvoice(string storeId, string cryptoCode,
+        string invoiceId, CancellationToken token = default)
+    {
+        if (invoiceId == null) throw new ArgumentNullException(nameof(invoiceId));
+        return await SendHttpRequest<LightningInvoiceData>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/invoices/{invoiceId}", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<LightningInvoiceData[]> GetLightningInvoices(string storeId, string cryptoCode,
+        bool? pendingOnly = null, long? offsetIndex = null, CancellationToken token = default)
+    {
+        var queryPayload = new Dictionary<string, object>();
+        if (pendingOnly is bool v)
         {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/info",
-                    method: HttpMethod.Get), token);
-            return await HandleResponse<LightningNodeInformationData>(response);
+            queryPayload.Add("pendingOnly", v.ToString());
         }
-
-        public virtual async Task<LightningNodeBalanceData> GetLightningNodeBalance(string storeId, string cryptoCode,
-            CancellationToken token = default)
+        if (offsetIndex is > 0)
         {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/balance",
-                    method: HttpMethod.Get), token);
-            return await HandleResponse<LightningNodeBalanceData>(response);
+            queryPayload.Add("offsetIndex", offsetIndex);
         }
+        return await SendHttpRequest<LightningInvoiceData[]>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/invoices", queryPayload, HttpMethod.Get, token);
+    }
 
-        public virtual async Task ConnectToLightningNode(string storeId, string cryptoCode, ConnectToNodeRequest request,
-            CancellationToken token = default)
+    public virtual async Task<LightningPaymentData[]> GetLightningPayments(string storeId, string cryptoCode,
+        bool? includePending = null, long? offsetIndex = null, CancellationToken token = default)
+    {
+        var queryPayload = new Dictionary<string, object>();
+        if (includePending is bool v)
         {
-            if (request == null)
-                throw new ArgumentNullException(nameof(request));
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/connect", bodyPayload: request,
-                    method: HttpMethod.Post), token);
-            await HandleResponse(response);
+            queryPayload.Add("includePending", v.ToString());
         }
-
-        public virtual async Task<IEnumerable<LightningChannelData>> GetLightningNodeChannels(string storeId, string cryptoCode,
-            CancellationToken token = default)
+        if (offsetIndex is > 0)
         {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/channels",
-                    method: HttpMethod.Get), token);
-            return await HandleResponse<IEnumerable<LightningChannelData>>(response);
+            queryPayload.Add("offsetIndex", offsetIndex);
         }
+        return await SendHttpRequest<LightningPaymentData[]>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/payments", queryPayload, HttpMethod.Get, token);
+    }
 
-        public virtual async Task OpenLightningChannel(string storeId, string cryptoCode, OpenLightningChannelRequest request,
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/channels", bodyPayload: request,
-                    method: HttpMethod.Post), token);
-            await HandleResponse(response);
-        }
-
-        public virtual async Task<string> GetLightningDepositAddress(string storeId, string cryptoCode,
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/address", method: HttpMethod.Post),
-                token);
-            return await HandleResponse<string>(response);
-        }
-
-        public virtual async Task<LightningPaymentData> PayLightningInvoice(string storeId, string cryptoCode, PayLightningInvoiceRequest request,
-            CancellationToken token = default)
-        {
-            if (request == null)
-                throw new ArgumentNullException(nameof(request));
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/invoices/pay", bodyPayload: request,
-                    method: HttpMethod.Post), token);
-            return await HandleResponse<LightningPaymentData>(response);
-        }
-
-        public virtual async Task<LightningPaymentData> GetLightningPayment(string storeId, string cryptoCode,
-            string paymentHash, CancellationToken token = default)
-        {
-            if (paymentHash == null)
-                throw new ArgumentNullException(nameof(paymentHash));
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/payments/{paymentHash}",
-                    method: HttpMethod.Get), token);
-            return await HandleResponse<LightningPaymentData>(response);
-        }
-
-        public virtual async Task<LightningInvoiceData> GetLightningInvoice(string storeId, string cryptoCode,
-            string invoiceId, CancellationToken token = default)
-        {
-            if (invoiceId == null)
-                throw new ArgumentNullException(nameof(invoiceId));
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/invoices/{invoiceId}",
-                    method: HttpMethod.Get), token);
-            return await HandleResponse<LightningInvoiceData>(response);
-        }
-
-        public virtual async Task<LightningInvoiceData[]> GetLightningInvoices(string storeId, string cryptoCode,
-            bool? pendingOnly = null, long? offsetIndex = null, CancellationToken token = default)
-        {
-            var queryPayload = new Dictionary<string, object>();
-            if (pendingOnly is bool v)
-            {
-                queryPayload.Add("pendingOnly", v.ToString());
-            }
-            if (offsetIndex is > 0)
-            {
-                queryPayload.Add("offsetIndex", offsetIndex);
-            }
-
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/invoices", queryPayload), token);
-            return await HandleResponse<LightningInvoiceData[]>(response);
-        }
-
-        public virtual async Task<LightningPaymentData[]> GetLightningPayments(string storeId, string cryptoCode,
-            bool? includePending = null, long? offsetIndex = null, CancellationToken token = default)
-        {
-            var queryPayload = new Dictionary<string, object>();
-            if (includePending is bool v)
-            {
-                queryPayload.Add("includePending", v.ToString());
-            }
-            if (offsetIndex is > 0)
-            {
-                queryPayload.Add("offsetIndex", offsetIndex);
-            }
-
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/payments", queryPayload), token);
-            return await HandleResponse<LightningPaymentData[]>(response);
-        }
-
-        public virtual async Task<LightningInvoiceData> CreateLightningInvoice(string storeId, string cryptoCode,
-            CreateLightningInvoiceRequest request, CancellationToken token = default)
-        {
-            if (request == null)
-                throw new ArgumentNullException(nameof(request));
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/invoices", bodyPayload: request,
-                    method: HttpMethod.Post), token);
-            return await HandleResponse<LightningInvoiceData>(response);
-        }
+    public virtual async Task<LightningInvoiceData> CreateLightningInvoice(string storeId, string cryptoCode,
+        CreateLightningInvoiceRequest request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<LightningInvoiceData>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/invoices", request, HttpMethod.Post, token);
     }
 }

BTCPayServer.Client/BTCPayServerClient.LightningAddresses.cs

@@ -3,46 +3,32 @@ using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
 {
-    public partial class BTCPayServerClient
+    public virtual async Task<LightningAddressData[]> GetStoreLightningAddresses(string storeId,
+        CancellationToken token = default)
     {
-        public virtual async Task<LightningAddressData[]> GetStoreLightningAddresses(string storeId,
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/lightning-addresses",
-                    method: HttpMethod.Get), token);
-            return await HandleResponse<LightningAddressData[]>(response);
-        }
+        return await SendHttpRequest<LightningAddressData[]>($"api/v1/stores/{storeId}/lightning-addresses", null, HttpMethod.Get, token);
+    }
 
-        public virtual async Task<LightningAddressData> GetStoreLightningAddress(string storeId, string username,
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/lightning-addresses/{username}",
-                    method: HttpMethod.Get), token);
-            return await HandleResponse<LightningAddressData>(response);
-        }
+    public virtual async Task<LightningAddressData> GetStoreLightningAddress(string storeId, string username,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<LightningAddressData>($"api/v1/stores/{storeId}/lightning-addresses/{username}", null, HttpMethod.Get, token);
+    }
 
-        public virtual async Task RemoveStoreLightningAddress(string storeId, string username,
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/lightning-addresses/{username}",
-                    method: HttpMethod.Delete), token);
-            await HandleResponse(response);
-        }
+    public virtual async Task RemoveStoreLightningAddress(string storeId, string username,
+        CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{storeId}/lightning-addresses/{username}", null, HttpMethod.Delete, token);
+    }
 
-        public virtual async Task<LightningAddressData> AddOrUpdateStoreLightningAddress(string storeId,
-            string username, LightningAddressData data,
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/lightning-addresses/{username}",
-                    method: HttpMethod.Post, bodyPayload: data), token);
-
-            return await HandleResponse<LightningAddressData>(response);
-        }
+    public virtual async Task<LightningAddressData> AddOrUpdateStoreLightningAddress(string storeId,
+        string username, LightningAddressData data,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<LightningAddressData>($"api/v1/stores/{storeId}/lightning-addresses/{username}", data, HttpMethod.Post, token);
     }
 }

BTCPayServer.Client/BTCPayServerClient.LightningNetworkPaymentMethods.cs

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

BTCPayServer.Client/BTCPayServerClient.Misc.cs

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

BTCPayServer.Client/BTCPayServerClient.Notifications.cs

@@ -1,56 +1,52 @@
-using System;
 using System.Collections.Generic;
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
 {
-    public partial class BTCPayServerClient
+    public virtual async Task<IEnumerable<NotificationData>> GetNotifications(bool? seen = null, int? skip = null,
+        int? take = null, string[] storeId = null, CancellationToken token = default)
     {
-        public virtual async Task<IEnumerable<NotificationData>> GetNotifications(bool? seen = null, int? skip = null,
-            int? take = null, CancellationToken token = default)
-        {
-            Dictionary<string, object> queryPayload = new Dictionary<string, object>();
+        var queryPayload = new Dictionary<string, object>();
+        if (seen != null)
+            queryPayload.Add(nameof(seen), seen);
+        if (skip != null)
+            queryPayload.Add(nameof(skip), skip);
+        if (take != null)
+            queryPayload.Add(nameof(take), take);
+        if (storeId != null)
+            queryPayload.Add(nameof(storeId), storeId);
+        return await SendHttpRequest<IEnumerable<NotificationData>>("api/v1/users/me/notifications", queryPayload, HttpMethod.Get, token);
+    }
 
-            if (seen != null)
-                queryPayload.Add(nameof(seen), seen);
-            if (skip != null)
-                queryPayload.Add(nameof(skip), skip);
-            if (take != null)
-                queryPayload.Add(nameof(take), take);
+    public virtual async Task<NotificationData> GetNotification(string notificationId,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<NotificationData>($"api/v1/users/me/notifications/{notificationId}", null, HttpMethod.Get, token);
+    }
 
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/users/me/notifications",
-                    queryPayload), token);
+    public virtual async Task<NotificationData> UpdateNotification(string notificationId, bool? seen,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<NotificationData>($"api/v1/users/me/notifications/{notificationId}", new UpdateNotification { Seen = seen }, HttpMethod.Put, token);
+    }
 
-            return await HandleResponse<IEnumerable<NotificationData>>(response);
-        }
+    public virtual async Task<NotificationSettingsData> GetNotificationSettings(CancellationToken token = default)
+    {
+        return await SendHttpRequest<NotificationSettingsData>("api/v1/users/me/notification-settings", null, HttpMethod.Get, token);
+    }
 
-        public virtual async Task<NotificationData> GetNotification(string notificationId,
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/users/me/notifications/{notificationId}"), token);
-            return await HandleResponse<NotificationData>(response);
-        }
+    public virtual async Task<NotificationSettingsData> UpdateNotificationSettings(UpdateNotificationSettingsRequest request, CancellationToken token = default)
+    {
+        return await SendHttpRequest<NotificationSettingsData>("api/v1/users/me/notification-settings", request, HttpMethod.Put, token);
+    }
 
-        public virtual async Task<NotificationData> UpdateNotification(string notificationId, bool? seen,
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/users/me/notifications/{notificationId}",
-                    method: HttpMethod.Put, bodyPayload: new UpdateNotification() { Seen = seen }), token);
-            return await HandleResponse<NotificationData>(response);
-        }
-
-        public virtual async Task RemoveNotification(string notificationId, CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/users/me/notifications/{notificationId}",
-                    method: HttpMethod.Delete), token);
-            await HandleResponse(response);
-        }
+    public virtual async Task RemoveNotification(string notificationId, CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/users/me/notifications/{notificationId}", null, HttpMethod.Delete, token);
     }
 }

BTCPayServer.Client/BTCPayServerClient.OnChainPaymentMethods.cs

@@ -3,92 +3,37 @@ using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
+using Newtonsoft.Json.Linq;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
 {
-    public partial class BTCPayServerClient
+    public virtual async Task<OnChainPaymentMethodPreviewResultData>
+        PreviewProposedStoreOnChainPaymentMethodAddresses(
+            string storeId, string paymentMethodId, string derivationScheme, int offset = 0,
+            int amount = 10,
+            CancellationToken token = default)
     {
-        public virtual async Task<IEnumerable<OnChainPaymentMethodData>> GetStoreOnChainPaymentMethods(string storeId,
-            bool? enabled = null,
-            CancellationToken token = default)
-        {
-            var query = new Dictionary<string, object>();
-            if (enabled != null)
-            {
-                query.Add(nameof(enabled), enabled);
-            }
-
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain",
-                        query), token);
-            return await HandleResponse<IEnumerable<OnChainPaymentMethodData>>(response);
-        }
-
-        public virtual async Task<OnChainPaymentMethodData> GetStoreOnChainPaymentMethod(string storeId,
-            string cryptoCode, CancellationToken token = default)
-        {
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}"), token);
-            return await HandleResponse<OnChainPaymentMethodData>(response);
-        }
-
-        public virtual async Task RemoveStoreOnChainPaymentMethod(string storeId,
-            string cryptoCode, CancellationToken token = default)
-        {
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}",
-                        method: HttpMethod.Delete), token);
-            await HandleResponse(response);
-        }
-
-        public virtual async Task<OnChainPaymentMethodData> UpdateStoreOnChainPaymentMethod(string storeId,
-            string cryptoCode, UpdateOnChainPaymentMethodRequest paymentMethod,
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}",
-                    bodyPayload: paymentMethod, method: HttpMethod.Put), token);
-            return await HandleResponse<OnChainPaymentMethodData>(response);
-        }
-
-        public virtual async Task<OnChainPaymentMethodPreviewResultData>
-            PreviewProposedStoreOnChainPaymentMethodAddresses(
-                string storeId, string cryptoCode, UpdateOnChainPaymentMethodRequest paymentMethod, int offset = 0,
-                int amount = 10,
-                CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/preview",
-                    bodyPayload: paymentMethod,
-                    queryPayload: new Dictionary<string, object>() { { "offset", offset }, { "amount", amount } },
-                    method: HttpMethod.Post), token);
-            return await HandleResponse<OnChainPaymentMethodPreviewResultData>(response);
-        }
-
-        public virtual async Task<OnChainPaymentMethodPreviewResultData> PreviewStoreOnChainPaymentMethodAddresses(
-            string storeId, string cryptoCode, int offset = 0, int amount = 10,
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/preview",
-                    queryPayload: new Dictionary<string, object>() { { "offset", offset }, { "amount", amount } },
-                    method: HttpMethod.Get), token);
-            return await HandleResponse<OnChainPaymentMethodPreviewResultData>(response);
-        }
-
-        public virtual async Task<OnChainPaymentMethodDataWithSensitiveData> GenerateOnChainWallet(string storeId,
-            string cryptoCode, GenerateOnChainWalletRequest request,
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/generate",
-                    bodyPayload: request,
-                    method: HttpMethod.Post), token);
-            return await HandleResponse<OnChainPaymentMethodDataWithSensitiveData>(response);
-        }
-
+        return await SendHttpRequest<UpdatePaymentMethodRequest, OnChainPaymentMethodPreviewResultData>($"api/v1/stores/{storeId}/payment-methods/{paymentMethodId}/preview",
+            new Dictionary<string, object> { { "offset", offset }, { "amount", amount } },
+            new UpdatePaymentMethodRequest { Config = JValue.CreateString(derivationScheme) },
+            HttpMethod.Post, token);
     }
+
+    public virtual async Task<OnChainPaymentMethodPreviewResultData> PreviewStoreOnChainPaymentMethodAddresses(
+        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",
+            new Dictionary<string, object> { { "offset", offset }, { "amount", amount } }, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<GenerateOnChainWalletResponse> GenerateOnChainWallet(string storeId,
+        string paymentMethodId, GenerateOnChainWalletRequest request,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<GenerateOnChainWalletResponse>($"api/v1/stores/{storeId}/payment-methods/{paymentMethodId}/generate", request, HttpMethod.Post, token);
+    }
+
 }

BTCPayServer.Client/BTCPayServerClient.OnChainWallet.Objects.cs

@@ -1,82 +1,62 @@
-using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
-using NBitcoin;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
 {
-    public partial class BTCPayServerClient
+    public virtual async Task<OnChainWalletObjectData> GetOnChainWalletObject(string storeId, string cryptoCode, OnChainWalletObjectId objectId, bool? includeNeighbourData = null, CancellationToken token = default)
     {
-        public virtual async Task<OnChainWalletObjectData> GetOnChainWalletObject(string storeId, string cryptoCode, OnChainWalletObjectId objectId, bool? includeNeighbourData = null, CancellationToken token = default)
+        var parameters = new Dictionary<string, object>();
+        if (includeNeighbourData is bool v)
+            parameters.Add("includeNeighbourData", v);
+        try
         {
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            if (includeNeighbourData is bool v)
-                parameters.Add("includeNeighbourData", v);
-            var response =
-            await _httpClient.SendAsync(
-            CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects/{objectId.Type}/{objectId.Id}", parameters, method: HttpMethod.Get), token);
-            try
-            {
-                return await HandleResponse<OnChainWalletObjectData>(response);
-            }
-            catch (GreenfieldAPIException err) when (err.APIError.Code == "wallet-object-not-found")
-            {
-                return null;
-            }
+            return await SendHttpRequest<OnChainWalletObjectData>($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects/{objectId.Type}/{objectId.Id}", parameters, HttpMethod.Get, token);
         }
-        public virtual async Task<OnChainWalletObjectData[]> GetOnChainWalletObjects(string storeId, string cryptoCode, GetWalletObjectsRequest query = null, CancellationToken token = default)
+        catch (GreenfieldAPIException err) when (err.APIError.Code == "wallet-object-not-found")
         {
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            if (query?.Type is string s)
-                parameters.Add("type", s);
-            if (query?.Ids is string[] ids)
-                parameters.Add("ids", ids);
-            if (query?.IncludeNeighbourData is bool v)
-                parameters.Add("includeNeighbourData", v);
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects", parameters, method: HttpMethod.Get), token);
-            return await HandleResponse<OnChainWalletObjectData[]>(response);
-        }
-        public virtual async Task RemoveOnChainWalletObject(string storeId, string cryptoCode, OnChainWalletObjectId objectId,
-            CancellationToken token = default)
-        {
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects/{objectId.Type}/{objectId.Id}", method: HttpMethod.Delete), token);
-            await HandleResponse(response);
-        }
-        public virtual async Task<OnChainWalletObjectData> AddOrUpdateOnChainWalletObject(string storeId, string cryptoCode, AddOnChainWalletObjectRequest request,
-            CancellationToken token = default)
-        {
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects", method: HttpMethod.Post, bodyPayload: request), token);
-            return await HandleResponse<OnChainWalletObjectData>(response);
-        }
-        public virtual async Task AddOrUpdateOnChainWalletLink(string storeId, string cryptoCode,
-            OnChainWalletObjectId objectId,
-            AddOnChainWalletObjectLinkRequest request = null,
-            CancellationToken token = default)
-        {
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects/{objectId.Type}/{objectId.Id}/links", method: HttpMethod.Post, bodyPayload: request), token);
-            await HandleResponse(response);
-        }
-        public virtual async Task RemoveOnChainWalletLinks(string storeId, string cryptoCode,
-            OnChainWalletObjectId objectId,
-            OnChainWalletObjectId link,
-            CancellationToken token = default)
-        {
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/objects/{objectId.Type}/{objectId.Id}/links/{link.Type}/{link.Id}", method: HttpMethod.Delete), token);
-            await HandleResponse(response);
+            return null;
         }
     }
+    public virtual async Task<OnChainWalletObjectData[]> GetOnChainWalletObjects(string storeId, string cryptoCode, GetWalletObjectsRequest query = null, CancellationToken token = default)
+    {
+        Dictionary<string, object> parameters = new Dictionary<string, object>();
+        if (query?.Type is string s)
+            parameters.Add("type", s);
+        if (query?.Ids is string[] ids)
+            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);
+    }
+    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);
+    }
+    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);
+    }
+
+    public virtual async Task AddOrUpdateOnChainWalletLink(string storeId, string cryptoCode,
+        OnChainWalletObjectId objectId,
+        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);
+    }
+
+    public virtual async Task RemoveOnChainWalletLinks(string storeId, string cryptoCode,
+        OnChainWalletObjectId objectId,
+        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);
+    }
 }

BTCPayServer.Client/BTCPayServerClient.OnChainWallet.cs

@@ -7,138 +7,105 @@ using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 using NBitcoin;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
 {
-    public partial class BTCPayServerClient
+    public virtual async Task<OnChainWalletOverviewData> ShowOnChainWalletOverview(string storeId, string cryptoCode,
+        CancellationToken token = default)
     {
-        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);
+    }
+    public virtual async Task<OnChainWalletFeeRateData> GetOnChainFeeRate(string storeId, string cryptoCode, int? blockTarget = null,
+        CancellationToken token = default)
+    {
+        var queryParams = new Dictionary<string, object>();
+        if (blockTarget != null)
         {
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet"), token);
-            return await HandleResponse<OnChainWalletOverviewData>(response);
-        }
-        public virtual async Task<OnChainWalletFeeRateData> GetOnChainFeeRate(string storeId, string cryptoCode, int? blockTarget = null,
-            CancellationToken token = default)
-        {
-            Dictionary<string, object> queryParams = new Dictionary<string, object>();
-            if (blockTarget != null)
-            {
-                queryParams.Add("blockTarget", blockTarget);
-            }
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/feeRate", queryParams), token);
-            return await HandleResponse<OnChainWalletFeeRateData>(response);
+            queryParams.Add("blockTarget", blockTarget);
         }
+        return await SendHttpRequest<OnChainWalletFeeRateData>($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/feeRate", queryParams, HttpMethod.Get, token);
+    }
 
-        public virtual async Task<OnChainWalletAddressData> GetOnChainWalletReceiveAddress(string storeId, string cryptoCode, bool forceGenerate = false,
-            CancellationToken token = default)
+    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>
         {
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/address", new Dictionary<string, object>()
-                    {
-                        {"forceGenerate", forceGenerate}
-                    }), token);
-            return await HandleResponse<OnChainWalletAddressData>(response);
-        }
+            {"forceGenerate", forceGenerate}
+        }, HttpMethod.Get, token);
+    }
 
-        public virtual async Task UnReserveOnChainWalletReceiveAddress(string storeId, string cryptoCode,
-            CancellationToken token = default)
-        {
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/address", method: HttpMethod.Delete), token);
-            await HandleResponse(response);
-        }
+    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);
+    }
 
-        public virtual async Task<IEnumerable<OnChainWalletTransactionData>> ShowOnChainWalletTransactions(
-            string storeId, string cryptoCode, TransactionStatus[] statusFilter = null, string labelFilter = null, int skip = 0,
-            CancellationToken token = default)
+    public virtual async Task<IEnumerable<OnChainWalletTransactionData>> ShowOnChainWalletTransactions(
+        string storeId, string cryptoCode, TransactionStatus[] statusFilter = null, string labelFilter = null, int skip = 0,
+        CancellationToken token = default)
+    {
+        var query = new Dictionary<string, object>();
+        if (statusFilter?.Any() is true)
         {
-            var query = new Dictionary<string, object>();
-            if (statusFilter?.Any() is true)
-            {
-                query.Add(nameof(statusFilter), statusFilter);
-            }
-            if (labelFilter != null)
-            {
-                query.Add(nameof(labelFilter), labelFilter);
-            }
-            if (skip != 0)
-            {
-                query.Add(nameof(skip), skip);
-            }
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions", query), token);
-            return await HandleResponse<IEnumerable<OnChainWalletTransactionData>>(response);
+            query.Add(nameof(statusFilter), statusFilter);
         }
+        if (labelFilter != null)
+        {
+            query.Add(nameof(labelFilter), labelFilter);
+        }
+        if (skip != 0)
+        {
+            query.Add(nameof(skip), skip);
+        }
+        return await SendHttpRequest<IEnumerable<OnChainWalletTransactionData>>($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions", query, HttpMethod.Get, token);
+    }
 
-        public virtual async Task<OnChainWalletTransactionData> GetOnChainWalletTransaction(
-            string storeId, string cryptoCode, string transactionId,
-            CancellationToken token = default)
-        {
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions/{transactionId}"), token);
-            return await HandleResponse<OnChainWalletTransactionData>(response);
-        }
+    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);
+    }
 
-        public virtual async Task<OnChainWalletTransactionData> PatchOnChainWalletTransaction(
-            string storeId, string cryptoCode, string transactionId,
-            PatchOnChainTransactionRequest request,
-            bool force = false, CancellationToken token = default)
-        {
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions/{transactionId}", queryPayload: new Dictionary<string, object>()
-                    {
-                        {"force", force}
-                    }, bodyPayload: request, HttpMethod.Patch), token);
-            return await HandleResponse<OnChainWalletTransactionData>(response);
-        }
+    public virtual async Task<OnChainWalletTransactionData> PatchOnChainWalletTransaction(
+        string storeId, string cryptoCode, string transactionId,
+        PatchOnChainTransactionRequest request,
+        bool force = false, CancellationToken token = default)
+    {
+        return await SendHttpRequest<PatchOnChainTransactionRequest, OnChainWalletTransactionData>($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions/{transactionId}", 
+            new Dictionary<string, object> { {"force", force} }, request, HttpMethod.Patch, token);
+    }
 
-        public virtual async Task<IEnumerable<OnChainWalletUTXOData>> GetOnChainWalletUTXOs(string storeId,
-            string cryptoCode,
-            CancellationToken token = default)
-        {
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/utxos"), token);
-            return await HandleResponse<IEnumerable<OnChainWalletUTXOData>>(response);
-        }
+    public virtual async Task<IEnumerable<OnChainWalletUTXOData>> GetOnChainWalletUTXOs(string storeId,
+        string cryptoCode,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<IEnumerable<OnChainWalletUTXOData>>($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/utxos", null, HttpMethod.Get, token);
+    }
 
-        public virtual async Task<OnChainWalletTransactionData> CreateOnChainTransaction(string storeId,
-            string cryptoCode, CreateOnChainTransactionRequest request,
-            CancellationToken token = default)
+    public virtual async Task<OnChainWalletTransactionData> CreateOnChainTransaction(string storeId,
+        string cryptoCode, CreateOnChainTransactionRequest request,
+        CancellationToken token = default)
+    {
+        if (!request.ProceedWithBroadcast)
         {
-            if (!request.ProceedWithBroadcast)
-            {
-                throw new ArgumentOutOfRangeException(nameof(request.ProceedWithBroadcast),
-                    "Please use CreateOnChainTransactionButDoNotBroadcast when wanting to only create the transaction");
-            }
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions", null, request, HttpMethod.Post), token);
-            return await HandleResponse<OnChainWalletTransactionData>(response);
+            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);
+    }
 
-        public virtual async Task<Transaction> CreateOnChainTransactionButDoNotBroadcast(string storeId,
-            string cryptoCode, CreateOnChainTransactionRequest request, Network network,
-            CancellationToken token = default)
+    public virtual async Task<Transaction> CreateOnChainTransactionButDoNotBroadcast(string storeId,
+        string cryptoCode, CreateOnChainTransactionRequest request, Network network,
+        CancellationToken token = default)
+    {
+        if (request.ProceedWithBroadcast)
         {
-            if (request.ProceedWithBroadcast)
-            {
-                throw new ArgumentOutOfRangeException(nameof(request.ProceedWithBroadcast),
-                    "Please use CreateOnChainTransaction when wanting to also broadcast the transaction");
-            }
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/onchain/{cryptoCode}/wallet/transactions", null, request, HttpMethod.Post), token);
-            return Transaction.Parse(await HandleResponse<string>(response), network);
+            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);
     }
 }

BTCPayServer.Client/BTCPayServerClient.PaymentRequests.cs

@@ -5,72 +5,49 @@ using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
 {
-    public partial class BTCPayServerClient
+    public virtual async Task<IEnumerable<PaymentRequestData>> GetPaymentRequests(string storeId,
+        bool includeArchived = false,
+        CancellationToken token = default)
     {
-        public virtual async Task<IEnumerable<PaymentRequestData>> GetPaymentRequests(string storeId,
-            bool includeArchived = false,
-            CancellationToken token = default)
-        {
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-requests",
-                        new Dictionary<string, object>() { { nameof(includeArchived), includeArchived } }), token);
-            return await HandleResponse<IEnumerable<PaymentRequestData>>(response);
-        }
+        return await SendHttpRequest<IEnumerable<PaymentRequestData>>($"api/v1/stores/{storeId}/payment-requests",
+            new Dictionary<string, object> { { nameof(includeArchived), includeArchived } }, HttpMethod.Get, token);
+    }
 
-        public virtual async Task<PaymentRequestData> GetPaymentRequest(string storeId, string paymentRequestId,
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/payment-requests/{paymentRequestId}"), token);
-            return await HandleResponse<PaymentRequestData>(response);
-        }
+    public virtual async Task<PaymentRequestData> GetPaymentRequest(string storeId, string paymentRequestId,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<PaymentRequestData>($"api/v1/stores/{storeId}/payment-requests/{paymentRequestId}", null, HttpMethod.Get, token);
+    }
 
-        public virtual async Task ArchivePaymentRequest(string storeId, string paymentRequestId,
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/payment-requests/{paymentRequestId}",
-                    method: HttpMethod.Delete), token);
-            await HandleResponse(response);
-        }
+    public virtual async Task ArchivePaymentRequest(string storeId, string paymentRequestId,
+        CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{storeId}/payment-requests/{paymentRequestId}", null, HttpMethod.Delete, token);
+    }
 
-        public virtual async Task<Client.Models.InvoiceData> PayPaymentRequest(string storeId, string paymentRequestId, PayPaymentRequestRequest request, CancellationToken token = default)
-        {
-            if (request == null)
-                throw new ArgumentNullException(nameof(request));
-            if (storeId is null)
-                throw new ArgumentNullException(nameof(storeId));
-            if (paymentRequestId is null)
-                throw new ArgumentNullException(nameof(paymentRequestId));
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/payment-requests/{paymentRequestId}/pay", bodyPayload: request,
-                    method: HttpMethod.Post), token);
-            return await HandleResponse<Client.Models.InvoiceData>(response);
-        }
+    public virtual async Task<Client.Models.InvoiceData> PayPaymentRequest(string storeId, string paymentRequestId, PayPaymentRequestRequest request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        if (storeId is null) throw new ArgumentNullException(nameof(storeId));
+        if (paymentRequestId is null) throw new ArgumentNullException(nameof(paymentRequestId));
+        return await SendHttpRequest<InvoiceData>($"api/v1/stores/{storeId}/payment-requests/{paymentRequestId}/pay", request, HttpMethod.Post, token);
+    }
 
-        public virtual async Task<PaymentRequestData> CreatePaymentRequest(string storeId,
-            CreatePaymentRequestRequest request, CancellationToken token = default)
-        {
-            if (request == null)
-                throw new ArgumentNullException(nameof(request));
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/payment-requests", bodyPayload: request,
-                    method: HttpMethod.Post), token);
-            return await HandleResponse<PaymentRequestData>(response);
-        }
+    public virtual async Task<PaymentRequestData> CreatePaymentRequest(string storeId,
+        CreatePaymentRequestRequest request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<PaymentRequestData>($"api/v1/stores/{storeId}/payment-requests", request, HttpMethod.Post, token);
+    }
 
-        public virtual async Task<PaymentRequestData> UpdatePaymentRequest(string storeId, string paymentRequestId,
-            UpdatePaymentRequestRequest request, CancellationToken token = default)
-        {
-            if (request == null)
-                throw new ArgumentNullException(nameof(request));
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/payment-requests/{paymentRequestId}", bodyPayload: request,
-                    method: HttpMethod.Put), token);
-            return await HandleResponse<PaymentRequestData>(response);
-        }
+    public virtual async Task<PaymentRequestData> UpdatePaymentRequest(string storeId, string paymentRequestId,
+        UpdatePaymentRequestRequest request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<PaymentRequestData>($"api/v1/stores/{storeId}/payment-requests/{paymentRequestId}", request, HttpMethod.Put, token);
     }
 }

BTCPayServer.Client/BTCPayServerClient.PayoutProcessors.cs

@@ -1,18 +1,16 @@
 #nullable enable
 using System.Collections.Generic;
+using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
 {
-    public partial class BTCPayServerClient
+    public virtual async Task<IEnumerable<PayoutProcessorData>> GetPayoutProcessors(CancellationToken token = default)
     {
-        public virtual async Task<IEnumerable<PayoutProcessorData>> GetPayoutProcessors(
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest("api/v1/payout-processors"), token);
-            return await HandleResponse<IEnumerable<PayoutProcessorData>>(response);
-        }
+        return await SendHttpRequest<IEnumerable<PayoutProcessorData>>("api/v1/payout-processors", null, HttpMethod.Get, token);
     }
 }

BTCPayServer.Client/BTCPayServerClient.PullPayments.cs

@@ -5,107 +5,90 @@ using System.Threading.Tasks;
 using System.Web;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
 {
-    public partial class BTCPayServerClient
+    public virtual async Task<PullPaymentData> CreatePullPayment(string storeId, CreatePullPaymentRequest request, CancellationToken cancellationToken = default)
     {
-        public virtual async Task<PullPaymentData> CreatePullPayment(string storeId, CreatePullPaymentRequest request, CancellationToken cancellationToken = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/pull-payments", bodyPayload: request, method: HttpMethod.Post), cancellationToken);
-            return await HandleResponse<PullPaymentData>(response);
-        }
-        public virtual async Task<PullPaymentData> GetPullPayment(string pullPaymentId, CancellationToken cancellationToken = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}", method: HttpMethod.Get), cancellationToken);
-            return await HandleResponse<PullPaymentData>(response);
-        }
+        return await SendHttpRequest<PullPaymentData>($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/pull-payments", request, HttpMethod.Post, cancellationToken);
+    }
 
-        public virtual async Task<PullPaymentData[]> GetPullPayments(string storeId, bool includeArchived = false, CancellationToken cancellationToken = default)
-        {
-            Dictionary<string, object> query = new Dictionary<string, object>();
-            query.Add("includeArchived", includeArchived);
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/pull-payments", queryPayload: query, method: HttpMethod.Get), cancellationToken);
-            return await HandleResponse<PullPaymentData[]>(response);
-        }
+    public virtual async Task<PullPaymentData> GetPullPayment(string pullPaymentId, CancellationToken cancellationToken = default)
+    {
+        return await SendHttpRequest<PullPaymentData>($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}", null, HttpMethod.Get, cancellationToken);
+    }
 
-        public virtual async Task ArchivePullPayment(string storeId, string pullPaymentId, CancellationToken cancellationToken = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}", method: HttpMethod.Delete), cancellationToken);
-            await HandleResponse(response);
-        }
+    public virtual async Task<RegisterBoltcardResponse> RegisterBoltcard(string pullPaymentId, RegisterBoltcardRequest request, CancellationToken cancellationToken = default)
+    {
+        return await SendHttpRequest<RegisterBoltcardResponse>($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}/boltcards", request, HttpMethod.Post, cancellationToken);
+    }
 
-        public virtual async Task<PayoutData[]> GetPayouts(string pullPaymentId, bool includeCancelled = false, CancellationToken cancellationToken = default)
-        {
-            Dictionary<string, object> query = new Dictionary<string, object>();
-            query.Add("includeCancelled", includeCancelled);
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}/payouts", queryPayload: query, method: HttpMethod.Get), cancellationToken);
-            return await HandleResponse<PayoutData[]>(response);
-        }
-        public virtual async Task<PayoutData[]> GetStorePayouts(string storeId, bool includeCancelled = false, CancellationToken cancellationToken = default)
-        {
-            Dictionary<string, object> query = new Dictionary<string, object>();
-            query.Add("includeCancelled", includeCancelled);
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/payouts", queryPayload: query, method: HttpMethod.Get), cancellationToken);
-            return await HandleResponse<PayoutData[]>(response);
-        }
-        public virtual async Task<PayoutData> CreatePayout(string pullPaymentId, CreatePayoutRequest payoutRequest, CancellationToken cancellationToken = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}/payouts", bodyPayload: payoutRequest, method: HttpMethod.Post), cancellationToken);
-            return await HandleResponse<PayoutData>(response);
-        }
-        public virtual async Task<PayoutData> GetPullPaymentPayout(string pullPaymentId, string payoutId, CancellationToken cancellationToken = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}/payouts/{payoutId}", method: HttpMethod.Get), cancellationToken);
-            return await HandleResponse<PayoutData>(response);
-        }
-        public virtual async Task<PayoutData> GetStorePayout(string storeId, string payoutId, CancellationToken cancellationToken = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/payouts/{payoutId}", method: HttpMethod.Get), cancellationToken);
-            return await HandleResponse<PayoutData>(response);
-        }
-        public virtual async Task<PayoutData> CreatePayout(string storeId, CreatePayoutThroughStoreRequest payoutRequest, CancellationToken cancellationToken = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/payouts", bodyPayload: payoutRequest, method: HttpMethod.Post), cancellationToken);
-            return await HandleResponse<PayoutData>(response);
-        }
-        public virtual async Task CancelPayout(string storeId, string payoutId, CancellationToken cancellationToken = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/payouts/{HttpUtility.UrlEncode(payoutId)}", method: HttpMethod.Delete), cancellationToken);
-            await HandleResponse(response);
-        }
-        public virtual async Task<PayoutData> ApprovePayout(string storeId, string payoutId, ApprovePayoutRequest request, CancellationToken cancellationToken = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/payouts/{HttpUtility.UrlEncode(payoutId)}", bodyPayload: request, method: HttpMethod.Post), cancellationToken);
-            return await HandleResponse<PayoutData>(response);
-        }
+    public virtual async Task<PullPaymentData[]> GetPullPayments(string storeId, bool includeArchived = false, CancellationToken cancellationToken = default)
+    {
+        var query = new Dictionary<string, object> { { "includeArchived", includeArchived } };
+        return await SendHttpRequest<PullPaymentData[]>($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/pull-payments", query, HttpMethod.Get, cancellationToken);
+    }
 
-        public virtual async Task MarkPayoutPaid(string storeId, string payoutId,
-            CancellationToken cancellationToken = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest(
-                    $"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/payouts/{HttpUtility.UrlEncode(payoutId)}/mark-paid",
-                    method: HttpMethod.Post), cancellationToken);
-            await HandleResponse(response);
-        }
-        public virtual async Task MarkPayout(string storeId, string payoutId, MarkPayoutRequest request,
-            CancellationToken cancellationToken = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest(
-                    $"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/payouts/{HttpUtility.UrlEncode(payoutId)}/mark",
-                    method: HttpMethod.Post, bodyPayload: request), cancellationToken);
-            await HandleResponse(response);
-        }
+    public virtual async Task ArchivePullPayment(string storeId, string pullPaymentId, CancellationToken cancellationToken = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}", null, HttpMethod.Delete, cancellationToken);
+    }
 
-        public virtual async Task<PullPaymentLNURL> GetPullPaymentLNURL(string pullPaymentId,
-            CancellationToken cancellationToken = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest(
-                    $"/api/v1/pull-payments/{pullPaymentId}/lnurl",
-                    method: HttpMethod.Get), cancellationToken);
-            return await HandleResponse<PullPaymentLNURL>(response);
-        }
+    public virtual async Task<PayoutData[]> GetPayouts(string pullPaymentId, bool includeCancelled = false, CancellationToken cancellationToken = default)
+    {
+        var query = new Dictionary<string, object> { { "includeCancelled", includeCancelled } };
+        return await SendHttpRequest<PayoutData[]>($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}/payouts", query, HttpMethod.Get, cancellationToken);
+    }
+
+    public virtual async Task<PayoutData[]> GetStorePayouts(string storeId, bool includeCancelled = false, CancellationToken cancellationToken = default)
+    {
+        var query = new Dictionary<string, object> { { "includeCancelled", includeCancelled } };
+        return await SendHttpRequest<PayoutData[]>($"api/v1/stores/{storeId}/payouts", queryPayload: query, method: HttpMethod.Get, cancellationToken);
+    }
+
+    public virtual async Task<PayoutData> CreatePayout(string pullPaymentId, CreatePayoutRequest payoutRequest, CancellationToken cancellationToken = default)
+    {
+        return await SendHttpRequest<PayoutData>($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}/payouts", bodyPayload: payoutRequest, HttpMethod.Post, cancellationToken);
+    }
+
+    public virtual async Task<PayoutData> GetPullPaymentPayout(string pullPaymentId, string payoutId, CancellationToken cancellationToken = default)
+    {
+        return await SendHttpRequest<PayoutData>($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}/payouts/{payoutId}", null, HttpMethod.Get, cancellationToken);
+    }
+
+    public virtual async Task<PayoutData> GetStorePayout(string storeId, string payoutId, CancellationToken cancellationToken = default)
+    {
+        return await SendHttpRequest<PayoutData>($"api/v1/stores/{storeId}/payouts/{payoutId}", null, HttpMethod.Get, cancellationToken);
+    }
+
+    public virtual async Task<PayoutData> CreatePayout(string storeId, CreatePayoutThroughStoreRequest payoutRequest, CancellationToken cancellationToken = default)
+    {
+        return await SendHttpRequest<PayoutData>($"api/v1/stores/{storeId}/payouts", bodyPayload: payoutRequest, method: HttpMethod.Post, cancellationToken);
+    }
+
+    public virtual async Task CancelPayout(string storeId, string payoutId, CancellationToken cancellationToken = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/payouts/{HttpUtility.UrlEncode(payoutId)}", null, HttpMethod.Delete, cancellationToken);
+    }
+
+    public virtual async Task<PayoutData> ApprovePayout(string storeId, string payoutId, ApprovePayoutRequest request, CancellationToken cancellationToken = default)
+    {
+        return await SendHttpRequest<PayoutData>($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/payouts/{HttpUtility.UrlEncode(payoutId)}", request, HttpMethod.Post, cancellationToken);
+    }
+
+    public virtual async Task MarkPayoutPaid(string storeId, string payoutId, CancellationToken cancellationToken = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/payouts/{HttpUtility.UrlEncode(payoutId)}/mark-paid", null, HttpMethod.Post, cancellationToken);
+    }
+
+    public virtual async Task MarkPayout(string storeId, string payoutId, MarkPayoutRequest request, CancellationToken cancellationToken = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/payouts/{HttpUtility.UrlEncode(payoutId)}/mark", request, HttpMethod.Post, cancellationToken);
+    }
+
+    public virtual async Task<PullPaymentLNURL> GetPullPaymentLNURL(string pullPaymentId, CancellationToken cancellationToken = default)
+    {
+        return await SendHttpRequest<PullPaymentLNURL>($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}/lnurl", null, HttpMethod.Get, cancellationToken);
     }
 }

BTCPayServer.Client/BTCPayServerClient.ServerInfo.cs

@@ -1,22 +1,20 @@
 using System.Collections.Generic;
+using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
 {
-    public partial class BTCPayServerClient
+    public virtual async Task<ServerInfoData> GetServerInfo(CancellationToken token = default)
     {
-        public virtual async Task<ServerInfoData> GetServerInfo(CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest("api/v1/server/info"), token);
-            return await HandleResponse<ServerInfoData>(response);
-        }
+        return await SendHttpRequest<ServerInfoData>("api/v1/server/info", null, HttpMethod.Get, token);
+    }
         
-        public virtual async Task<List<RoleData>> GetServerRoles(CancellationToken token = default)
-        {
-            using var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/server/roles"), token);
-            return await HandleResponse<List<RoleData>>(response);
-        }
+    public virtual async Task<List<RoleData>> GetServerRoles(CancellationToken token = default)
+    {
+        return await SendHttpRequest<List<RoleData>>("api/v1/server/roles", null, HttpMethod.Get, token);
     }
 }

BTCPayServer.Client/BTCPayServerClient.StoreEmail.cs

@@ -3,35 +3,22 @@ using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
 {
-    public partial class BTCPayServerClient
+    public virtual async Task<EmailSettingsData> GetStoreEmailSettings(string storeId, CancellationToken token = default)
     {
-        public virtual async Task<EmailSettingsData> GetStoreEmailSettings(string storeId,
-            CancellationToken token = default)
-        {
-            using var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/email", method: HttpMethod.Get),
-                token);
-            return await HandleResponse<EmailSettingsData>(response);
-        }
+        return await SendHttpRequest<EmailSettingsData>($"api/v1/stores/{storeId}/email", null, HttpMethod.Get, token);
+    }
 
-        public virtual async Task<EmailSettingsData> UpdateStoreEmailSettings(string storeId, EmailSettingsData request,
-            CancellationToken token = default)
-        {
-            using var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/email", bodyPayload: request, method: HttpMethod.Put),
-                token);
-            return await HandleResponse<EmailSettingsData>(response);
-        }
+    public virtual async Task<EmailSettingsData> UpdateStoreEmailSettings(string storeId, EmailSettingsData request, CancellationToken token = default)
+    {
+        return await SendHttpRequest<EmailSettingsData>($"api/v1/stores/{storeId}/email", request, method: HttpMethod.Put, token);
+    }
 
-        public virtual async Task SendEmail(string storeId, SendEmailRequest request,
-            CancellationToken token = default)
-        {
-            using var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/email/send", bodyPayload: request, method: HttpMethod.Post),
-                token);
-            await HandleResponse(response);
-        }
+    public virtual async Task SendEmail(string storeId, SendEmailRequest request, CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{storeId}/email/send", request, HttpMethod.Post, token);
     }
 }

BTCPayServer.Client/BTCPayServerClient.StorePaymentMethods.cs

@@ -1,27 +1,45 @@
 using System.Collections.Generic;
+using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client
-{
-    public partial class BTCPayServerClient
-    {
-        public virtual async Task<Dictionary<string, GenericPaymentMethodData>> GetStorePaymentMethods(string storeId,
-            bool? enabled = null,
-            CancellationToken token = default)
-        {
-            var query = new Dictionary<string, object>();
-            if (enabled != null)
-            {
-                query.Add(nameof(enabled), enabled);
-            }
+namespace BTCPayServer.Client;
 
-            var response =
-                await _httpClient.SendAsync(
-                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods",
-                        query), token);
-            return await HandleResponse<Dictionary<string, GenericPaymentMethodData>>(response);
+public partial class BTCPayServerClient
+{
+    public virtual async Task<GenericPaymentMethodData> UpdateStorePaymentMethod(string storeId, string paymentMethodId, UpdatePaymentMethodRequest request, CancellationToken token = default)
+    {
+        return await SendHttpRequest<GenericPaymentMethodData>($"api/v1/stores/{storeId}/payment-methods/{paymentMethodId}", request, HttpMethod.Put, token);
+    }
+
+    public virtual async Task RemoveStorePaymentMethod(string storeId, string paymentMethodId)
+    {
+        await SendHttpRequest($"api/v1/stores/{storeId}/payment-methods/{paymentMethodId}", null, HttpMethod.Delete, CancellationToken.None);
+    }
+
+    public virtual async Task<GenericPaymentMethodData> GetStorePaymentMethod(string storeId, string paymentMethodId, bool? includeConfig = null, CancellationToken token = default)
+    {
+        var query = new Dictionary<string, object>();
+        if (includeConfig != null)
+        {
+            query.Add(nameof(includeConfig), includeConfig);
         }
+        return await SendHttpRequest<GenericPaymentMethodData>($"api/v1/stores/{storeId}/payment-methods/{paymentMethodId}", query, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<GenericPaymentMethodData[]> GetStorePaymentMethods(string storeId, bool? onlyEnabled = null, bool? includeConfig = null, CancellationToken token = default)
+    {
+        var query = new Dictionary<string, object>();
+        if (onlyEnabled != null)
+        {
+            query.Add(nameof(onlyEnabled), onlyEnabled);
+        }
+        if (includeConfig != null)
+        {
+            query.Add(nameof(includeConfig), includeConfig);
+        }
+
+        return await SendHttpRequest<GenericPaymentMethodData[]>($"api/v1/stores/{storeId}/payment-methods", query, HttpMethod.Get, token);
     }
 }

BTCPayServer.Client/BTCPayServerClient.StorePayoutProcessors.cs

@@ -5,44 +5,37 @@ using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
 {
-    public partial class BTCPayServerClient
+    public virtual async Task<IEnumerable<PayoutProcessorData>> GetPayoutProcessors(string storeId, CancellationToken token = default)
     {
-        public virtual async Task<IEnumerable<PayoutProcessorData>> GetPayoutProcessors(string storeId,
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/payout-processors"), token);
-            return await HandleResponse<IEnumerable<PayoutProcessorData>>(response);
-        }
-        public virtual async Task RemovePayoutProcessor(string storeId, string processor, string paymentMethod, CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/payout-processors/{processor}/{paymentMethod}", null, HttpMethod.Delete), token);
-            await HandleResponse(response);
-        }
+        return await SendHttpRequest<IEnumerable<PayoutProcessorData>>($"api/v1/stores/{storeId}/payout-processors", null, HttpMethod.Get, token);
+    }
 
-        public virtual async Task<IEnumerable<LightningAutomatedPayoutSettings>> GetStoreLightningAutomatedPayoutProcessors(string storeId, string? paymentMethod = null,
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/payout-processors/LightningAutomatedPayoutSenderFactory{(paymentMethod is null ? string.Empty : $"/{paymentMethod}")}"), token);
-            return await HandleResponse<IEnumerable<LightningAutomatedPayoutSettings>>(response);
-        }
-        public virtual async Task<LightningAutomatedPayoutSettings> UpdateStoreLightningAutomatedPayoutProcessors(string storeId, string paymentMethod, LightningAutomatedPayoutSettings request, CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/payout-processors/LightningAutomatedPayoutSenderFactory/{paymentMethod}", null, request, HttpMethod.Put), token);
-            return await HandleResponse<LightningAutomatedPayoutSettings>(response);
-        }
-        public virtual async Task<OnChainAutomatedPayoutSettings> UpdateStoreOnChainAutomatedPayoutProcessors(string storeId, string paymentMethod, OnChainAutomatedPayoutSettings request, CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/payout-processors/OnChainAutomatedPayoutSenderFactory/{paymentMethod}", null, request, HttpMethod.Put), token);
-            return await HandleResponse<OnChainAutomatedPayoutSettings>(response);
-        }
+    public virtual async Task RemovePayoutProcessor(string storeId, string processor, string paymentMethod, CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{storeId}/payout-processors/{processor}/{paymentMethod}", null, HttpMethod.Delete, token);
+    }
 
-        public virtual async Task<IEnumerable<OnChainAutomatedPayoutSettings>> GetStoreOnChainAutomatedPayoutProcessors(string storeId, string? paymentMethod = null,
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/payout-processors/OnChainAutomatedPayoutSenderFactory{(paymentMethod is null ? string.Empty : $"/{paymentMethod}")}"), token);
-            return await HandleResponse<IEnumerable<OnChainAutomatedPayoutSettings>>(response);
-        }
+    public virtual async Task<IEnumerable<LightningAutomatedPayoutSettings>> GetStoreLightningAutomatedPayoutProcessors(string storeId, string? paymentMethod = 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);
+    }
+
+    public virtual async Task<LightningAutomatedPayoutSettings> UpdateStoreLightningAutomatedPayoutProcessors(string storeId, string paymentMethod, LightningAutomatedPayoutSettings request, CancellationToken token = default)
+    {
+        return await SendHttpRequest<LightningAutomatedPayoutSettings>($"api/v1/stores/{storeId}/payout-processors/LightningAutomatedPayoutSenderFactory/{paymentMethod}", request, HttpMethod.Put, token);
+    }
+
+    public virtual async Task<OnChainAutomatedPayoutSettings> UpdateStoreOnChainAutomatedPayoutProcessors(string storeId, string paymentMethod, OnChainAutomatedPayoutSettings request, CancellationToken token = default)
+    {
+        return await SendHttpRequest<OnChainAutomatedPayoutSettings>($"api/v1/stores/{storeId}/payout-processors/OnChainAutomatedPayoutSenderFactory/{paymentMethod}", request, HttpMethod.Put, token);
+    }
+
+    public virtual async Task<IEnumerable<OnChainAutomatedPayoutSettings>> GetStoreOnChainAutomatedPayoutProcessors(string storeId, string? paymentMethod = null, CancellationToken token = default)
+    {
+        return await SendHttpRequest<IEnumerable<OnChainAutomatedPayoutSettings>>($"api/v1/stores/{storeId}/payout-processors/OnChainAutomatedPayoutSenderFactory{(paymentMethod is null ? string.Empty : $"/{paymentMethod}")}", null, HttpMethod.Get, token);
     }
 }

BTCPayServer.Client/BTCPayServerClient.StoreRatesConfiguration.cs

@@ -4,61 +4,34 @@ using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
 {
-    public partial class BTCPayServerClient
+    public virtual async Task<StoreRateConfiguration> GetStoreRateConfiguration(string storeId, CancellationToken token = default)
     {
-        public virtual async Task<StoreRateConfiguration> GetStoreRateConfiguration(string storeId,
-            CancellationToken token = default)
-        {
-            using var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/rates/configuration", method: HttpMethod.Get),
-                token);
-            return await HandleResponse<StoreRateConfiguration>(response);
-        }
+        return await SendHttpRequest<StoreRateConfiguration>($"api/v1/stores/{storeId}/rates/configuration", null, HttpMethod.Get, token);
+    }
 
-        public virtual async Task<List<RateSource>> GetRateSources(
-            CancellationToken token = default)
-        {
-            using var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"misc/rate-sources", method: HttpMethod.Get),
-                token);
-            return await HandleResponse<List<RateSource>>(response);
-        }
+    public virtual async Task<List<RateSource>> GetRateSources(CancellationToken token = default)
+    {
+        return await SendHttpRequest<List<RateSource>>("misc/rate-sources", null, HttpMethod.Get, token);
+    }
 
-        public virtual async Task<StoreRateConfiguration> UpdateStoreRateConfiguration(string storeId,
-            StoreRateConfiguration request,
-            CancellationToken token = default)
-        {
-            using var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/rates/configuration", bodyPayload: request,
-                    method: HttpMethod.Put),
-                token);
-            return await HandleResponse<StoreRateConfiguration>(response);
-        }
+    public virtual async Task<StoreRateConfiguration> UpdateStoreRateConfiguration(string storeId, StoreRateConfiguration request, CancellationToken token = default)
+    {
+        return await SendHttpRequest<StoreRateConfiguration>($"api/v1/stores/{storeId}/rates/configuration", request, HttpMethod.Put, token);
+    }
 
-        public virtual async Task<List<StoreRateResult>> PreviewUpdateStoreRateConfiguration(string storeId,
-            StoreRateConfiguration request,
-            string[] currencyPair,
-            CancellationToken token = default)
-        {
-            using var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/rates/configuration/preview", bodyPayload: request,
-                    queryPayload: new Dictionary<string, object>() { { "currencyPair", currencyPair } },
-                    method: HttpMethod.Post),
-                token);
-            return await HandleResponse<List<StoreRateResult>>(response);
-        }
+    public virtual async Task<List<StoreRateResult>> PreviewUpdateStoreRateConfiguration(string storeId, StoreRateConfiguration request, string[] currencyPair = null, CancellationToken token = default)
+    {
+        var queryPayload = currencyPair == null ? null : new Dictionary<string, object> { { "currencyPair", currencyPair } };
+        return await SendHttpRequest<StoreRateConfiguration, List<StoreRateResult>>($"api/v1/stores/{storeId}/rates/configuration/preview", queryPayload, request, HttpMethod.Post, token);
+    }
 
-        public virtual async Task<List<StoreRateResult>> GetStoreRates(string storeId, string[] currencyPair,
-            CancellationToken token = default)
-        {
-            using var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/rates",
-                    queryPayload: new Dictionary<string, object>() { { "currencyPair", currencyPair } },
-                    method: HttpMethod.Get),
-                token);
-            return await HandleResponse<List<StoreRateResult>>(response);
-        }
+    public virtual async Task<List<StoreRateResult>> GetStoreRates(string storeId, string[] currencyPair = null, CancellationToken token = default)
+    {
+        var queryPayload = currencyPair == null ? null : new Dictionary<string, object> { { "currencyPair", currencyPair } };
+        return await SendHttpRequest<List<StoreRateResult>>($"api/v1/stores/{storeId}/rates", queryPayload, HttpMethod.Get, token);
     }
 }

BTCPayServer.Client/BTCPayServerClient.StoreUsers.cs

@@ -5,40 +5,28 @@ using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
 {
-    public partial class BTCPayServerClient
+    public virtual async Task<List<RoleData>> GetStoreRoles(string storeId, CancellationToken token = default)
     {
-        public virtual async Task<List<RoleData>> GetStoreRoles(string storeId,
-            CancellationToken token = default)
-        {
-            using var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/roles"), token);
-            return await HandleResponse<List<RoleData>>(response);
-        }
+        return await SendHttpRequest<List<RoleData>>($"api/v1/stores/{storeId}/roles", null,  HttpMethod.Get,token);
+    }
         
-        public virtual async Task<IEnumerable<StoreUserData>> GetStoreUsers(string storeId,
-            CancellationToken token = default)
-        {
-            using var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/users"), token);
-            return await HandleResponse<IEnumerable<StoreUserData>>(response);
-        }
+    public virtual async Task<IEnumerable<StoreUserData>> GetStoreUsers(string storeId, CancellationToken token = default)
+    {
+        return await SendHttpRequest<IEnumerable<StoreUserData>>($"api/v1/stores/{storeId}/users", null, HttpMethod.Get, token);
+    }
 
-        public virtual async Task RemoveStoreUser(string storeId, string userId, CancellationToken token = default)
-        {
-            using var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/users/{userId}", method: HttpMethod.Delete), token);
-            await HandleResponse(response);
-        }
+    public virtual async Task RemoveStoreUser(string storeId, string userId, CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{storeId}/users/{userId}", null, HttpMethod.Delete, token);
+    }
 
-        public virtual async Task AddStoreUser(string storeId, StoreUserData request,
-            CancellationToken token = default)
-        {
-            if (request == null)
-                throw new ArgumentNullException(nameof(request));
-            using var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}/users", bodyPayload: request, method: HttpMethod.Post),
-                token);
-            await HandleResponse(response);
-        }
+    public virtual async Task AddStoreUser(string storeId, StoreUserData request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        await SendHttpRequest<StoreUserData>($"api/v1/stores/{storeId}/users", request, HttpMethod.Post, token);
     }
 }

BTCPayServer.Client/BTCPayServerClient.Stores.cs

@@ -5,47 +5,45 @@ using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
 {
-    public partial class BTCPayServerClient
+    public virtual async Task<IEnumerable<StoreData>> GetStores(CancellationToken token = default)
     {
-        public virtual async Task<IEnumerable<StoreData>> GetStores(CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest("api/v1/stores"), token);
-            return await HandleResponse<IEnumerable<StoreData>>(response);
-        }
+        return await SendHttpRequest<IEnumerable<StoreData>>("api/v1/stores", null, HttpMethod.Get, token);
+    }
 
-        public virtual async Task<StoreData> GetStore(string storeId, CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}"), token);
-            return await HandleResponse<StoreData>(response);
-        }
+    public virtual async Task<StoreData> GetStore(string storeId, CancellationToken token = default)
+    {
+        return await SendHttpRequest<StoreData>($"api/v1/stores/{storeId}", null, HttpMethod.Get, token);
+    }
 
-        public virtual async Task RemoveStore(string storeId, CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(
-                CreateHttpRequest($"api/v1/stores/{storeId}", method: HttpMethod.Delete), token);
-            await HandleResponse(response);
-        }
+    public virtual async Task RemoveStore(string storeId, CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{storeId}", null, HttpMethod.Delete, token);
+    }
 
-        public virtual async Task<StoreData> CreateStore(CreateStoreRequest request, CancellationToken token = default)
-        {
-            if (request == null)
-                throw new ArgumentNullException(nameof(request));
-            var response = await _httpClient.SendAsync(CreateHttpRequest("api/v1/stores", bodyPayload: request, method: HttpMethod.Post), token);
-            return await HandleResponse<StoreData>(response);
-        }
+    public virtual async Task<StoreData> CreateStore(CreateStoreRequest request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<StoreData>("api/v1/stores", request, HttpMethod.Post, token);
+    }
 
-        public virtual async Task<StoreData> UpdateStore(string storeId, UpdateStoreRequest request, CancellationToken token = default)
-        {
-            if (request == null)
-                throw new ArgumentNullException(nameof(request));
-            if (storeId == null)
-                throw new ArgumentNullException(nameof(storeId));
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}", bodyPayload: request, method: HttpMethod.Put), token);
-            return await HandleResponse<StoreData>(response);
-        }
+    public virtual async Task<StoreData> UpdateStore(string storeId, UpdateStoreRequest request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        if (storeId == null) throw new ArgumentNullException(nameof(storeId));
+        return await SendHttpRequest<StoreData>($"api/v1/stores/{storeId}", request, HttpMethod.Put, token);
+    }
 
+    public virtual async Task<StoreData> UploadStoreLogo(string storeId, string filePath, string mimeType, CancellationToken token = default)
+    {
+        return await UploadFileRequest<StoreData>($"api/v1/stores/{storeId}/logo", filePath, mimeType, "file", HttpMethod.Post, token);
+    }
+
+    public virtual async Task DeleteStoreLogo(string storeId, CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{storeId}/logo", null, HttpMethod.Delete, token);
     }
 }

BTCPayServer.Client/BTCPayServerClient.Users.cs

@@ -4,52 +4,68 @@ using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
 {
-    public partial class BTCPayServerClient
+    public virtual async Task<ApplicationUserData> GetCurrentUser(CancellationToken token = default)
     {
-        public virtual async Task<ApplicationUserData> GetCurrentUser(CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest("api/v1/users/me"), token);
-            return await HandleResponse<ApplicationUserData>(response);
-        }
+        return await SendHttpRequest<ApplicationUserData>("api/v1/users/me", null, HttpMethod.Get, token);
+    }
 
-        public virtual async Task<ApplicationUserData> CreateUser(CreateApplicationUserRequest request,
-            CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest("api/v1/users", null, request, HttpMethod.Post), token);
-            return await HandleResponse<ApplicationUserData>(response);
-        }
+    public virtual async Task<ApplicationUserData> UpdateCurrentUser(UpdateApplicationUserRequest request, CancellationToken token = default)
+    {
+        return await SendHttpRequest<ApplicationUserData>("api/v1/users/me", request, HttpMethod.Put, token);
+    }
 
-        public virtual async Task DeleteUser(string userId, CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/users/{userId}", null, HttpMethod.Delete), token);
-            await HandleResponse(response);
-        }
+    public virtual async Task<ApplicationUserData> UploadCurrentUserProfilePicture(string filePath, string mimeType, CancellationToken token = default)
+    {
+        return await UploadFileRequest<ApplicationUserData>("api/v1/users/me/picture", filePath, mimeType, "file", HttpMethod.Post, token);
+    }
 
-        public virtual async Task<ApplicationUserData> GetUserByIdOrEmail(string idOrEmail, CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/users/{idOrEmail}", null, HttpMethod.Get), token);
-            return await HandleResponse<ApplicationUserData>(response);
-        }
+    public virtual async Task DeleteCurrentUserProfilePicture(CancellationToken token = default)
+    {
+        await SendHttpRequest("api/v1/users/me/picture", null, HttpMethod.Delete, token);
+    }
+    
+    public virtual async Task<ApplicationUserData> CreateUser(CreateApplicationUserRequest request, CancellationToken token = default)
+    {
+        return await SendHttpRequest<ApplicationUserData>("api/v1/users", request, HttpMethod.Post, token);
+    }
 
-        public virtual async Task<bool> LockUser(string idOrEmail, bool locked, CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/users/{idOrEmail}/lock", null,
-                new LockUserRequest { Locked = locked }, HttpMethod.Post), token);
-            await HandleResponse(response);
-            return response.IsSuccessStatusCode;
-        }
+    public virtual async Task DeleteUser(string userId, CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/users/{userId}", null, HttpMethod.Delete, token);
+    }
 
-        public virtual async Task<ApplicationUserData[]> GetUsers(CancellationToken token = default)
-        {
-            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/users/", null, HttpMethod.Get), token);
-            return await HandleResponse<ApplicationUserData[]>(response);
-        }
+    public virtual async Task<ApplicationUserData> GetUserByIdOrEmail(string idOrEmail, CancellationToken token = default)
+    {
+        return await SendHttpRequest<ApplicationUserData>($"api/v1/users/{idOrEmail}", null, HttpMethod.Get, token);
+    }
 
-        public virtual async Task DeleteCurrentUser(CancellationToken token = default)
-        {
-            await DeleteUser("me", token);
-        }
+    public virtual async Task<bool> LockUser(string idOrEmail, bool locked, CancellationToken token = default)
+    {
+        var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/users/{idOrEmail}/lock", null,
+            new LockUserRequest { Locked = locked }, HttpMethod.Post), token);
+        await HandleResponse(response);
+        return response.IsSuccessStatusCode;
+    }
+
+    public virtual async Task<bool> ApproveUser(string idOrEmail, bool approved, CancellationToken token = default)
+    {
+        var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/users/{idOrEmail}/approve", null,
+            new ApproveUserRequest { Approved = approved }, HttpMethod.Post), token);
+        await HandleResponse(response);
+        return response.IsSuccessStatusCode;
+    }
+
+    public virtual async Task<ApplicationUserData[]> GetUsers(CancellationToken token = default)
+    {
+        return await SendHttpRequest<ApplicationUserData[]>("api/v1/users/", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task DeleteCurrentUser(CancellationToken token = default)
+    {
+        await DeleteUser("me", token);
     }
 }

BTCPayServer.Client/BTCPayServerClient.Webhooks.cs

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

BTCPayServer.Client/BTCPayServerClient.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Net.Http;
 using System.Net.Http.Headers;
@@ -9,154 +10,192 @@ using System.Threading;
 using System.Threading.Tasks;
 using Newtonsoft.Json;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
 {
-    public partial class BTCPayServerClient
+    private readonly string _apiKey;
+    private readonly Uri _btcpayHost;
+    private readonly string _username;
+    private readonly string _password;
+    protected readonly HttpClient _httpClient;
+    public Uri Host => _btcpayHost;
+
+    public string APIKey => _apiKey;
+
+    public BTCPayServerClient(Uri btcpayHost, HttpClient httpClient = null)
     {
-        private readonly string _apiKey;
-        private readonly Uri _btcpayHost;
-        private readonly string _username;
-        private readonly string _password;
-        private readonly HttpClient _httpClient;
-        public Uri Host => _btcpayHost;
+        if (btcpayHost == null) throw new ArgumentNullException(nameof(btcpayHost));
+        _btcpayHost = btcpayHost;
+        _httpClient = httpClient ?? new HttpClient();
+    }
 
-        public string APIKey => _apiKey;
+    public BTCPayServerClient(Uri btcpayHost, string APIKey, HttpClient httpClient = null)
+    {
+        _apiKey = APIKey;
+        _btcpayHost = btcpayHost;
+        _httpClient = httpClient ?? new HttpClient();
+    }
 
-        public BTCPayServerClient(Uri btcpayHost, HttpClient httpClient = null)
-        {
-            if (btcpayHost == null)
-                throw new ArgumentNullException(nameof(btcpayHost));
-            _btcpayHost = btcpayHost;
-            _httpClient = httpClient ?? new HttpClient();
-        }
-        public BTCPayServerClient(Uri btcpayHost, string APIKey, HttpClient httpClient = null)
-        {
-            _apiKey = APIKey;
-            _btcpayHost = btcpayHost;
-            _httpClient = httpClient ?? new HttpClient();
-        }
+    public BTCPayServerClient(Uri btcpayHost, string username, string password, HttpClient httpClient = null)
+    {
+        _apiKey = APIKey;
+        _btcpayHost = btcpayHost;
+        _username = username;
+        _password = password;
+        _httpClient = httpClient ?? new HttpClient();
+    }
 
-        public BTCPayServerClient(Uri btcpayHost, string username, string password, HttpClient httpClient = null)
+    protected async Task HandleResponse(HttpResponseMessage message)
+    {
+        if (!message.IsSuccessStatusCode && message.Content?.Headers?.ContentType?.MediaType?.StartsWith("application/json", StringComparison.OrdinalIgnoreCase) is true)
         {
-            _apiKey = APIKey;
-            _btcpayHost = btcpayHost;
-            _username = username;
-            _password = password;
-            _httpClient = httpClient ?? new HttpClient();
-        }
-
-        protected async Task HandleResponse(HttpResponseMessage message)
-        {
-            if (!message.IsSuccessStatusCode && message.Content?.Headers?.ContentType?.MediaType?.StartsWith("application/json", StringComparison.OrdinalIgnoreCase) is true)
+            if (message.StatusCode == System.Net.HttpStatusCode.UnprocessableEntity)
             {
-                if (message.StatusCode == System.Net.HttpStatusCode.UnprocessableEntity)
-                {
-                    var aa = await message.Content.ReadAsStringAsync();
-                    var err = JsonConvert.DeserializeObject<Models.GreenfieldValidationError[]>(aa);
-                    throw new GreenfieldValidationException(err);
-                }
-                if (message.StatusCode == System.Net.HttpStatusCode.Forbidden)
-                {
-                    var err = JsonConvert.DeserializeObject<Models.GreenfieldPermissionAPIError>(await message.Content.ReadAsStringAsync());
-                    throw new GreenfieldAPIException((int)message.StatusCode, err);
-                }
-                else
-                {
-                    var err = JsonConvert.DeserializeObject<Models.GreenfieldAPIError>(await message.Content.ReadAsStringAsync());
-                    if (err.Code != null)
-                        throw new GreenfieldAPIException((int)message.StatusCode, err);
-                }
+                var aa = await message.Content.ReadAsStringAsync();
+                var err = JsonConvert.DeserializeObject<Models.GreenfieldValidationError[]>(aa);
+                throw new GreenfieldValidationException(err);
             }
-            message.EnsureSuccessStatusCode();
-        }
-
-        protected async Task<T> HandleResponse<T>(HttpResponseMessage message)
-        {
-            await HandleResponse(message);
-            var str = await message.Content.ReadAsStringAsync();
-            return JsonConvert.DeserializeObject<T>(str);
-        }
-
-        public async Task<T> SendHttpRequest<T>(string path,
-            Dictionary<string, object> queryPayload = null,
-            HttpMethod method = null, CancellationToken cancellationToken = default)
-        {
-            using var resp = await _httpClient.SendAsync(CreateHttpRequest(path, queryPayload, method), cancellationToken);
-            return await HandleResponse<T>(resp);
-        }
-        public async Task<T> SendHttpRequest<T>(string path,
-        object bodyPayload = null,
-        HttpMethod method = null, CancellationToken cancellationToken = default)
-        {
-            using var resp = await _httpClient.SendAsync(CreateHttpRequest(path: path, bodyPayload: bodyPayload, method: method), cancellationToken);
-            return await HandleResponse<T>(resp);
-        }
-        protected virtual HttpRequestMessage CreateHttpRequest(string path,
-            Dictionary<string, object> queryPayload = null,
-            HttpMethod method = null)
-        {
-            UriBuilder uriBuilder = new UriBuilder(_btcpayHost) { Path = path };
-            if (queryPayload != null && queryPayload.Any())
+            if (message.StatusCode == System.Net.HttpStatusCode.Forbidden)
             {
-                AppendPayloadToQuery(uriBuilder, queryPayload);
-            }
-
-            var httpRequest = new HttpRequestMessage(method ?? HttpMethod.Get, uriBuilder.Uri);
-            if (_apiKey != null)
-                httpRequest.Headers.Authorization = new AuthenticationHeaderValue("token", _apiKey);
-            else if (!string.IsNullOrEmpty(_username))
-            {
-                httpRequest.Headers.Authorization = new AuthenticationHeaderValue("Basic", System.Convert.ToBase64String(Encoding.ASCII.GetBytes(_username + ":" + _password)));
-            }
-
-
-            return httpRequest;
-        }
-
-        protected virtual HttpRequestMessage CreateHttpRequest<T>(string path,
-            Dictionary<string, object> queryPayload = null,
-            T bodyPayload = default, HttpMethod method = null)
-        {
-            var request = CreateHttpRequest(path, queryPayload, method);
-            if (typeof(T).IsPrimitive || !EqualityComparer<T>.Default.Equals(bodyPayload, default(T)))
-            {
-                request.Content = new StringContent(JsonConvert.SerializeObject(bodyPayload), Encoding.UTF8, "application/json");
-            }
-
-            return request;
-        }
-
-        public static void AppendPayloadToQuery(UriBuilder uri, KeyValuePair<string, object> keyValuePair)
-        {
-            if (uri.Query.Length > 1)
-                uri.Query += "&";
-
-            UriBuilder uriBuilder = uri;
-            if (!(keyValuePair.Value is string) &&
-                keyValuePair.Value.GetType().GetInterfaces().Contains((typeof(IEnumerable))))
-            {
-                foreach (var item in (IEnumerable)keyValuePair.Value)
-                {
-                    uriBuilder.Query = uriBuilder.Query + Uri.EscapeDataString(keyValuePair.Key) + "=" +
-                                       Uri.EscapeDataString(item.ToString()) + "&";
-                }
+                var err = JsonConvert.DeserializeObject<Models.GreenfieldPermissionAPIError>(await message.Content.ReadAsStringAsync());
+                throw new GreenfieldAPIException((int)message.StatusCode, err);
             }
             else
             {
-                uriBuilder.Query = uriBuilder.Query + Uri.EscapeDataString(keyValuePair.Key) + "=" +
-                                   Uri.EscapeDataString(keyValuePair.Value.ToString()) + "&";
+                var err = JsonConvert.DeserializeObject<Models.GreenfieldAPIError>(await message.Content.ReadAsStringAsync());
+                if (err.Code != null)
+                    throw new GreenfieldAPIException((int)message.StatusCode, err);
             }
-            uri.Query = uri.Query.Trim('&');
+        }
+        message.EnsureSuccessStatusCode();
+    }
+
+    protected virtual async Task<T> HandleResponse<T>(HttpResponseMessage message)
+    {
+        await HandleResponse(message);
+        var str = await message.Content.ReadAsStringAsync();
+        return JsonConvert.DeserializeObject<T>(str);
+    }
+
+    public virtual async Task SendHttpRequest(string path,
+        Dictionary<string, object> queryPayload = null,
+        HttpMethod method = null, CancellationToken cancellationToken = default)
+    {
+        using var resp = await _httpClient.SendAsync(CreateHttpRequest(path, queryPayload, method), cancellationToken);
+        await HandleResponse(resp);
+    }
+
+    public virtual async Task<T> SendHttpRequest<T>(string path,
+        Dictionary<string, object> queryPayload = null,
+        HttpMethod method = null, CancellationToken cancellationToken = default)
+    {
+        using var resp = await _httpClient.SendAsync(CreateHttpRequest(path, queryPayload, method), cancellationToken);
+        return await HandleResponse<T>(resp);
+    }
+
+    public virtual async Task SendHttpRequest(string path,
+        object bodyPayload = null,
+        HttpMethod method = null, CancellationToken cancellationToken = default)
+    {
+        using var resp = await _httpClient.SendAsync(CreateHttpRequest(path: path, bodyPayload: bodyPayload, method: method), cancellationToken);
+        await HandleResponse(resp);
+    }
+
+    protected virtual async Task<T> SendHttpRequest<T>(string path,
+        object bodyPayload = null,
+        HttpMethod method = null, CancellationToken cancellationToken = default)
+    {
+        using var resp = await _httpClient.SendAsync(CreateHttpRequest(path: path, bodyPayload: bodyPayload, method: method), cancellationToken);
+        return await HandleResponse<T>(resp);
+    }
+        
+    protected virtual async Task<TRes> SendHttpRequest<TReq, TRes>(string path,
+        Dictionary<string, object> queryPayload = null,
+        TReq bodyPayload = default, HttpMethod method = null, CancellationToken cancellationToken = default)
+    {
+        using var resp = await _httpClient.SendAsync(CreateHttpRequest(path: path, bodyPayload: bodyPayload, queryPayload: queryPayload, method: method), cancellationToken);
+        return await HandleResponse<TRes>(resp);
+    }
+
+    protected virtual HttpRequestMessage CreateHttpRequest(string path,
+        Dictionary<string, object> queryPayload = null,
+        HttpMethod method = null)
+    {
+        var uriBuilder = new UriBuilder(_btcpayHost);
+        uriBuilder.Path += (uriBuilder.Path.EndsWith("/") || path.StartsWith("/") ? "" : "/") + path;
+        if (queryPayload != null && queryPayload.Any())
+        {
+            AppendPayloadToQuery(uriBuilder, queryPayload);
         }
 
-        public static void AppendPayloadToQuery(UriBuilder uri, Dictionary<string, object> payload)
+        var httpRequest = new HttpRequestMessage(method ?? HttpMethod.Get, uriBuilder.Uri);
+        if (_apiKey != null)
+            httpRequest.Headers.Authorization = new AuthenticationHeaderValue("token", _apiKey);
+        else if (!string.IsNullOrEmpty(_username))
         {
-            if (uri.Query.Length > 1)
-                uri.Query += "&";
-            foreach (KeyValuePair<string, object> keyValuePair in payload)
+            httpRequest.Headers.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.ASCII.GetBytes(_username + ":" + _password)));
+        }
+
+        return httpRequest;
+    }
+
+    protected virtual HttpRequestMessage CreateHttpRequest<T>(string path,
+        Dictionary<string, object> queryPayload = null,
+        T bodyPayload = default, HttpMethod method = null)
+    {
+        var request = CreateHttpRequest(path, queryPayload, method);
+        if (typeof(T).IsPrimitive || !EqualityComparer<T>.Default.Equals(bodyPayload, default(T)))
+        {
+            request.Content = new StringContent(JsonConvert.SerializeObject(bodyPayload), Encoding.UTF8, "application/json");
+        }
+
+        return request;
+    }
+
+    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));
+        var fileName = Path.GetFileName(filePath);
+        fileContent.Headers.ContentType = MediaTypeHeaderValue.Parse(mimeType);
+        multipartContent.Add(fileContent, formFieldName, fileName);
+        var req = CreateHttpRequest(apiPath, null, method ?? HttpMethod.Post);
+        req.Content = multipartContent;
+        using var resp = await _httpClient.SendAsync(req, token);
+        return await HandleResponse<T>(resp);
+    }
+
+    public static void AppendPayloadToQuery(UriBuilder uri, KeyValuePair<string, object> keyValuePair)
+    {
+        if (uri.Query.Length > 1)
+            uri.Query += "&";
+
+        UriBuilder uriBuilder = uri;
+        if (!(keyValuePair.Value is string) &&
+            keyValuePair.Value.GetType().GetInterfaces().Contains((typeof(IEnumerable))))
+        {
+            foreach (var item in (IEnumerable)keyValuePair.Value)
             {
-                AppendPayloadToQuery(uri, keyValuePair);
+                uriBuilder.Query = uriBuilder.Query + Uri.EscapeDataString(keyValuePair.Key) + "=" +
+                                   Uri.EscapeDataString(item.ToString()) + "&";
             }
         }
+        else
+        {
+            uriBuilder.Query = uriBuilder.Query + Uri.EscapeDataString(keyValuePair.Key) + "=" +
+                               Uri.EscapeDataString(keyValuePair.Value.ToString()) + "&";
+        }
+        uri.Query = uri.Query.Trim('&');
+    }
+
+    public static void AppendPayloadToQuery(UriBuilder uri, Dictionary<string, object> payload)
+    {
+        if (uri.Query.Length > 1)
+            uri.Query += "&";
+        foreach (KeyValuePair<string, object> keyValuePair in payload)
+        {
+            AppendPayloadToQuery(uri, keyValuePair);
+        }
     }
 }

BTCPayServer.Client/GreenFieldAPIException.cs

@@ -1,17 +1,15 @@
 using System;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public class GreenfieldAPIException : Exception
 {
-    public class GreenfieldAPIException : Exception
+    public GreenfieldAPIException(int httpCode, Models.GreenfieldAPIError error) : base(error.Message)
     {
-        public GreenfieldAPIException(int httpCode, Models.GreenfieldAPIError error) : base(error.Message)
-        {
-            if (error == null)
-                throw new ArgumentNullException(nameof(error));
-            HttpCode = httpCode;
-            APIError = error;
-        }
-        public Models.GreenfieldAPIError APIError { get; }
-        public int HttpCode { get; set; }
+        if (error == null) throw new ArgumentNullException(nameof(error));
+        HttpCode = httpCode;
+        APIError = error;
     }
+    public Models.GreenfieldAPIError APIError { get; }
+    public int HttpCode { get; set; }
 }

BTCPayServer.Client/GreenFieldValidationException.cs

@@ -2,27 +2,25 @@ using System;
 using System.Text;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client
+namespace BTCPayServer.Client;
+
+public class GreenfieldValidationException : Exception
 {
-    public class GreenfieldValidationException : Exception
+    public GreenfieldValidationException(GreenfieldValidationError[] errors) : base(BuildMessage(errors))
     {
-        public GreenfieldValidationException(Models.GreenfieldValidationError[] errors) : base(BuildMessage(errors))
-        {
-            ValidationErrors = errors;
-        }
-
-        private static string BuildMessage(GreenfieldValidationError[] errors)
-        {
-            if (errors == null)
-                throw new ArgumentNullException(nameof(errors));
-            StringBuilder builder = new StringBuilder();
-            foreach (var error in errors)
-            {
-                builder.AppendLine($"{error.Path}: {error.Message}");
-            }
-            return builder.ToString();
-        }
-
-        public Models.GreenfieldValidationError[] ValidationErrors { get; }
+        ValidationErrors = errors;
     }
+
+    private static string BuildMessage(GreenfieldValidationError[] errors)
+    {
+        if (errors == null) throw new ArgumentNullException(nameof(errors));
+        var builder = new StringBuilder();
+        foreach (var error in errors)
+        {
+            builder.AppendLine($"{error.Path}: {error.Message}");
+        }
+        return builder.ToString();
+    }
+
+    public GreenfieldValidationError[] ValidationErrors { get; }
 }

BTCPayServer.Client/JsonConverters/SaneOutpointJsonConverter.cs

@@ -0,0 +1,43 @@
+using NBitcoin;
+using NBitcoin.DataEncoders;
+using NBitcoin.JsonConverters;
+using Newtonsoft.Json;
+using System;
+using System.IO;
+using System.Reflection;
+
+namespace BTCPayServer.Client.JsonConverters
+{
+    public class SaneOutpointJsonConverter : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+        {
+            return typeof(OutPoint).GetTypeInfo().IsAssignableFrom(objectType.GetTypeInfo());
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+                return null;
+
+            if (reader.TokenType != JsonToken.String)
+                throw new JsonObjectException($"Unexpected json token type, expected is {JsonToken.String} and actual is {reader.TokenType}", reader);
+            try
+            {
+                if (!OutPoint.TryParse((string)reader.Value, out var outpoint))
+                    throw new JsonObjectException("Invalid bitcoin object of type OutPoint", reader);
+                return outpoint;
+            }
+            catch (EndOfStreamException)
+            {
+            }
+            throw new JsonObjectException("Invalid bitcoin object of type OutPoint", reader);
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            if (value is { })
+                writer.WriteValue(value.ToString());
+        }
+    }
+}

BTCPayServer.Client/JsonConverters/TimeSpanJsonConverter.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Globalization;
 using NBitcoin.JsonConverters;
 using Newtonsoft.Json;
 
@@ -58,6 +59,8 @@ namespace BTCPayServer.Client.JsonConverters
                         return null;
                     return TimeSpan.Zero;
                 }
+                if (reader.TokenType == JsonToken.String && TimeSpan.TryParse(reader.Value?.ToString(), CultureInfo.InvariantCulture, out var res))
+                    return res;
                 if (reader.TokenType != JsonToken.Integer)
                     throw new JsonObjectException("Invalid timespan, expected integer", reader);
                 return ToTimespan((long)reader.Value);

BTCPayServer.Client/JsonConverters/TradeQuantityJsonConverter.cs

@@ -1,36 +0,0 @@
-using System;
-using System.Globalization;
-using BTCPayServer.Client.Models;
-using BTCPayServer.Lightning;
-using NBitcoin.JsonConverters;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-
-namespace BTCPayServer.Client.JsonConverters
-{
-    public class TradeQuantityJsonConverter : JsonConverter<TradeQuantity>
-    {
-        public override TradeQuantity ReadJson(JsonReader reader, Type objectType, TradeQuantity existingValue, bool hasExistingValue, JsonSerializer serializer)
-        {
-            JToken token = JToken.Load(reader);
-            switch (token.Type)
-            {
-                case JTokenType.Float:
-                case JTokenType.Integer:
-                case JTokenType.String:
-                    if (TradeQuantity.TryParse(token.ToString(), out var q))
-                        return q;
-                    break;
-                case JTokenType.Null:
-                    return null;
-            }
-            throw new JsonObjectException("Invalid TradeQuantity, expected string. Expected: \"1.50\" or \"50%\"", reader);
-        }
-
-        public override void WriteJson(JsonWriter writer, TradeQuantity value, JsonSerializer serializer)
-        {
-            if (value is not null)
-                writer.WriteValue(value.ToString());
-        }
-    }
-}

BTCPayServer.Client/Models/AppBaseData.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Client.Models;
+
+public class AppBaseData
+{
+    public string Id { get; set; }
+    public string AppType { get; set; }
+    public string AppName { get; set; }
+    public string StoreId { get; set; }
+    [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
+    public bool? Archived { get; set; }
+    [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+    public DateTimeOffset Created { get; set; }
+    [JsonExtensionData]
+    public IDictionary<string, JToken> AdditionalData { get; set; } = new Dictionary<string, JToken>();
+}
+
+public interface IAppRequest
+{
+    public string AppName { get; set; }
+}

BTCPayServer.Client/Models/ApplicationUserData.cs

@@ -14,6 +14,16 @@ namespace BTCPayServer.Client.Models
         /// 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; }
 
         /// <summary>
         /// Whether the user has verified their email
@@ -25,6 +35,16 @@ namespace BTCPayServer.Client.Models
         /// </summary>
         public bool RequiresEmailConfirmation { get; set; }
 
+        /// <summary>
+        /// Whether the user was approved by an admin
+        /// </summary>
+        public bool Approved { get; set; }
+
+        /// <summary>
+        /// whether the user needed approval on account creation
+        /// </summary>
+        public bool RequiresApproval { get; set; }
+
         /// <summary>
         /// the roles of the user
         /// </summary>

BTCPayServer.Client/Models/ApproveUserRequest.cs

@@ -0,0 +1,6 @@
+namespace BTCPayServer.Client;
+
+public class ApproveUserRequest
+{
+    public bool Approved { get; set; }
+}

BTCPayServer.Client/Models/CreateAppRequest.cs

@@ -1,86 +0,0 @@
-using System;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Converters;
-
-namespace BTCPayServer.Client.Models
-{
-    public enum PosViewType
-    {
-        Static,
-        Cart,
-        Light,
-        Print
-    }
-
-    public class CreateAppRequest
-    {
-        public string AppName { get; set; }
-        public string AppType { get; set; }
-    }
-
-    public class CreatePointOfSaleAppRequest : CreateAppRequest
-    {
-        public string Currency { get; set; } = null;
-        public string Title { get; set; } = null;
-        public string Description { get; set; } = null;
-        public string Template { get; set; } = null;
-        [JsonConverter(typeof(StringEnumConverter))]
-        public PosViewType DefaultView { get; set; }
-        public bool ShowCustomAmount { get; set; } = false;
-        public bool ShowDiscount { get; set; } = true;
-        public bool EnableTips { get; set; } = true;
-        public string CustomAmountPayButtonText { get; set; } = null;
-        public string FixedAmountPayButtonText { get; set; } = null;
-        public string TipText { get; set; } = null;
-        public string CustomCSSLink { get; set; } = null;
-        public string NotificationUrl { get; set; } = null;
-        public string RedirectUrl { get; set; } = null;
-        public bool? RedirectAutomatically { get; set; } = null;
-        public bool? RequiresRefundEmail { get; set; } = null;
-        public bool? Archived { get; set; } = null;
-        public string FormId { get; set; } = null;
-        public string EmbeddedCSS { get; set; } = null;
-        public CheckoutType? CheckoutType { get; set; } = null;
-    }
-
-    public enum CrowdfundResetEvery
-    {
-        Never,
-        Hour,
-        Day,
-        Month,
-        Year
-    }
-
-    public class CreateCrowdfundAppRequest : CreateAppRequest
-    {
-        public string Title { get; set; } = null;
-        public bool? Enabled { get; set; } = null;
-        public bool? EnforceTargetAmount { get; set; } = null;
-        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
-        public DateTimeOffset? StartDate { get; set; } = null;
-        public string TargetCurrency { get; set; } = null;
-        public string Description { get; set; } = null;
-        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
-        public DateTimeOffset? EndDate { get; set; } = null;
-        public decimal? TargetAmount { get; set; } = null;
-        public string CustomCSSLink { get; set; } = null;
-        public string MainImageUrl { get; set; } = null;
-        public string EmbeddedCSS { get; set; } = null;
-        public string NotificationUrl { get; set; } = null;
-        public string Tagline { get; set; } = null;
-        public string PerksTemplate { get; set; } = null;
-        public bool? SoundsEnabled { get; set; } = null;
-        public string DisqusShortname { get; set; } = null;
-        public bool? AnimationsEnabled { get; set; } = null;
-        public int? ResetEveryAmount { get; set; } = null;
-        [JsonConverter(typeof(StringEnumConverter))]
-        public CrowdfundResetEvery ResetEvery { get; set; } = CrowdfundResetEvery.Never;
-        public bool? DisplayPerksValue { get; set; } = null;
-        public bool? DisplayPerksRanking { get; set; } = null;
-        public bool? SortPerksByPopularity { get; set; } = null;
-        public bool? Archived { get; set; } = null;
-        public string[] Sounds { get; set; } = null;
-        public string[] AnimationColors { get; set; } = null;
-    }
-}

BTCPayServer.Client/Models/CreateApplicationUserRequest.cs

@@ -2,6 +2,16 @@ namespace BTCPayServer.Client.Models
 {
     public class CreateApplicationUserRequest
     {
+        /// <summary>
+        /// the name of the new user
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// the image url of the new user
+        /// </summary>
+        public string ImageUrl { get; set; }
+
         /// <summary>
         /// the email AND username of the new user
         /// </summary>

BTCPayServer.Client/Models/CreateCustodianAccountRequest.cs

@@ -1,12 +0,0 @@
-using Newtonsoft.Json.Linq;
-
-namespace BTCPayServer.Client.Models
-{
-    public class CreateCustodianAccountRequest
-    {
-        public string CustodianCode { get; set; }
-        public string Name { get; set; }
-
-        public JObject Config { get; set; }
-    }
-}

BTCPayServer.Client/Models/CreateOnChainTransactionRequest.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using BTCPayServer.Client.JsonConverters;
 using BTCPayServer.JsonConverters;
 using NBitcoin;
 using NBitcoin.JsonConverters;
@@ -21,7 +22,7 @@ namespace BTCPayServer.Client.Models
         public bool ProceedWithPayjoin { get; set; } = true;
         public bool ProceedWithBroadcast { get; set; } = true;
         public bool NoChange { get; set; } = false;
-        [JsonProperty(ItemConverterType = typeof(OutpointJsonConverter))]
+        [JsonProperty(ItemConverterType = typeof(SaneOutpointJsonConverter))]
         public List<OutPoint> SelectedInputs { get; set; } = null;
         public List<CreateOnChainTransactionRequestDestination> Destinations { get; set; }
         [JsonProperty("rbf")]

BTCPayServer.Client/Models/CreatePullPaymentRequest.cs

@@ -12,8 +12,6 @@ namespace BTCPayServer.Client.Models
         [JsonProperty(ItemConverterType = typeof(NumericStringJsonConverter))]
         public decimal Amount { get; set; }
         public string Currency { get; set; }
-        [JsonConverter(typeof(TimeSpanJsonConverter.Seconds))]
-        public TimeSpan? Period { get; set; }
         [JsonConverter(typeof(TimeSpanJsonConverter.Days))]
         [JsonProperty("BOLT11Expiration")]
         public TimeSpan? BOLT11Expiration { get; set; }

BTCPayServer.Client/Models/CrowdfundAppData.cs

@@ -0,0 +1,55 @@
+#nullable enable
+using System;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace BTCPayServer.Client.Models;
+
+public abstract class CrowdfundBaseData : AppBaseData
+{
+    public string? Title { get; set; }
+    public bool? Enabled { get; set; }
+    public bool? EnforceTargetAmount { get; set; }
+    [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+    public DateTimeOffset? StartDate { get; set; }
+    public string? TargetCurrency { get; set; }
+    public string? Description { get; set; }
+    [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+    public DateTimeOffset? EndDate { get; set; }
+    public decimal? TargetAmount { get; set; }
+    public string? MainImageUrl { get; set; }
+    public string? NotificationUrl { get; set; }
+    public string? Tagline { get; set; }
+    public bool? DisqusEnabled { get; set; }
+    public string? DisqusShortname { get; set; }
+    public bool? SoundsEnabled { get; set; }
+    public bool? AnimationsEnabled { get; set; }
+    public int? ResetEveryAmount { get; set; }
+    [JsonConverter(typeof(StringEnumConverter))]
+    public CrowdfundResetEvery? ResetEvery { get; set; }
+    public bool? DisplayPerksValue { get; set; }
+    public bool? DisplayPerksRanking { get; set; }
+    public bool? SortPerksByPopularity { get; set; }
+    public string[]? Sounds { get; set; }
+    public string[]? AnimationColors { get; set; }
+    public string? FormId { get; set; }
+}
+
+public class CrowdfundAppData : CrowdfundBaseData
+{
+    public object? Perks { get; set; }
+}
+
+public class CrowdfundAppRequest : CrowdfundBaseData, IAppRequest
+{
+    public string? PerksTemplate { get; set; }
+}
+
+public enum CrowdfundResetEvery
+{
+    Never,
+    Hour,
+    Day,
+    Month,
+    Year
+}

BTCPayServer.Client/Models/CustodianAccountBaseData.cs

@@ -1,16 +0,0 @@
-using Newtonsoft.Json.Linq;
-
-namespace BTCPayServer.Client.Models
-{
-    public abstract class CustodianAccountBaseData
-    {
-        public string CustodianCode { get; set; }
-
-        public string Name { get; set; }
-
-        public string StoreId { get; set; }
-
-        public JObject Config { get; set; }
-    }
-
-}