Merge branch 'master' into igiownq

.circleci/config.yml

@@ -31,23 +31,79 @@ jobs:
       - run:
           command: |
             curl -X POST -H "Authorization: token $GH_PAT" -H "Accept: application/vnd.github.everest-preview+json" -H "Content-Type: application/json" https://api.github.com/repos/btcpayserver/btcpayserver-doc/dispatches --data '{"event_type": "build_docs"}'
+
   # publish jobs require $DOCKERHUB_REPO, $DOCKERHUB_USER, $DOCKERHUB_PASS defined
-  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-]+)/

.gitignore

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

.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.6" />
-    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="8.0.4" />
+    <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

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

BTCPayServer.Abstractions/Contracts/BaseDbContextFactory.cs

@@ -1,11 +1,10 @@
 using System;
+using System.Data.Common;
 using BTCPayServer.Abstractions.Models;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata;
 using Microsoft.EntityFrameworkCore.Migrations;
 using Microsoft.Extensions.Options;
-using Npgsql;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Infrastructure;
 using Npgsql.EntityFrameworkCore.PostgreSQL.Migrations;
 using Npgsql.EntityFrameworkCore.PostgreSQL.Migrations.Operations;
 
@@ -14,16 +13,15 @@ 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

@@ -2,7 +2,6 @@
 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

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

BTCPayServer.Abstractions/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/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/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,12 @@
+namespace BTCPayServer.Abstractions.Custodians;
+
+public class AssetBalancesUnavailableException : CustodianApiException
+{
+    public AssetBalancesUnavailableException(System.Exception e) : base(500, "asset-balances-unavailable", $"Cannot fetch the asset balances: {e.Message}", e)
+    {
+    }
+
+    public AssetBalancesUnavailableException(string errorMsg) : base(500, "asset-balances-unavailable", $"Cannot fetch the asset balances: {errorMsg}")
+    {
+    }
+}

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

@@ -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,18 @@
+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,8 @@
+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,8 @@
+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/SimulateWithdrawalResult.cs

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

BTCPayServer.Abstractions/Custodians/Client/WithdrawResult.cs

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

BTCPayServer.Abstractions/Custodians/ICustodian.cs

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

BTCPayServer.Abstractions/Extensions/CustodianExtensions.cs

@@ -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/HttpRequestExtensions.cs

@@ -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/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)

BTCPayServer.Abstractions/Form/Form.cs

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

BTCPayServer.Abstractions/Models/DatabaseOptions.cs

@@ -2,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/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/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,51 @@ 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 = "[not-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) && string.IsNullOrEmpty(NotPermission))
             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 expectedResult = !string.IsNullOrEmpty(Permission);
+        var key = $"{Permission??NotPermission}_{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 (expectedResult != 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.Client/BTCPayServer.Client.csproj

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

BTCPayServer.Client/BTCPayServerClient.APIKeys.cs

@@ -1,44 +1,58 @@
 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<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<ApiKeyData> CreateAPIKey(string userId, CreateApiKeyRequest request, CancellationToken token = default)
+        {
+            if (request == null)
+                throw new ArgumentNullException(nameof(request));
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/users/{userId}/api-keys",
+            bodyPayload: request, method: HttpMethod.Post), token);
+            return await HandleResponse<ApiKeyData>(response);
+        }
 
