Introduce wallet object contagion

.circleci/config.yml

@@ -2,7 +2,7 @@ version: 2
 jobs:
   fast_tests:
     machine:
-      image: ubuntu-2004:2024.11.1
+      image: ubuntu-2004:202111-02
     steps:
       - checkout
       - run:
@@ -10,7 +10,7 @@ jobs:
             cd .circleci && ./run-tests.sh "Fast=Fast|ThirdParty=ThirdParty" && ./can-build.sh
   selenium_tests:
     machine:
-      image: ubuntu-2004:2024.11.1
+      image: ubuntu-2004:202111-02
     steps:
       - checkout
       - run:
@@ -18,7 +18,7 @@ jobs:
             cd .circleci && ./run-tests.sh "Selenium=Selenium"
   integration_tests:
     machine:
-      image: ubuntu-2004:2024.11.1
+      image: ubuntu-2004:202111-02
     steps:
       - checkout
       - run:
@@ -26,28 +26,84 @@ jobs:
             cd .circleci && ./run-tests.sh "Integration=Integration"
   trigger_docs_build:
     machine:
-      image: ubuntu-2004:2024.11.1
+      image: ubuntu-2004:202111-02
     steps:
       - 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
-  docker:
-    docker:
-      - image: cimg/base:stable
+  amd64:
+    machine:
+      image: ubuntu-2004:202111-02
     steps:
-      - setup_remote_docker
       - checkout
       - run:
           command: |
             LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
             GIT_COMMIT=$(git rev-parse HEAD)
             #
-            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 .
+            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
+
 workflows:
   version: 2
   build_and_test:
@@ -64,7 +120,7 @@ workflows:
             # only act on version tags
             tags:
               only: /(v[1-9]+(\.[0-9]+)*(-[a-z0-9-]+)?)|(v[a-z0-9-]+)/
-      - docker:
+      - amd64:
           filters:
             # ignore any commit on any branch by default
             branches:
@@ -74,3 +130,25 @@ 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-]+)/

.circleci/run-tests.sh

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

.editorconfig

@@ -11,14 +11,10 @@ insert_final_newline = true
 indent_style = space
 indent_size = 4
 charset = utf-8
-space_before_self_closing = true
 
 [*.json]
 indent_size = 2
 
-[swagger*.json]
-indent_size = 4
-
 # C# files
 [*.cs]
 # New line preferences
@@ -71,7 +67,7 @@ dotnet_naming_symbols.private_internal_fields.applicable_kinds = field
 dotnet_naming_symbols.private_internal_fields.applicable_accessibilities = private, internal
 
 dotnet_naming_style.camel_case_underscore_style.required_prefix = _
-dotnet_naming_style.camel_case_underscore_style.capitalization = camel_case
+dotnet_naming_style.camel_case_underscore_style.capitalization = camel_case 
 
 # Code style defaults
 dotnet_sort_system_directives_first = true

.github/ISSUE_TEMPLATE/config.yml

@@ -1,14 +1,8 @@
 blank_issues_enabled: true
 contact_links:
-  - name: 💡 Request a feature
-    url: https://github.com/btcpayserver/btcpayserver/discussions/categories/ideas-feature-requests
-    about: Submit a feature request or vote on ideas posted by others. Features with most upvotes become roadmap candidates
-  - name: 🧑‍💻 Ask a technical question
-    url: https://github.com/btcpayserver/btcpayserver/discussions/new?category=technical-support
-    about: If you're experiencing a technical problem post it to our community support forum
-  - name: 🔌 Report a problem with a plugin
-    url: https://github.com/btcpayserver/btcpayserver/discussions/new?category=plugins-integrations
-    about: Experiencing a problem with a third-party plugin? Post it here and we will tag their developers to assist
+  - name: 🚀 Discussions
+    url: https://github.com/btcpayserver/btcpayserver/discussions
+    about: Technical discussions, questions and feature requests
   - name: 📝 Official Documentation
     url: https://docs.btcpayserver.org
     about: Check our documentation for answers to common questions

.github/codeql/codeql-config.yml

@@ -1,2 +0,0 @@
-paths-ignore:
-  - 'BTCPayServer/wwwroot/vendor/**/*.js'

.github/workflows/codeql.yml

@@ -1,80 +0,0 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-#
-# ******** NOTE ********
-# We have attempted to detect the languages in your repository. Please check
-# the `language` matrix defined below to confirm you have the correct set of
-# supported CodeQL languages.
-#
-name: "CodeQL"
-
-on:
-# Allow running tests manually. Usefull if scan failure, or need to rescan before next scheduled date.
-  workflow_dispatch:
-# We scan only on a schedule for now, can uncomment the following to scan on commit or PR merge later on if deemed appropriate.
-  # push:
-  #  branches: [ "master" ]
-  # pull_request:
-  #   branches: [ "master" ]
-  schedule:
-  # Scan every Monday 06:00 UTC.
-    - cron: '0 6 * * 1'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'javascript', 'csharp' ]
-        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
-        # Use only 'java' to analyze code written in Java, Kotlin or both
-        # Use only 'javascript' to analyze code written in JavaScript, TypeScript or both
-        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v3
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v2
-      with:
-        languages: ${{ matrix.language }}
-        config-file: ./.github/codeql/codeql-config.yml
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-
-        # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
-        # queries: security-extended,security-and-quality
-
-
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, Go, or Java).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v2
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
-
-    #   If the Autobuild fails above, remove it and uncomment the following three lines.
-    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
-
-    # - run: |
-    #     echo "Run, Build Application using script"
-    #     ./location_of_script_within_repo/buildscript.sh
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2
-      with:
-        category: "/language:${{matrix.language}}"

.gitignore

@@ -266,7 +266,6 @@ paket-files/
 # JetBrains Rider
 .idea/
 *.sln.iml
-.run
 
 # CodeRush
 .cr/
@@ -299,6 +298,3 @@ Packed Plugins
 Plugins/packed
 
 BTCPayServer/wwwroot/swagger/v1/openapi.json
-BTCPayServer/appsettings.dev.json
-BTCPayServer.Tests/monero_wallet
-/BTCPayServer.Tests/NewBlocks.bat

.run/Pack Test Extension.run.xml

@@ -0,0 +1,21 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Pack Test Plugin" type="DotNetProject" factoryName=".NET Project" singleton="false">
+    <option name="EXE_PATH" value="$PROJECT_DIR$/BTCPayServer.PluginPacker/bin/Debug/netcoreapp3.1/BTCPayServer.PluginPacker.dll" />
+    <option name="PROGRAM_PARAMETERS" value="../../../../BTCPayServer.Plugins.Test\bin\Debug\netcoreapp3.1 BTCPayServer.Plugins.Test &quot;../../../../Packed Plugins&quot;" />
+    <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/BTCPayServer.PluginPacker/bin/Debug/netcoreapp3.1" />
+    <option name="PASS_PARENT_ENVS" value="1" />
+    <option name="USE_EXTERNAL_CONSOLE" value="0" />
+    <option name="USE_MONO" value="0" />
+    <option name="RUNTIME_ARGUMENTS" value="" />
+    <option name="PROJECT_PATH" value="$PROJECT_DIR$/BTCPayServer.PluginPacker/BTCPayServer.PluginPacker.csproj" />
+    <option name="PROJECT_EXE_PATH_TRACKING" value="1" />
+    <option name="PROJECT_ARGUMENTS_TRACKING" value="1" />
+    <option name="PROJECT_WORKING_DIRECTORY_TRACKING" value="1" />
+    <option name="PROJECT_KIND" value="DotNetCore" />
+    <option name="PROJECT_TFM" value=".NETCoreApp,Version=v3.1" />
+    <method v="2">
+      <option name="Build" default="false" projectName="BTCPayServer.Plugins.Test" projectPath="C:\Git\btcpayserver\BTCPayServer.Plugins.Test\BTCPayServer.Plugins.Test.csproj" />
+      <option name="Build" />
+    </method>
+  </configuration>
+</component>