-    public virtual async Task RevokeCurrentAPIKeyInfo(CancellationToken token = default)
-    {
-        await SendHttpRequest("api/v1/api-keys/current", null, HttpMethod.Delete, 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 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);
+        }
+        public virtual async Task RevokeAPIKey(string userId, string apikey, CancellationToken token = default)
+        {
+            if (apikey == null)
+                throw new ArgumentNullException(nameof(apikey));
+            if (userId is null)
+                throw new ArgumentNullException(nameof(userId));
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/users/{userId}/api-keys/{apikey}", null, HttpMethod.Delete), token);
+            await HandleResponse(response);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.Apps.cs

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

BTCPayServer.Client/BTCPayServerClient.Custodians.cs

@@ -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,101 +5,142 @@ 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 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)
-        {
-            queryPayload.Add("offsetIndex", offsetIndex);
-        }
-        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<LightningNodeBalanceData> GetLightningNodeBalance(string cryptoCode,
+            CancellationToken token = default)
         {
-            queryPayload.Add("includePending", v.ToString());
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/balance",
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<LightningNodeBalanceData>(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 ConnectToLightningNode(string cryptoCode, ConnectToNodeRequest request,
+            CancellationToken token = default)
+        {
+            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);
+        }
+
+        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<LightningPaymentData[]> GetLightningPayments(string cryptoCode,
+            bool? includePending = null, long? offsetIndex = null, CancellationToken token = default)
+        {
+            var queryPayload = new Dictionary<string, object>();
+            if (includePending is bool v)
+            {
+                queryPayload.Add("includePending", v.ToString());
+            }
+            if (offsetIndex is > 0)
+            {
+                queryPayload.Add("offsetIndex", offsetIndex);
+            }
+
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/payments", queryPayload), token);
+            return await HandleResponse<LightningPaymentData[]>(response);
+        }
+
+        public virtual async Task<LightningInvoiceData> CreateLightningInvoice(string cryptoCode, CreateLightningInvoiceRequest request,
+            CancellationToken token = default)
+        {
+            if (request == null)
+                throw new ArgumentNullException(nameof(request));
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/invoices", bodyPayload: request,
+                    method: HttpMethod.Post), token);
+            return await HandleResponse<LightningInvoiceData>(response);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.Lightning.Store.cs

@@ -5,102 +5,144 @@ 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 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)
-        {
-            queryPayload.Add("offsetIndex", offsetIndex);
-        }
-        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<LightningNodeBalanceData> GetLightningNodeBalance(string storeId, string cryptoCode,
+            CancellationToken token = default)
         {
-            queryPayload.Add("includePending", v.ToString());
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/balance",
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<LightningNodeBalanceData>(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 ConnectToLightningNode(string storeId, string cryptoCode, ConnectToNodeRequest request,
+            CancellationToken token = default)
+        {
+            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);
+        }
+
+        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<LightningPaymentData[]> GetLightningPayments(string storeId, string cryptoCode,
+            bool? includePending = null, long? offsetIndex = null, CancellationToken token = default)
+        {
+            var queryPayload = new Dictionary<string, object>();
+            if (includePending is bool v)
+            {
+                queryPayload.Add("includePending", v.ToString());
+            }
+            if (offsetIndex is > 0)
+            {
+                queryPayload.Add("offsetIndex", offsetIndex);
+            }
+
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/payments", queryPayload), token);
+            return await HandleResponse<LightningPaymentData[]>(response);
+        }
+
+        public virtual async Task<LightningInvoiceData> CreateLightningInvoice(string storeId, string cryptoCode,
+            CreateLightningInvoiceRequest request, CancellationToken token = default)
+        {
+            if (request == null)
+                throw new ArgumentNullException(nameof(request));
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/invoices", bodyPayload: request,
+                    method: HttpMethod.Post), token);
+            return await HandleResponse<LightningInvoiceData>(response);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.LightningAddresses.cs

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

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,105 +7,134 @@ 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<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,107 @@ 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 MarkPayoutPaid(string storeId, string payoutId,
+            CancellationToken cancellationToken = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest(
+                    $"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/payouts/{HttpUtility.UrlEncode(payoutId)}/mark-paid",
+                    method: HttpMethod.Post), cancellationToken);
+            await HandleResponse(response);
+        }
+        public virtual async Task MarkPayout(string storeId, string payoutId, MarkPayoutRequest request,
+            CancellationToken cancellationToken = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest(
+                    $"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/payouts/{HttpUtility.UrlEncode(payoutId)}/mark",
+                    method: HttpMethod.Post, bodyPayload: request), cancellationToken);
+            await HandleResponse(response);
+        }
 
-    public virtual async Task<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<PullPaymentLNURL> GetPullPaymentLNURL(string pullPaymentId,
+            CancellationToken cancellationToken = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest(
+                    $"/api/v1/pull-payments/{pullPaymentId}/lnurl",
+                    method: HttpMethod.Get), cancellationToken);
+            return await HandleResponse<PullPaymentLNURL>(response);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.ServerInfo.cs

@@ -1,20 +1,22 @@
 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<ServerInfoData> GetServerInfo(CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest("api/v1/server/info"), token);
+            return await HandleResponse<ServerInfoData>(response);
+        }
         
-    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<List<RoleData>> GetServerRoles(CancellationToken token = default)
+        {
+            using var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/server/roles"), token);
+            return await HandleResponse<List<RoleData>>(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<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 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? 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<LightningAutomatedPayoutSettings>> GetStoreLightningAutomatedPayoutProcessors(string storeId, string? paymentMethod = null, CancellationToken token = default)
-    {
-        return await SendHttpRequest<IEnumerable<LightningAutomatedPayoutSettings>>($"api/v1/stores/{storeId}/payout-processors/LightningAutomatedPayoutSenderFactory{(paymentMethod is null ? string.Empty : $"/{paymentMethod}")}", null, HttpMethod.Get, token);
-    }
-
-    public virtual async Task<LightningAutomatedPayoutSettings> UpdateStoreLightningAutomatedPayoutProcessors(string storeId, string paymentMethod, LightningAutomatedPayoutSettings request, CancellationToken token = default)
-    {
-        return await SendHttpRequest<LightningAutomatedPayoutSettings>($"api/v1/stores/{storeId}/payout-processors/LightningAutomatedPayoutSenderFactory/{paymentMethod}", request, HttpMethod.Put, token);
-    }
-
-    public virtual async Task<OnChainAutomatedPayoutSettings> UpdateStoreOnChainAutomatedPayoutProcessors(string storeId, string paymentMethod, OnChainAutomatedPayoutSettings request, CancellationToken token = default)
-    {
-        return await SendHttpRequest<OnChainAutomatedPayoutSettings>($"api/v1/stores/{storeId}/payout-processors/OnChainAutomatedPayoutSenderFactory/{paymentMethod}", request, HttpMethod.Put, token);
-    }
-
-    public virtual async Task<IEnumerable<OnChainAutomatedPayoutSettings>> GetStoreOnChainAutomatedPayoutProcessors(string storeId, string? paymentMethod = null, CancellationToken token = default)
-    {
-        return await SendHttpRequest<IEnumerable<OnChainAutomatedPayoutSettings>>($"api/v1/stores/{storeId}/payout-processors/OnChainAutomatedPayoutSenderFactory{(paymentMethod is null ? string.Empty : $"/{paymentMethod}")}", null, HttpMethod.Get, token);
+        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,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<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>> PreviewUpdateStoreRateConfiguration(string storeId,
+            StoreRateConfiguration request,
+            string[] currencyPair,
+            CancellationToken token = default)
+        {
+            using var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/rates/configuration/preview", bodyPayload: request,
+                    queryPayload: new Dictionary<string, object>() { { "currencyPair", currencyPair } },
+                    method: HttpMethod.Post),
+                token);
+            return await HandleResponse<List<StoreRateResult>>(response);
+        }
 
-    public virtual async Task<List<StoreRateResult>> 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<StoreRateResult>> GetStoreRates(string storeId, string[] currencyPair,
+            CancellationToken token = default)
+        {
+            using var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/rates",
+                    queryPayload: new Dictionary<string, object>() { { "currencyPair", currencyPair } },
+                    method: HttpMethod.Get),
+                token);
+            return await HandleResponse<List<StoreRateResult>>(response);
+        }
     }
 }

BTCPayServer.Client/BTCPayServerClient.StoreUsers.cs

@@ -5,28 +5,40 @@ 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<List<RoleData>> GetStoreRoles(string storeId,
+            CancellationToken token = default)
+        {
+            using var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/roles"), token);
+            return await HandleResponse<List<RoleData>>(response);
+        }
         