.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/net8.0/BTCPayServer.dll",
+            "program": "${workspaceFolder}/BTCPayServer/bin/Debug/net6.0/BTCPayServer.dll",
             "args": [],
             "cwd": "${workspaceFolder}/BTCPayServer",
             "stopAtEntry": false,

BTCPayServer.Abstractions/BTCPayServer.Abstractions.csproj

@@ -31,9 +31,11 @@
     <None Include="icon.png" Pack="true" PackagePath="\" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="HtmlSanitizer" Version="8.0.838" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.11" />
-    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="8.0.11" />
+    <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" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\BTCPayServer.Client\BTCPayServer.Client.csproj" />

BTCPayServer.Abstractions/Configuration/DataDirectories.cs

@@ -1,5 +1,3 @@
-using System.IO;
-
 namespace BTCPayServer.Configuration
 {
     public class DataDirectories
@@ -9,13 +7,5 @@ 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)
-        {
-            if (Path.IsPathRooted(path))
-                return path;
-            return Path.Combine(DataDir, path);
-        }
     }
 }

BTCPayServer.Abstractions/Contracts/BaseDbContextFactory.cs

@@ -4,8 +4,6 @@ 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;
 
@@ -14,16 +12,16 @@ namespace BTCPayServer.Abstractions.Contracts
     public abstract class BaseDbContextFactory<T> where T : DbContext
     {
         private readonly IOptions<DatabaseOptions> _options;
-        private readonly string _migrationTableName;
+        private readonly string _schemaPrefix;
 
-        public BaseDbContextFactory(IOptions<DatabaseOptions> options, string migrationTableName)
+        public BaseDbContextFactory(IOptions<DatabaseOptions> options, string schemaPrefix)
         {
             _options = options;
-            _migrationTableName = migrationTableName;
+            _schemaPrefix = schemaPrefix;
         }
 
-        public T CreateContext() => CreateContext(null);
-        public abstract T CreateContext(Action<NpgsqlDbContextOptionsBuilder> npgsqlOptionsAction = null);
+        public abstract T CreateContext();
+
         class CustomNpgsqlMigrationsSqlGenerator : NpgsqlMigrationsSqlGenerator
         {
 #pragma warning disable EF1001 // Internal EF Core API usage.
@@ -68,27 +66,46 @@ namespace BTCPayServer.Abstractions.Contracts
             }
         }
 
-        public void ConfigureBuilder(DbContextOptionsBuilder builder) => ConfigureBuilder(builder, null);
-        public void ConfigureBuilder(DbContextOptionsBuilder builder, Action<NpgsqlDbContextOptionsBuilder> npgsqlOptionsAction = null)
+        public void ConfigureBuilder(DbContextOptionsBuilder builder)
         {
-            builder
-            .UseNpgsql(_options.Value.ConnectionString, o =>
+            switch (_options.Value.DatabaseType)
             {
-                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>();
+                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();
+            }
         }
 
-        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/IFileService.cs

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

BTCPayServer.Abstractions/Contracts/INotificationHandler.cs

@@ -19,12 +19,9 @@ namespace BTCPayServer.Abstractions.Contracts
     public class NotificationViewModel
     {
         public string Id { get; set; }
-        public string Identifier { get; set; }
-        public string Type { get; set; }
         public DateTimeOffset Created { get; set; }
         public string Body { get; set; }
         public string ActionLink { get; set; }
         public bool Seen { get; set; }
-        public string StoreId { get; set; }
     }
 }

BTCPayServer.Abstractions/Contracts/IPluginHookService.cs

@@ -1,4 +1,3 @@
-using System;
 using System.Threading.Tasks;
 
 namespace BTCPayServer.Abstractions.Contracts
@@ -7,8 +6,5 @@ namespace BTCPayServer.Abstractions.Contracts
     {
         Task ApplyAction(string hook, object args);
         Task<object> ApplyFilter(string hook, object args);
-
-        event EventHandler<(string hook, object args)> ActionInvoked;
-        event EventHandler<(string hook, object args)> FilterInvoked;
     }
 }

BTCPayServer.Abstractions/Contracts/IScopeProvider.cs

@@ -1,4 +1,4 @@
-#nullable enable
+#nullable enable
 namespace BTCPayServer.Abstractions.Contracts;
 
 public interface IScopeProvider

BTCPayServer.Abstractions/Contracts/IStoredFile.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 
 namespace BTCPayServer.Abstractions.Contracts;
 

BTCPayServer.Abstractions/Contracts/ISyncSummaryProvider.cs

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

BTCPayServer.Abstractions/Contracts/IUTXOLocker.cs

@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using NBitcoin;
 

BTCPayServer.Abstractions/Custodians/Client/AssetQuoteResult.cs

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,11 @@
+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)
+    {
+    }
+
+    
+}

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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,16 @@
+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

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

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

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

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

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

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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,29 @@
+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/WithdrawResult.cs

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,15 @@
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Abstractions.Custodians.Client;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Abstractions.Custodians;
+
+public interface ICanWithdraw
+{
+    public Task<WithdrawResult> WithdrawAsync(string paymentMethod, decimal amount, JObject config, CancellationToken cancellationToken);
+
+    public Task<WithdrawResult> GetWithdrawalInfoAsync(string paymentMethod, string withdrawalId, JObject config, CancellationToken cancellationToken);
+
+    public string[] GetWithdrawablePaymentMethods();
+}

BTCPayServer.Abstractions/Custodians/ICustodian.cs

@@ -0,0 +1,26 @@
+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, string locale,
+        CancellationToken cancellationToken = default);
+
+}

BTCPayServer.Abstractions/Extensions/CustodianExtensions.cs

@@ -0,0 +1,14 @@
+#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/GreenfieldExtensions.cs