-    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 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,52 @@ 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<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<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,154 @@ 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 aa = await message.Content.ReadAsStringAsync();
+                    var err = JsonConvert.DeserializeObject<Models.GreenfieldValidationError[]>(aa);
+                    throw new GreenfieldValidationException(err);
+                }
+                if (message.StatusCode == System.Net.HttpStatusCode.Forbidden)
+                {
+                    var err = JsonConvert.DeserializeObject<Models.GreenfieldPermissionAPIError>(await message.Content.ReadAsStringAsync());
+                    throw new GreenfieldAPIException((int)message.StatusCode, err);
+                }
+                else
+                {
+                    var err = JsonConvert.DeserializeObject<Models.GreenfieldAPIError>(await message.Content.ReadAsStringAsync());
+                    if (err.Code != null)
+                        throw new GreenfieldAPIException((int)message.StatusCode, err);
+                }
             }
-            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();
-        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; }
 }

BTCPayServer.Client/GreenFieldValidationException.cs

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

BTCPayServer.Client/JsonConverters/SaneOutpointJsonConverter.cs

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

BTCPayServer.Client/JsonConverters/TimeSpanJsonConverter.cs

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

BTCPayServer.Client/JsonConverters/TradeQuantityJsonConverter.cs

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

BTCPayServer.Client/Models/AppBaseData.cs

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

BTCPayServer.Client/Models/AppItemStats.cs

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

BTCPayServer.Client/Models/AppSalesStats.cs

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

BTCPayServer.Client/Models/ApplicationUserData.cs

@@ -14,16 +14,6 @@ namespace BTCPayServer.Client.Models
         /// the email AND username of the user
         /// </summary>
         public string Email { get; set; }
-        
-        /// <summary>
-        /// the name of the user
-        /// </summary>
-        public string Name { get; set; }
-
-        /// <summary>
-        /// the image url of the user
-        /// </summary>
-        public string ImageUrl { get; set; }
 
         /// <summary>
         /// Whether the user has verified their email
@@ -35,16 +25,6 @@ namespace BTCPayServer.Client.Models
         /// </summary>
         public bool RequiresEmailConfirmation { get; set; }
 
-        /// <summary>
-        /// Whether the user was approved by an admin
-        /// </summary>
-        public bool Approved { get; set; }
-
-        /// <summary>
-        /// whether the user needed approval on account creation
-        /// </summary>
-        public bool RequiresApproval { get; set; }
-
         /// <summary>
         /// the roles of the user
         /// </summary>

BTCPayServer.Client/Models/ApproveUserRequest.cs

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

BTCPayServer.Client/Models/CreateAppRequest.cs

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

BTCPayServer.Client/Models/CreateApplicationUserRequest.cs

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

BTCPayServer.Client/Models/CreateCustodianAccountRequest.cs

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

BTCPayServer.Client/Models/CreateOnChainTransactionRequest.cs

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

BTCPayServer.Client/Models/CreatePayoutRequest.cs

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

BTCPayServer.Client/Models/CreatePayoutThroughStoreRequest.cs

@@ -1,11 +1,8 @@
 #nullable enable
-using Newtonsoft.Json.Linq;
-
 namespace BTCPayServer.Client.Models;
 
 public class CreatePayoutThroughStoreRequest : CreatePayoutRequest
 {
     public string? PullPaymentId { get; set; }
     public bool? Approved { get; set; }
-    public JObject? Metadata { get; set; }
 }

BTCPayServer.Client/Models/CreatePullPaymentRequest.cs

@@ -12,6 +12,8 @@ namespace BTCPayServer.Client.Models
         [JsonProperty(ItemConverterType = typeof(NumericStringJsonConverter))]
         public decimal Amount { get; set; }
         public string Currency { get; set; }
+        [JsonConverter(typeof(TimeSpanJsonConverter.Seconds))]
+        public TimeSpan? Period { get; set; }
         [JsonConverter(typeof(TimeSpanJsonConverter.Days))]
         [JsonProperty("BOLT11Expiration")]
         public TimeSpan? BOLT11Expiration { get; set; }
@@ -19,7 +21,7 @@ namespace BTCPayServer.Client.Models
         public DateTimeOffset? ExpiresAt { get; set; }
         [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
         public DateTimeOffset? StartsAt { get; set; }
-        public string[] PayoutMethods { get; set; }
+        public string[] PaymentMethods { get; set; }
         public bool AutoApproveClaims { get; set; }
     }
 }