@@ -7,10 +7,6 @@ namespace BTCPayServer.Abstractions.Extensions;
 
 public static class GreenfieldExtensions
 {
-    public static IActionResult UserNotFound(this ControllerBase ctrl)
-    {
-        return ctrl.CreateAPIError(404, "user-not-found", "The user was not found");
-    }
     public static IActionResult CreateValidationError(this ControllerBase controller, ModelStateDictionary modelState)
     {
         return controller.UnprocessableEntity(modelState.ToGreenfieldValidationError());
@@ -34,12 +30,12 @@ public static class GreenfieldExtensions
     {
         return controller.BadRequest(new GreenfieldAPIError(errorCode, errorMessage));
     }
-
+        
     public static IActionResult CreateAPIError(this ControllerBase controller, int httpCode, string errorCode, string errorMessage)
     {
         return controller.StatusCode(httpCode, new GreenfieldAPIError(errorCode, errorMessage));
     }
-
+        
     public static IActionResult CreateAPIPermissionError(this ControllerBase controller, string missingPermission, string message = null)
     {
         return controller.StatusCode(403, new GreenfieldPermissionAPIError(missingPermission, message));

BTCPayServer.Abstractions/Extensions/HttpRequestExtensions.cs

@@ -11,7 +11,7 @@ public static class HttpRequestExtensions
             return false;
         return request.Host.Host.EndsWith(".onion", StringComparison.OrdinalIgnoreCase);
     }
-
+    
     public static string GetAbsoluteRoot(this HttpRequest request)
     {
         return string.Concat(
@@ -36,17 +36,6 @@ 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/ITempDataDictionaryExtensions.cs

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

BTCPayServer.Abstractions/Extensions/StringExtensions.cs

@@ -6,6 +6,7 @@ namespace BTCPayServer.Abstractions.Extensions;
 
 public static class StringExtensions
 {
+
     public static bool IsValidFileName(this string fileName)
     {
         return !fileName.ToCharArray().Any(c => Path.GetInvalidFileNameChars().Contains(c)
@@ -40,4 +41,5 @@ public static class StringExtensions
             return str.Substring(0, str.Length - 1);
         return str;
     }
+    
 }

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 ACTIVE_CLASS = "active";
+        private const string ActivePageClass = "active";
 
         public enum DateDisplayFormat
         {
@@ -20,15 +20,6 @@ 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
         {
@@ -55,101 +46,50 @@ namespace BTCPayServer.Abstractions.Extensions
             viewData[ACTIVE_CATEGORY_KEY] = activeCategory;
         }
 
-        public static bool IsCategoryActive(this ViewDataDictionary viewData, string category, object id = null)
+        public static string IsActiveCategory<T>(this ViewDataDictionary viewData, T category, object id = null)
         {
-            if (!viewData.ContainsKey(ACTIVE_CATEGORY_KEY)) return false;
+            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;
+            }
             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;
+            return categoryMatch && idMatch ? ActivePageClass : null;
         }
 
-        public static bool IsCategoryActive<T>(this ViewDataDictionary viewData, T category, object id = null)
+        public static string IsActivePage<T>(this ViewDataDictionary viewData, T page, object id = null)
+            where T : IConvertible
         {
-            return IsCategoryActive(viewData, category.ToString(), id);
+            return IsActivePage(viewData, page.ToString(), page.GetType().ToString(), id);
         }
 
-        public static bool IsPageActive(this ViewDataDictionary viewData, string page, string category, object id = null)
+        public static string IsActivePage<T>(this ViewDataDictionary viewData, IEnumerable<T> pages, object id = null)
+            where T : IConvertible
         {
-            if (!viewData.ContainsKey(ACTIVE_PAGE_KEY)) return false;
+            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;
+            }
             var activeId = viewData[ACTIVE_ID_KEY];
             var activePage = viewData[ACTIVE_PAGE_KEY]?.ToString();
             var activeCategory = viewData[ACTIVE_CATEGORY_KEY]?.ToString();
-            var categoryAndPageMatch = page.Equals(activePage, StringComparison.InvariantCultureIgnoreCase) &&
-                (category == null || activeCategory != null && activeCategory.Equals(category, StringComparison.InvariantCultureIgnoreCase));
+            var categoryAndPageMatch = (category == null || activeCategory.Equals(category, StringComparison.InvariantCultureIgnoreCase)) && page.Equals(activePage, StringComparison.InvariantCultureIgnoreCase);
             var idMatch = id == null || activeId == null || id.Equals(activeId);
-            return categoryAndPageMatch && idMatch;
-        }
-        
-        public static bool IsPageActive<T>(this ViewDataDictionary viewData, IEnumerable<T> pages, object id = null)
-            where T : IConvertible
-        {
-            return pages.Any(page => ActivePageClass(viewData, page.ToString(), page.GetType().ToString(), id) == ACTIVE_CLASS);
-        }
-
-        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 IsCategoryActive(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 IsPageActive(viewData, page, category, id) ? ACTIVE_CLASS : null;
-        }
-
-        public static string ActivePageClass<T>(this ViewDataDictionary viewData, IEnumerable<T> pages, object id = null) where T : IConvertible
-        {
-            return IsPageActive(viewData, pages, id) ? ACTIVE_CLASS : null;
-        }
-
-        [Obsolete("Use ActiveCategoryClass instead")]
-        public static string IsActiveCategory<T>(this ViewDataDictionary viewData, T category, object id = null)
-        {
-            return ActiveCategoryClass(viewData, category, id);
-        }
-
-        [Obsolete("Use ActiveCategoryClass instead")]
-        public static string IsActiveCategory(this ViewDataDictionary viewData, string category, object id = null)
-        {
-            return ActiveCategoryClass(viewData, category, id);
-        }
-
-        [Obsolete("Use ActivePageClass instead")]
-        public static string IsActivePage<T>(this ViewDataDictionary viewData, T page, object id = null) where T : IConvertible
-        {
-            return ActivePageClass(viewData, page, id);
-        }
-
-        [Obsolete("Use ActivePageClass instead")]
-        public static string IsActivePage<T>(this ViewDataDictionary viewData, IEnumerable<T> pages, object id = null) where T : IConvertible
-        {
-            return ActivePageClass(viewData, pages, id);
-        }
-
-        [Obsolete("Use ActivePageClass instead")]
-        public static string IsActivePage(this ViewDataDictionary viewData, string page, string category, object id = null)
-        {
-            return ActivePageClass(viewData, page, category, id);
-        }
-
-        public static HtmlString ToBrowserDate(this DateTimeOffset date, string netFormat, string jsDateFormat = "short", string jsTimeFormat = "short")
-        {
-            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>");
+            return categoryAndPageMatch && idMatch ? ActivePageClass : null;
         }
 
         public static HtmlString ToBrowserDate(this DateTimeOffset date, DateDisplayFormat format = DateDisplayFormat.Localized)
@@ -186,7 +126,7 @@ namespace BTCPayServer.Abstractions.Extensions
             {
                 return $"{(int)timeSpan.TotalMinutes} minute{Plural((int)timeSpan.TotalMinutes)}";
             }
-            return timeSpan.Days < 1
+            return timeSpan.Days < 1 
                 ? $"{(int)timeSpan.TotalHours} hour{Plural((int)timeSpan.TotalHours)}"
                 : $"{(int)timeSpan.TotalDays} day{Plural((int)timeSpan.TotalDays)}";
         }

BTCPayServer.Abstractions/Form/AlertMessage.cs

@@ -17,16 +17,16 @@ public class AlertMessage
         Danger,
         Info
     }
-
+    
     [JsonConverter(typeof(StringEnumConverter))]
     public AlertMessageType Type;
-
+    
     // The translated message to be shown to the user
     public string Message;
 
     public AlertMessage()
     {
-
+        
     }
 
     public AlertMessage(AlertMessageType type, string message)

BTCPayServer.Abstractions/Form/Field.cs

@@ -12,12 +12,12 @@ public class Field
 {
     public static Field Create(string label, string name, string value, bool required, string helpText, string type = "text")
     {
-        return new Field
+        return new Field()
         {
             Label = label,
             Name = name,
             Value = value,
-            OriginalValue = value,
+            OriginalValue = value,  
             Required = required,
             HelpText = helpText,
             Type = type
@@ -26,14 +26,14 @@ public class Field
     // The name of the HTML5 node. Should be used as the key for the posted data.
     public string Name;
 
-    public bool Constant;
+    public bool Hidden;
 
-    // HTML5 compatible type string like "text", "textarea", "email", "password", etc.
+    // HTML5 compatible type string like "text", "textarea", "email", "password", etc. Each type is a class and may contain more fields (i.e. "select" would have options).
     public string Type;
 
     public static Field CreateFieldset()
     {
-        return new Field { Type = "fieldset" };
+        return new Field() { Type = "fieldset" };
     }
 
     // The value field is what is currently in the DB or what the user entered, but possibly not saved yet due to validation errors.
@@ -55,7 +55,7 @@ public class Field
     public List<Field> Fields { get; set; } = new();
 
     // The field is considered "valid" if there are no validation errors
-    public List<string> ValidationErrors = new();
+    public List<string> ValidationErrors = new List<string>();
 
     public virtual bool IsValid()
     {

BTCPayServer.Abstractions/Form/Form.cs

@@ -1,9 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Reflection;
 using Microsoft.AspNetCore.Http;
-using Microsoft.Extensions.Primitives;
+using Microsoft.AspNetCore.Mvc.ModelBinding;
 using Newtonsoft.Json.Linq;
 
 namespace BTCPayServer.Abstractions.Form;
@@ -21,90 +20,137 @@ public class Form
         return JObject.FromObject(this, CamelCaseSerializerSettings.Serializer).ToString(Newtonsoft.Json.Formatting.Indented);
     }
 #nullable restore
-
     // Messages to be shown at the top of the form indicating user feedback like "Saved successfully" or "Please change X because of Y." or a warning, etc...
     public List<AlertMessage> TopMessages { get; set; } = new();
-
+    
     // Groups of fields in the form
     public List<Field> Fields { get; set; } = new();
-
+    
     // Are all the fields valid in the form?
     public bool IsValid()
     {
-        if (TopMessages?.Any(t => t.Type == AlertMessage.AlertMessageType.Danger) is true)
-            return false;
         return Fields.Select(f => f.IsValid()).All(o => o);
     }
 
-    public Field GetFieldByFullName(string fullName)
+    public Field GetFieldByName(string name)
     {
-        foreach (var f in GetAllFields())
+        return GetFieldByName(name, Fields, null);
+    }
+    
+    private static Field GetFieldByName(string name, List<Field> fields, string prefix)
+    {
+        prefix ??= string.Empty;
+        foreach (var field in fields)
         {
-            if (f.FullName == fullName)
-                return f.Field;
+            var currentPrefix = prefix;
+            if (!string.IsNullOrEmpty(field.Name))
+            {
+                
+                currentPrefix = $"{prefix}{field.Name}";
+                if (currentPrefix.Equals(name, StringComparison.InvariantCultureIgnoreCase))
+                {
+                    return field;
+                }
+
+                currentPrefix += "_";
+            }
+
+            var subFieldResult = GetFieldByName(name, field.Fields, currentPrefix);
+            if (subFieldResult is not null)
+            {
+                return subFieldResult;
+            }
+            
         }
         return null;
     }
 
-    public IEnumerable<(string FullName, List<string> Path, Field Field)> GetAllFields()
+    public List<string> GetAllNames()
     {
-        HashSet<string> nameReturned = new();
-        foreach (var f in GetAllFieldsCore(new List<string>(), Fields))
-        {
-            var fullName = string.Join('_', f.Path.Where(s => !string.IsNullOrEmpty(s)));
-            if (!nameReturned.Add(fullName))
-                continue;
-            yield return (fullName, f.Path, f.Field);
-        }
+        return GetAllNames(Fields);
     }
 
-    public bool ValidateFieldNames(out List<string> errors)
-    {
-        errors = new List<string>();
-        HashSet<string> nameReturned = new();
-        foreach (var f in GetAllFieldsCore(new List<string>(), Fields))
-        {
-            var fullName = string.Join('_', f.Path.Where(s => !string.IsNullOrEmpty(s)));
-            if (!nameReturned.Add(fullName))
-            {
-                errors.Add($"Form contains duplicate field names '{fullName}'");
-            }
-        }
-        return errors.Count == 0;
-    }
-
-    IEnumerable<(List<string> Path, Field Field)> GetAllFieldsCore(List<string> path, List<Field> fields)
+    private static List<string> GetAllNames(List<Field> fields)
     {
+        var names = new List<string>();
+        
         foreach (var field in fields)
         {
-            List<string> thisPath = new(path.Count + 1);
-            thisPath.AddRange(path);
+            string prefix = string.Empty;
             if (!string.IsNullOrEmpty(field.Name))
             {
-                thisPath.Add(field.Name);
-                yield return (thisPath, field);
+                names.Add(field.Name);
+                prefix = $"{field.Name}_";
             }
-            foreach (var descendant in GetAllFieldsCore(thisPath, field.Fields))
+
+            if (field.Fields.Any())
             {
-                descendant.Field.Constant = field.Constant || descendant.Field.Constant;
-                yield return descendant;
+                names.AddRange(GetAllNames(field.Fields).Select(s => $"{prefix}{s}" ));
+            }
+        }
+
+        return names;
+    }
+
+    public void ApplyValuesFromOtherForm(Form form)
+    {
+        foreach (var fieldset in Fields)
+        {
+            foreach (var field in fieldset.Fields)
+            {
+                field.Value = form
+                    .GetFieldByName(
+                        $"{(string.IsNullOrEmpty(fieldset.Name) ? string.Empty : fieldset.Name + "_")}{field.Name}")
+                    ?.Value;
             }
         }
     }
-
-    public void ApplyValuesFromForm(IEnumerable<KeyValuePair<string, StringValues>> form)
+    
+    public void ApplyValuesFromForm(IFormCollection form)
     {
-        var values = form.GroupBy(f => f.Key, f => f.Value).ToDictionary(g => g.Key, g => g.First());
-        foreach (var f in GetAllFields())
+        var names = GetAllNames();
+        foreach (var name in names)
         {
-            if (f.Field.Constant || !values.TryGetValue(f.FullName, out var val))
+            var field = GetFieldByName(name);
+            if (field is null || !form.TryGetValue(name, out var val))
+            {
                 continue;
+            }
 
-            f.Field.Value = val;
+            field.Value = val;
         }
     }
 
+    public Dictionary<string, object> GetValues()
+    {
+        return GetValues(Fields);
+    }
     
+    private static Dictionary<string, object> GetValues(List<Field> fields)
+    {
+        var result = new Dictionary<string, object>();
+        foreach (Field field in fields)
+        {
+            var name = field.Name ?? string.Empty;
+            if (field.Fields.Any())
+            {
+                var values = GetValues(fields);
+                values.Remove(string.Empty, out var keylessValue);
+                
+                result.TryAdd(name, values);
 
+                if (keylessValue is not Dictionary<string, object> dict) continue;
+                foreach (KeyValuePair<string,object> keyValuePair in dict)
+                {
+                    result.TryAdd(keyValuePair.Key, keyValuePair.Value);
+                }
+            }
+            else
+            {
+                result.TryAdd(name, field.Value);
+            }
+        }
 
+        return result;
+    }
 }

BTCPayServer.Abstractions/Models/BaseBTCPayServerPlugin.cs

@@ -8,52 +8,18 @@ namespace BTCPayServer.Abstractions.Models
 {
     public abstract class BaseBTCPayServerPlugin : IBTCPayServerPlugin
     {
-        public virtual string Identifier
-        {
-            get
-            {
-                return GetType().GetTypeInfo().Assembly.GetName().Name;
-            }
-        }
-        public virtual string Name
-        {
-            get
-            {
-                return GetType().GetTypeInfo().Assembly
-                        .GetCustomAttribute<AssemblyProductAttribute>()?
-                        .Product ?? "???";
-            }
-        }
+        public abstract string Identifier { get; }
+        public abstract string Name { get; }
 
         public virtual Version Version
         {
             get
             {
-                return GetVersion(GetType().GetTypeInfo().Assembly
-                        .GetCustomAttribute<AssemblyInformationalVersionAttribute>()?
-                        .InformationalVersion) ??
-                        Assembly.GetAssembly(GetType())?.GetName()?.Version ??
-                        new Version(1, 0, 0, 0);
+                return Assembly.GetAssembly(GetType())?.GetName().Version ?? new Version(1, 0, 0, 0);
             }
         }
 
-        private static Version GetVersion(string informationalVersion)
-        {
-            if (informationalVersion is null)
-                return null;
-            Version.TryParse(informationalVersion, out var r);
-            return r;
-        }
-
-        public virtual string Description
-        {
-            get
-            {
-                return GetType().GetTypeInfo().Assembly
-                        .GetCustomAttribute<AssemblyDescriptionAttribute>()?
-                        .Description ?? string.Empty;
-            }
-        }
+        public abstract string Description { get; }
         public bool SystemPlugin { get; set; }
         public virtual IBTCPayServerPlugin.PluginDependency[] Dependencies { get; } = Array.Empty<IBTCPayServerPlugin.PluginDependency>();
 

BTCPayServer.Abstractions/Models/DatabaseOptions.cs

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

BTCPayServer.Abstractions/Models/DatabaseType.cs

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

BTCPayServer.Abstractions/Models/StatusMessageModel.cs

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

BTCPayServer.Abstractions/Models/UploadImageResultModel.cs

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

BTCPayServer.Abstractions/Security/AuthorizationFilterHandle.cs

@@ -8,7 +8,7 @@ public class AuthorizationFilterHandle
     public AuthorizationHandlerContext Context { get; }
     public PolicyRequirement Requirement { get; }
     public HttpContext HttpContext { get; }
-    public bool Success { get; private set; }
+    public bool Success { get; private set;  }
 
     public AuthorizationFilterHandle(
         AuthorizationHandlerContext context,

BTCPayServer.Abstractions/Security/ContentSecurityPolicies.cs

@@ -114,11 +114,6 @@ namespace BTCPayServer.Security
             _Policies.Add(policy);
         }
 
-        public void UnsafeEval()
-        {
-            Add("script-src", "'unsafe-eval'");
-        }
-
         public IEnumerable<ConsentSecurityPolicy> Rules => _Policies;
         public bool HasRules => _Policies.Count != 0;
 

BTCPayServer.Abstractions/Services/Safe.cs

@@ -1,5 +1,4 @@
-using System.Web;
-using Ganss.Xss;
+using Ganss.XSS;
 using Microsoft.AspNetCore.Html;
 using Microsoft.AspNetCore.Mvc.Rendering;
 
@@ -22,11 +21,6 @@ namespace BTCPayServer.Abstractions.Services
         {
             return _htmlHelper.Raw(_htmlSanitizer.Sanitize(value));
         }
-        
-        public IHtmlContent RawEncode(string value)
-        {
-            return _htmlHelper.Raw(HttpUtility.HtmlEncode(_htmlSanitizer.Sanitize(value)));
-        }
 
         public IHtmlContent Json(object model)
         {

BTCPayServer.Abstractions/Services/UIExtension.cs

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

BTCPayServer.Abstractions/TagHelpers/PermissionTagHelper.cs

@@ -2,93 +2,47 @@ using System.Threading.Tasks;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Razor.TagHelpers;
-using System;
-using System.Linq;
+using Microsoft.Extensions.Logging;
 
 namespace BTCPayServer.Abstractions.TagHelpers;
 
-[HtmlTargetElement(Attributes = "[permission]")]
-[HtmlTargetElement(Attributes = "[not-permission]")]
+[HtmlTargetElement(Attributes = nameof(Permission))]
 public class PermissionTagHelper : TagHelper
 {
     private readonly IAuthorizationService _authorizationService;
     private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly ILogger<PermissionTagHelper> _logger;
 
-    public PermissionTagHelper(IAuthorizationService authorizationService, IHttpContextAccessor httpContextAccessor)
+    public PermissionTagHelper(IAuthorizationService authorizationService, IHttpContextAccessor httpContextAccessor, ILogger<PermissionTagHelper> logger)
     {
         _authorizationService = authorizationService;
         _httpContextAccessor = httpContextAccessor;
+        _logger = logger;
     }
 
     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)
     {
-        var permissions = Permission?.Split(',', StringSplitOptions.RemoveEmptyEntries) ?? Array.Empty<string>();
-        var notPermissions = NotPermission?.Split(',', StringSplitOptions.RemoveEmptyEntries) ?? Array.Empty<string>();
-
-        if (!permissions.Any() && !notPermissions.Any())
+        if (string.IsNullOrEmpty(Permission))
             return;
         if (_httpContextAccessor.HttpContext is null)
             return;
 
-        bool shouldRender = true; // Assume tag should be rendered unless a check fails
-
-        // Process 'Permission' - User must have these permissions
-        if (permissions.Any())
+        var key = $"{Permission}_{PermissionResource}";
+        if (!_httpContextAccessor.HttpContext.Items.TryGetValue(key, out var o) ||
+            o is not AuthorizationResult 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;
+            res = await _authorizationService.AuthorizeAsync(_httpContextAccessor.HttpContext.User,
+                PermissionResource,
+                Permission);
+            _httpContextAccessor.HttpContext.Items.Add(key, res);
         }
-
-        // 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)
+        if (!res.Succeeded)
         {
             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

@@ -1,35 +0,0 @@
-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.Abstractions/TagHelpers/SVGUse.cs

@@ -23,20 +23,11 @@ public class SVGUse : UrlResolutionTagHelper2
     {
         _fileVersionProvider = fileVersionProvider;
     }
-
     public override void Process(TagHelperContext context, TagHelperOutput output)
     {
         var attr = output.Attributes["href"].Value.ToString();
-        var symbolIndex = attr!.IndexOf("#", StringComparison.InvariantCulture);
-        var start = attr.IndexOf("~", StringComparison.InvariantCulture) + 1;
-        var length = (symbolIndex != -1 ? symbolIndex : attr.Length) - start;
-        var filePath = attr.Substring(start, length);
-        if (!string.IsNullOrEmpty(filePath))
-        {
-            var versioned = _fileVersionProvider.AddFileVersionToPath(ViewContext.HttpContext.Request.PathBase, filePath);
-            attr = attr.Replace(filePath, versioned);
-        }
+        attr = _fileVersionProvider.AddFileVersionToPath(ViewContext.HttpContext.Request.PathBase, attr);
         output.Attributes.SetAttribute("href", attr);
         base.Process(context, output);
-    }
+    }  
 }

BTCPayServer.Client/App/IBTCPayAppHubClient.cs

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

BTCPayServer.Client/App/Models/AcceptInviteRequest.cs

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

BTCPayServer.Client/App/Models/AcceptInviteResult.cs

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

BTCPayServer.Client/App/Models/AccessTokenResult.cs

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

BTCPayServer.Client/App/Models/AppInstanceInfo.cs

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

BTCPayServer.Client/App/Models/AppUserInfo.cs

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

BTCPayServer.Client/App/Models/CreateStoreData.cs

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

BTCPayServer.Client/BTCPayServer.Client.csproj

@@ -12,11 +12,9 @@
         <PackageLicenseExpression>MIT</PackageLicenseExpression>
         <RepositoryUrl>https://github.com/btcpayserver/btcpayserver</RepositoryUrl>
         <RepositoryType>git</RepositoryType>
-        <Configurations>Debug;Release</Configurations>
-        <Platforms>AnyCPU</Platforms>
     </PropertyGroup>
   <PropertyGroup>
-    <Version Condition=" '$(Version)' == '' ">2.0.1</Version>
+    <Version Condition=" '$(Version)' == '' ">1.7.1</Version>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
@@ -30,9 +28,9 @@
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
   </ItemGroup>
     <ItemGroup>
-      <PackageReference Include="BTCPayServer.Lightning.Common" Version="1.5.2" />
-      <PackageReference Include="NBitcoin" Version="7.0.46" />
-      <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+      <PackageReference Include="BTCPayServer.Lightning.Common" Version="1.3.15" />
+      <PackageReference Include="NBitcoin" Version="7.0.14" />
+      <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
     </ItemGroup>
   <ItemGroup>
     <None Include="icon.png" Pack="true" PackagePath="\" />

BTCPayServer.Client/BTCPayServerClient.APIKeys.cs

@@ -4,41 +4,36 @@ using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client;
-
-public partial class BTCPayServerClient
+namespace BTCPayServer.Client
 {
-    public virtual async Task<ApiKeyData> GetCurrentAPIKeyInfo(CancellationToken token = default)
+    public partial class BTCPayServerClient
     {
-        return await SendHttpRequest<ApiKeyData>("api/v1/api-keys/current", null, HttpMethod.Get, token);
-    }
+        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);
+        }
 
-    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(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(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));
-        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);
+        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);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.Apps.cs

@@ -1,91 +1,65 @@
 using System;
-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
+namespace BTCPayServer.Client
 {
-    public virtual async Task<PointOfSaleAppData> CreatePointOfSaleApp(string storeId,
-        PointOfSaleAppRequest request, CancellationToken token = default)
+    public partial class BTCPayServerClient
     {
-        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<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<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,
+            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<AppBaseData[]> GetAllApps(CancellationToken token = default)
-    {
-        return await SendHttpRequest<AppBaseData[]>("api/v1/apps", null, HttpMethod.Get, token);
-    }
-
-    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<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<AppSalesStats> GetAppSales(string appId, int numberOfDays = 7, CancellationToken token = default)
-    {
-        if (appId == null) throw new ArgumentNullException(nameof(appId));
-        var queryPayload = new Dictionary<string, object> { { nameof(numberOfDays), numberOfDays } };
-        return await SendHttpRequest<AppSalesStats>($"api/v1/apps/{appId}/sales", queryPayload, HttpMethod.Get, token);
-    }
-
-    public virtual async Task<List<AppItemStats>> GetAppTopItems(string appId, int offset = 0, int count = 10, CancellationToken token = default)
-    {
-        if (appId == null) throw new ArgumentNullException(nameof(appId));
-        var queryPayload = new Dictionary<string, object> { { nameof(offset), offset }, { nameof(count), count } };
-        return await SendHttpRequest<List<AppItemStats>>($"api/v1/apps/{appId}/top-items", queryPayload, HttpMethod.Get, token);
-    }
-
-    public virtual async Task DeleteApp(string appId, CancellationToken token = default)
-    {
-        if (appId == null) throw new ArgumentNullException(nameof(appId));
-        await SendHttpRequest($"api/v1/apps/{appId}", null, HttpMethod.Delete, token);
-    }
-
-    public virtual async Task<FileData> UploadAppItemImage(string appId, string filePath, string mimeType, CancellationToken token = default)
-    {
-        return await UploadFileRequest<FileData>($"api/v1/apps/{appId}/image", filePath, mimeType, "file", HttpMethod.Post, token);
-    }
-
-    public virtual async Task DeleteAppItemImage(string appId, string fileId, CancellationToken token = default)
-    {
-        await SendHttpRequest($"api/v1/apps/{appId}/image/{fileId}", null, HttpMethod.Delete, token);
+        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);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.Authorization.cs

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

@@ -0,0 +1,97 @@
+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> GetDepositAddress(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> GetTradeInfo(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> GetTradeQuote(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> CreateWithdrawal(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<WithdrawalResponseData> GetWithdrawalInfo(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

@@ -0,0 +1,16 @@
+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

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

BTCPayServer.Client/BTCPayServerClient.Invoices.cs

@@ -7,101 +7,139 @@ using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 using NBitcoin;
 
-namespace BTCPayServer.Client;
-
-public partial class BTCPayServerClient
+namespace BTCPayServer.Client
 {
-    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 partial class BTCPayServerClient
     {
-        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);
-
-        return await SendHttpRequest<IEnumerable<InvoiceData>>($"api/v1/stores/{storeId}/invoices", queryPayload, HttpMethod.Get, token);
-    }
-
-    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,
-        bool onlyAccountedPayments = true, bool includeSensitive = false,
-        CancellationToken token = default)
-    {
-        var queryPayload = new Dictionary<string, object>
+        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)
         {
-            { nameof(onlyAccountedPayments), onlyAccountedPayments },
-            { nameof(includeSensitive), includeSensitive }
-        };
-        return await SendHttpRequest<InvoicePaymentMethodDataModel[]>($"api/v1/stores/{storeId}/invoices/{invoiceId}/payment-methods", queryPayload, HttpMethod.Get, token);
-    }
+            Dictionary<string, object> queryPayload = new Dictionary<string, object>();
+            queryPayload.Add(nameof(includeArchived), includeArchived);
 
-    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 (startDate is DateTimeOffset s)
+                queryPayload.Add(nameof(startDate), Utils.DateTimeToUnixTime(s));
 
-    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 (endDate is DateTimeOffset e)
+                queryPayload.Add(nameof(endDate), Utils.DateTimeToUnixTime(e));
 
-    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);
-    }
+            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<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);
-    }
+            if (skip != null)
+            {
+                queryPayload.Add(nameof(skip), skip);
+            }
 
-    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);
-    }
+            if (take != null)
+            {
+                queryPayload.Add(nameof(take), take);
+            }
 
-    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);
-    }
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/invoices",
+                        queryPayload), token);
+            return await HandleResponse<IEnumerable<InvoiceData>>(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);
+        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 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<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);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.LNURLPayPaymentMethods.cs

@@ -0,0 +1,59 @@
+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,108 +5,124 @@ using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client;
-
-public partial class BTCPayServerClient
+namespace BTCPayServer.Client
 {
-    public virtual async Task<LightningNodeInformationData> GetLightningNodeInfo(string cryptoCode,
-        CancellationToken token = default)
+    public partial class BTCPayServerClient
     {
-        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<HistogramData> GetLightningNodeHistogram(string cryptoCode, HistogramType? type = null,
-        CancellationToken token = default)
-    {
-        var queryPayload = type == null ? null : new Dictionary<string, object> { { "type", type.ToString() } };
-        return await SendHttpRequest<HistogramData>($"api/v1/server/lightning/{cryptoCode}/histogram", queryPayload, HttpMethod.Get, token);
-    }
-
-    public virtual async Task ConnectToLightningNode(string cryptoCode, ConnectToNodeRequest request,
-        CancellationToken token = default)
-    {
-        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)
+        public virtual async Task<LightningNodeInformationData> GetLightningNodeInfo(string cryptoCode,
+            CancellationToken token = default)
         {
-            queryPayload.Add("pendingOnly", v.ToString());
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/info",
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<LightningNodeInformationData>(response);
         }
-        if (offsetIndex is > 0)
+        
+        public virtual async Task<LightningNodeBalanceData> GetLightningNodeBalance(string cryptoCode,
+            CancellationToken token = default)
         {
-            queryPayload.Add("offsetIndex", offsetIndex);
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/balance",
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<LightningNodeBalanceData>(response);
         }
-        return await SendHttpRequest<LightningInvoiceData[]>($"api/v1/server/lightning/{cryptoCode}/invoices", queryPayload, HttpMethod.Get, token);
-    }
 
-    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)
+        public virtual async Task ConnectToLightningNode(string cryptoCode, ConnectToNodeRequest request,
+            CancellationToken token = default)
         {
-            queryPayload.Add("includePending", v.ToString());
+            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);
         }