BTCPayServer.Client/Models/CrowdfundAppData.cs

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

BTCPayServer.Client/Models/CustodianAccountBaseData.cs

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

BTCPayServer.Client/Models/CustodianAccountData.cs

@@ -0,0 +1,7 @@
+namespace BTCPayServer.Client.Models
+{
+    public class CustodianAccountData : CustodianAccountBaseData
+    {
+        public string Id { get; set; }
+    }
+}

BTCPayServer.Client/Models/CustodianAccountResponse.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+
+namespace BTCPayServer.Client.Models;
+
+public class CustodianAccountResponse : CustodianAccountData
+{
+    public IDictionary<string, decimal> AssetBalances { get; set; }
+
+    public CustodianAccountResponse()
+    {
+
+    }
+
+}

BTCPayServer.Client/Models/CustodianData.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+
+namespace BTCPayServer.Client.Models;
+
+public class CustodianData
+{
+    public string Code { get; set; }
+    public string Name { get; set; }
+    public Dictionary<string, AssetPairData> TradableAssetPairs { get; set; }
+    public string[] WithdrawablePaymentMethods { get; set; }
+    public string[] DepositablePaymentMethods { get; set; }
+
+}

BTCPayServer.Client/Models/DepositAddressData.cs

@@ -0,0 +1,15 @@
+namespace BTCPayServer.Client.Models;
+
+public class DepositAddressData
+{
+    // /**
+    // * Example: P2PKH, P2SH, P2WPKH, P2TR, BOLT11, ...
+    // */
+    // public string Type { get; set; }
+
+    /**
+     * Format depends hugely on the type.
+     */
+    public string Address { get; set; }
+
+}

BTCPayServer.Client/Models/EmailSettingsData.cs

@@ -1,5 +1,3 @@
-using Newtonsoft.Json;
-
 namespace BTCPayServer.Client.Models;
 
 public class EmailSettingsData
@@ -28,11 +26,4 @@ public class EmailSettingsData
         get; set;
     }
     public bool DisableCertificateCheck { get; set; }
-
-    [JsonIgnore]
-    public bool EnabledCertificateCheck
-    {
-        get => !DisableCertificateCheck;
-        set { DisableCertificateCheck = !value; }
-    }
 }

BTCPayServer.Client/Models/FileData.cs

@@ -1,16 +0,0 @@
-using System;
-using Newtonsoft.Json;
-
-namespace BTCPayServer.Client.Models;
-
-public class FileData
-{
-    public string Id { get; set; }
-    public string UserId { get; set; }
-    public string Uri { get; set; }
-    public string Url { get; set; }
-    public string OriginalName { get; set; }
-    public string StorageName { get; set; }
-    [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
-    public DateTimeOffset? CreatedAt { get; set; }
-}

BTCPayServer.Client/Models/GenerateOnChainWalletRequest.cs

@@ -1,16 +1,12 @@
-using System.Collections.Generic;
 using BTCPayServer.Client.JsonConverters;
-using BTCPayServer.Client.Models;
 using NBitcoin;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
-using Newtonsoft.Json.Linq;
 
 namespace BTCPayServer.Client
 {
     public class GenerateOnChainWalletRequest
     {
-        public string Label { get; set; }
         public int AccountNumber { get; set; } = 0;
         [JsonConverter(typeof(MnemonicJsonConverter))]
         public Mnemonic ExistingMnemonic { get; set; }
@@ -26,17 +22,4 @@ namespace BTCPayServer.Client
         public bool ImportKeysToRPC { get; set; }
         public bool SavePrivateKeys { get; set; }
     }
-    public class GenerateOnChainWalletResponse : GenericPaymentMethodData
-    {
-        public class ConfigData
-        {
-            public string Label { get; set; }
-            public string AccountDerivation { get; set; }
-            [JsonExtensionData]
-            IDictionary<string, JToken> AdditionalData { get; set; }
-        }
-        [JsonConverter(typeof(MnemonicJsonConverter))]
-        public Mnemonic Mnemonic { get; set; }
-        public new ConfigData Config { get; set; }
-    }
 }