-        if (offsetIndex is > 0)
-        {
-            queryPayload.Add("offsetIndex", offsetIndex);
-        }
-        return await SendHttpRequest<LightningPaymentData[]>($"api/v1/server/lightning/{cryptoCode}/payments", queryPayload, HttpMethod.Get, token);
-    }
 
-    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);
+        public virtual async Task<IEnumerable<LightningChannelData>> GetLightningNodeChannels(string cryptoCode,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/channels",
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<IEnumerable<LightningChannelData>>(response);
+        }
+
+        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<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);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.Lightning.Store.cs

@@ -5,109 +5,126 @@ using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client;
-
-public partial class BTCPayServerClient
+namespace BTCPayServer.Client
 {
-    public virtual async Task<LightningNodeInformationData> GetLightningNodeInfo(string storeId, string cryptoCode,
-        CancellationToken token = default)
+    public partial class BTCPayServerClient
     {
-        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<HistogramData> GetLightningNodeHistogram(string storeId, string cryptoCode, HistogramType? type = null,
-        CancellationToken token = default)
-    {
-        var queryPayload = type == null ? null : new Dictionary<string, object> { { "type", type.ToString() } };
-        return await SendHttpRequest<HistogramData>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/histogram", queryPayload, HttpMethod.Get, token);
-    }
-
-    public virtual async Task ConnectToLightningNode(string storeId, string cryptoCode, ConnectToNodeRequest request,
-        CancellationToken token = default)
-    {
-        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)
+        public virtual async Task<LightningNodeInformationData> GetLightningNodeInfo(string storeId, string cryptoCode,
+            CancellationToken token = default)
         {
-            queryPayload.Add("pendingOnly", v.ToString());
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/info",
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<LightningNodeInformationData>(response);
         }
-        if (offsetIndex is > 0)
+        
+        public virtual async Task<LightningNodeBalanceData> GetLightningNodeBalance(string storeId, string cryptoCode,
+            CancellationToken token = default)
         {
-            queryPayload.Add("offsetIndex", offsetIndex);
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/balance",
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<LightningNodeBalanceData>(response);
         }
-        return await SendHttpRequest<LightningInvoiceData[]>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/invoices", queryPayload, HttpMethod.Get, token);
-    }
 
-    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)
+        public virtual async Task ConnectToLightningNode(string storeId, string cryptoCode, ConnectToNodeRequest request,
+            CancellationToken token = default)
         {
-            queryPayload.Add("includePending", v.ToString());
+            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);
         }
-        if (offsetIndex is > 0)
-        {
-            queryPayload.Add("offsetIndex", offsetIndex);
-        }
-        return await SendHttpRequest<LightningPaymentData[]>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/payments", queryPayload, HttpMethod.Get, token);
-    }
 
-    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);
+        public virtual async Task<IEnumerable<LightningChannelData>> GetLightningNodeChannels(string storeId, string cryptoCode,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/channels",
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<IEnumerable<LightningChannelData>>(response);
+        }
+
+        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<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);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.LightningAddresses.cs

@@ -1,34 +0,0 @@
-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<LightningAddressData[]> GetStoreLightningAddresses(string storeId,
-        CancellationToken token = default)
-    {
-        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)
-    {
-        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)
-    {
-        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)
-    {
-        return await SendHttpRequest<LightningAddressData>($"api/v1/stores/{storeId}/lightning-addresses/{username}", data, HttpMethod.Post, token);
-    }
-}

BTCPayServer.Client/BTCPayServerClient.LightningNetworkPaymentMethods.cs

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

BTCPayServer.Client/BTCPayServerClient.Notifications.cs

@@ -1,52 +1,56 @@
+using System;
 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
+namespace BTCPayServer.Client
 {
-    public virtual async Task<IEnumerable<NotificationData>> GetNotifications(bool? seen = null, int? skip = null,
-        int? take = null, string[] storeId = null, CancellationToken token = default)
+    public partial class BTCPayServerClient
     {
-        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);
-    }
+        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>();
 
-    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);
-    }
+            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> 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);
-    }
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/users/me/notifications",
+                    queryPayload), token);
 
-    public virtual async Task<NotificationSettingsData> GetNotificationSettings(CancellationToken token = default)
-    {
-        return await SendHttpRequest<NotificationSettingsData>("api/v1/users/me/notification-settings", null, HttpMethod.Get, token);
-    }
+            return await HandleResponse<IEnumerable<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> 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 RemoveNotification(string notificationId, CancellationToken token = default)
-    {
-        await SendHttpRequest($"api/v1/users/me/notifications/{notificationId}", null, HttpMethod.Delete, 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);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.OnChainPaymentMethods.cs

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

BTCPayServer.Client/BTCPayServerClient.OnChainWallet.Objects.cs

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

BTCPayServer.Client/BTCPayServerClient.OnChainWallet.cs

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

BTCPayServer.Client/BTCPayServerClient.PaymentRequests.cs

@@ -5,49 +5,72 @@ using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client;
-
-public partial class BTCPayServerClient
+namespace BTCPayServer.Client
 {
-    public virtual async Task<IEnumerable<PaymentRequestData>> GetPaymentRequests(string storeId,
-        bool includeArchived = false,
-        CancellationToken token = default)
+    public partial class BTCPayServerClient
     {
-        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<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);
+        }
 
-    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<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 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 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<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<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<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> 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> 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);
+        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);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.PayoutProcessors.cs

@@ -1,16 +1,18 @@
 #nullable enable
 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
+namespace BTCPayServer.Client
 {
-    public virtual async Task<IEnumerable<PayoutProcessorData>> GetPayoutProcessors(CancellationToken token = default)
+    public partial class BTCPayServerClient
     {
-        return await SendHttpRequest<IEnumerable<PayoutProcessorData>>("api/v1/payout-processors", null, HttpMethod.Get, token);
+        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);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.PullPayments.cs

@@ -5,90 +5,97 @@ using System.Threading.Tasks;
 using System.Web;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client;
-
-public partial class BTCPayServerClient
+namespace BTCPayServer.Client
 {
-    public virtual async Task<PullPaymentData> CreatePullPayment(string storeId, CreatePullPaymentRequest request, CancellationToken cancellationToken = default)
+    public partial class BTCPayServerClient
     {
-        return await SendHttpRequest<PullPaymentData>($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/pull-payments", request, HttpMethod.Post, cancellationToken);
-    }
+        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);
+        }
 
-    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<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<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 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<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<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 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<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);
+        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);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.ServerInfo.cs

@@ -1,20 +1,15 @@
-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
+namespace BTCPayServer.Client
 {
-    public virtual async Task<ServerInfoData> GetServerInfo(CancellationToken token = default)
+    public partial class BTCPayServerClient
     {
-        return await SendHttpRequest<ServerInfoData>("api/v1/server/info", null, HttpMethod.Get, token);
-    }
-        
-    public virtual async Task<List<RoleData>> GetServerRoles(CancellationToken token = default)
-    {
-        return await SendHttpRequest<List<RoleData>>("api/v1/server/roles", null, HttpMethod.Get, token);
+        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);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.StoreEmail.cs

@@ -3,22 +3,35 @@ using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client;
-
-public partial class BTCPayServerClient
+namespace BTCPayServer.Client
 {
-    public virtual async Task<EmailSettingsData> GetStoreEmailSettings(string storeId, CancellationToken token = default)
+    public partial class BTCPayServerClient
     {
-        return await SendHttpRequest<EmailSettingsData>($"api/v1/stores/{storeId}/email", null, HttpMethod.Get, token);
-    }
+        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);
+        }
 
-    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<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 SendEmail(string storeId, SendEmailRequest request, CancellationToken token = default)
-    {
-        await SendHttpRequest($"api/v1/stores/{storeId}/email/send", request, HttpMethod.Post, 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);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.StorePaymentMethods.cs

@@ -1,45 +1,27 @@
 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
+namespace BTCPayServer.Client
 {
-    public virtual async Task<GenericPaymentMethodData> UpdateStorePaymentMethod(string storeId, string paymentMethodId, UpdatePaymentMethodRequest request, CancellationToken token = default)
+    public partial class BTCPayServerClient
     {
-        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)
+        public virtual async Task<Dictionary<string, GenericPaymentMethodData>> GetStorePaymentMethods(string storeId,
+            bool? enabled = null,
+            CancellationToken token = default)
         {
-            query.Add(nameof(includeConfig), includeConfig);
-        }
-        return await SendHttpRequest<GenericPaymentMethodData>($"api/v1/stores/{storeId}/payment-methods/{paymentMethodId}", query, HttpMethod.Get, token);
-    }
+            var query = new Dictionary<string, object>();
+            if (enabled != null)
+            {
+                query.Add(nameof(enabled), enabled);
+            }
 
-    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);
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods",
+                        query), token);
+            return await HandleResponse<Dictionary<string, GenericPaymentMethodData>>(response);
         }
-        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,37 +5,44 @@ using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client;
-
-public partial class BTCPayServerClient
+namespace BTCPayServer.Client
 {
-    public virtual async Task<IEnumerable<PayoutProcessorData>> GetPayoutProcessors(string storeId, CancellationToken token = default)
+    public partial class BTCPayServerClient
     {
-        return await SendHttpRequest<IEnumerable<PayoutProcessorData>>($"api/v1/stores/{storeId}/payout-processors", null, HttpMethod.Get, token);
-    }
-
-    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<LightningAutomatedPayoutSettings>> GetStoreLightningAutomatedPayoutProcessors(string storeId, string? payoutMethodId = null, CancellationToken token = default)
-    {
-        return await SendHttpRequest<IEnumerable<LightningAutomatedPayoutSettings>>($"api/v1/stores/{storeId}/payout-processors/LightningAutomatedPayoutSenderFactory{(payoutMethodId is null ? string.Empty : $"/{payoutMethodId}")}", null, HttpMethod.Get, token);
-    }
-
-    public virtual async Task<LightningAutomatedPayoutSettings> UpdateStoreLightningAutomatedPayoutProcessors(string storeId, string payoutMethodId, LightningAutomatedPayoutSettings request, CancellationToken token = default)
-    {
-        return await SendHttpRequest<LightningAutomatedPayoutSettings>($"api/v1/stores/{storeId}/payout-processors/LightningAutomatedPayoutSenderFactory/{payoutMethodId}", request, HttpMethod.Put, token);
-    }
-
-    public virtual async Task<OnChainAutomatedPayoutSettings> UpdateStoreOnChainAutomatedPayoutProcessors(string storeId, string paymentMethod, OnChainAutomatedPayoutSettings request, CancellationToken token = default)
-    {
-        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);
+        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);
+        }
+        
+        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<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);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.StoreRatesConfiguration.cs

@@ -4,34 +4,50 @@ using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client;
-
-public partial class BTCPayServerClient
+namespace BTCPayServer.Client
 {
-    public virtual async Task<StoreRateConfiguration> GetStoreRateConfiguration(string storeId, CancellationToken token = default)
+    public partial class BTCPayServerClient
     {
-        return await SendHttpRequest<StoreRateConfiguration>($"api/v1/stores/{storeId}/rates/configuration", null, HttpMethod.Get, token);
-    }
+        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);
+        }
 
-    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<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<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<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<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 = 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);
+        public virtual async Task<List<StoreRatePreviewResult>> 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<StoreRatePreviewResult>>(response);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.StoreUsers.cs

@@ -5,34 +5,33 @@ using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client;
-
-public partial class BTCPayServerClient
+namespace BTCPayServer.Client
 {
-    public virtual async Task<List<RoleData>> GetStoreRoles(string storeId, CancellationToken token = default)
+    public partial class BTCPayServerClient
     {
-        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)
-    {
-        return await SendHttpRequest<IEnumerable<StoreUserData>>($"api/v1/stores/{storeId}/users", 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 RemoveStoreUser(string storeId, string userId, CancellationToken token = default)
-    {
-        await SendHttpRequest($"api/v1/stores/{storeId}/users/{userId}", null, HttpMethod.Delete, 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 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);
-    }
-
-    public virtual async Task UpdateStoreUser(string storeId, string userId, StoreUserData request, CancellationToken token = default)
-    {
-        if (request == null) throw new ArgumentNullException(nameof(request));
-        await SendHttpRequest<StoreUserData>($"api/v1/stores/{storeId}/users/{userId}", request, HttpMethod.Put, token);
+        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);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.Stores.cs

@@ -5,45 +5,47 @@ using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client;
-
-public partial class BTCPayServerClient
+namespace BTCPayServer.Client
 {
-    public virtual async Task<IEnumerable<StoreData>> GetStores(CancellationToken token = default)
+    public partial class BTCPayServerClient
     {
-        return await SendHttpRequest<IEnumerable<StoreData>>("api/v1/stores", null, HttpMethod.Get, token);
-    }
+        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);
+        }
 
-    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<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 RemoveStore(string storeId, CancellationToken token = default)
-    {
-        await SendHttpRequest($"api/v1/stores/{storeId}", null, HttpMethod.Delete, 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<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> 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> 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> 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> 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,68 +4,51 @@ using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client;
-
-public partial class BTCPayServerClient
+namespace BTCPayServer.Client
 {
-    public virtual async Task<ApplicationUserData> GetCurrentUser(CancellationToken token = default)
+    public partial class BTCPayServerClient
     {
-        return await SendHttpRequest<ApplicationUserData>("api/v1/users/me", null, HttpMethod.Get, token);
-    }
+        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);
+        }
 
-    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<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> 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 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 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<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 DeleteUser(string userId, CancellationToken token = default)
-    {
-        await SendHttpRequest($"api/v1/users/{userId}", null, HttpMethod.Delete, token);
-    }
+        public virtual async Task 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);
+        }
 
-    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<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<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);
+        public virtual async Task DeleteCurrentUser(CancellationToken token = default)
+        {
+            await DeleteUser("me", token);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.Webhooks.cs

@@ -3,56 +3,61 @@ using System.Threading;
 using System.Threading.Tasks;
 using BTCPayServer.Client.Models;
 
-namespace BTCPayServer.Client;
-
-public partial class BTCPayServerClient
+namespace BTCPayServer.Client
 {
-    public virtual async Task<StoreWebhookData> CreateWebhook(string storeId, CreateStoreWebhookRequest create, CancellationToken token = default)
+    public partial class BTCPayServerClient
     {
-        return await SendHttpRequest<StoreWebhookData>($"api/v1/stores/{storeId}/webhooks", create, HttpMethod.Post, token);
-    }
+        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);
+        }
 
-    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);
+        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);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.IO;
 using System.Linq;
 using System.Net.Http;
 using System.Net.Http.Headers;
@@ -10,192 +9,153 @@ using System.Threading;
 using System.Threading.Tasks;
 using Newtonsoft.Json;
 
-namespace BTCPayServer.Client;
-
-public partial class BTCPayServerClient
+namespace BTCPayServer.Client
 {
-    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)
+    public partial class BTCPayServerClient
     {
-        if (btcpayHost == null) throw new ArgumentNullException(nameof(btcpayHost));
-        _btcpayHost = btcpayHost;
-        _httpClient = httpClient ?? new HttpClient();
-    }
+        private readonly string _apiKey;
+        private readonly Uri _btcpayHost;
+        private readonly string _username;
+        private readonly string _password;
+        private readonly HttpClient _httpClient;
+        public Uri Host => _btcpayHost;
 
-    public BTCPayServerClient(Uri btcpayHost, string APIKey, HttpClient httpClient = null)
-    {
-        _apiKey = APIKey;
-        _btcpayHost = btcpayHost;
-        _httpClient = httpClient ?? new HttpClient();
-    }
+        public string APIKey => _apiKey;
 
-    public BTCPayServerClient(Uri btcpayHost, string username, string password, HttpClient httpClient = null)
-    {
-        _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)
+        public BTCPayServerClient(Uri btcpayHost, HttpClient httpClient = null)
         {
-            if (message.StatusCode == System.Net.HttpStatusCode.UnprocessableEntity)
+            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();
+        }
+
+        protected async Task HandleResponse(HttpResponseMessage message)
+        {
+            if (!message.IsSuccessStatusCode && message.Content?.Headers?.ContentType?.MediaType?.StartsWith("application/json", StringComparison.OrdinalIgnoreCase) is true)
             {
-                var aa = await message.Content.ReadAsStringAsync();
-                var err = JsonConvert.DeserializeObject<Models.GreenfieldValidationError[]>(aa);
-                throw new GreenfieldValidationException(err);
+                if (message.StatusCode == System.Net.HttpStatusCode.UnprocessableEntity)
+                {
+                    var err = JsonConvert.DeserializeObject<Models.GreenfieldValidationError[]>(await message.Content.ReadAsStringAsync());
+                    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);
+                }
             }
-            if (message.StatusCode == System.Net.HttpStatusCode.Forbidden)
+            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())
             {
-                var err = JsonConvert.DeserializeObject<Models.GreenfieldPermissionAPIError>(await message.Content.ReadAsStringAsync());
-                throw new GreenfieldAPIException((int)message.StatusCode, err);
+                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()) + "&";
+                }
             }
             else
-            {
-                var err = JsonConvert.DeserializeObject<Models.GreenfieldAPIError>(await message.Content.ReadAsStringAsync());
-                if (err.Code != null)
-                    throw new GreenfieldAPIException((int)message.StatusCode, err);
-            }
-        }
-        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);
-        }
-
-        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", 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();
-        using 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)
             {
                 uriBuilder.Query = uriBuilder.Query + Uri.EscapeDataString(keyValuePair.Key) + "=" +
-                                   Uri.EscapeDataString(item.ToString()) + "&";
+                                   Uri.EscapeDataString(keyValuePair.Value.ToString()) + "&";
             }
+            uri.Query = uri.Query.Trim('&');
         }
-        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)
+        public static void AppendPayloadToQuery(UriBuilder uri, Dictionary<string, object> payload)
         {
-            AppendPayloadToQuery(uri, keyValuePair);
+            if (uri.Query.Length > 1)
+                uri.Query += "&";
+            foreach (KeyValuePair<string, object> keyValuePair in payload)
+            {
+                AppendPayloadToQuery(uri, keyValuePair);
+            }
         }
     }
 }

BTCPayServer.Client/GreenFieldAPIException.cs

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