Changelog and new release (#2204)

* Changelog and new release

* Update Changelog.md

.circleci/can-build.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+set -e
+
+echo "Checking if it is possible to build Bitcoin only..."
+cd ../BTCPayServer.Tests
+docker-compose -f "docker-compose.yml" build

.circleci/config.yml

@@ -7,7 +7,7 @@ jobs:
       - checkout
       - run:
           command: |
-            cd .circleci && ./run-tests.sh "Fast=Fast"
+            cd .circleci && ./run-tests.sh "Fast=Fast" && ./can-build.sh
   selenium_tests:
     machine:
         enabled: true
@@ -49,8 +49,10 @@ jobs:
             LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
             #
             sudo docker build --pull -t $DOCKERHUB_REPO:$LATEST_TAG-amd64 -f amd64.Dockerfile .
+            sudo docker build --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:
@@ -63,8 +65,26 @@ jobs:
             LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
             #
             sudo docker build --pull -t $DOCKERHUB_REPO:$LATEST_TAG-arm32v7 -f arm32v7.Dockerfile .
+            sudo docker build --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:
+        enabled: true
+    steps:
+      - checkout  
+      - run:
+          command: |
+            sudo docker run --rm --privileged multiarch/qemu-user-static:register --reset
+            LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
+            #
+            sudo docker build --pull -t $DOCKERHUB_REPO:$LATEST_TAG-arm64v8 -f arm64v8.Dockerfile .
+            sudo docker build --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:
@@ -80,10 +100,18 @@ jobs:
             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
+            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
@@ -96,7 +124,6 @@ workflows:
           filters:
             branches:
                 only: master
-
   publish:
     jobs:
       - amd64:
@@ -104,22 +131,31 @@ workflows:
             # ignore any commit on any branch by default
             branches:
               ignore: /.*/
-            # only act on version tags v1.0.0.88
+            # only act on version tags v1.0.0.88 or v1.0.2-1
             # OR feature tags like vlndseedbackup
+            # OR features on specific versions like v1.0.0.88-lndseedbackup-1
             tags:
-              only: /(v[1-9]+(\.[0-9]+)*)|(v[a-z]+)/
+
+              only: /(v[1-9]+(\.[0-9]+)*(-[a-z0-9-]+)?)|(v[a-z0-9-]+)/
       - arm32v7:
           filters:
             branches:
               ignore: /.*/
             tags:
-              only: /(v[1-9]+(\.[0-9]+)*)|(v[a-z]+)/
-      - multiarch:
-          requires:
-            - amd64
-            - arm32v7
+              only: /(v[1-9]+(\.[0-9]+)*(-[a-z0-9-]+)?)|(v[a-z0-9-]+)/
+      - arm64v8:
           filters:
             branches:
               ignore: /.*/
             tags:
-              only: /(v[1-9]+(\.[0-9]+)*)|(v[a-z]+)/
+              only: /(v[1-9]+(\.[0-9]+)*(-[a-z0-9-]+)?)|(v[a-z0-9-]+)/
+      - multiarch:
+          requires:
+            - amd64
+            - arm32v7
+            - arm64v8
+          filters:
+            branches:
+              ignore: /.*/
+            tags:
+              only: /(v[1-9]+(\.[0-9]+)*(-[a-z0-9-]+)?)|(v[a-z0-9-]+)/

.circleci/run-tests.sh

@@ -3,7 +3,7 @@ set -e
 
 cd ../BTCPayServer.Tests
 docker-compose -v
-docker-compose down --v
-docker-compose pull
-docker-compose build
-docker-compose run -e "TEST_FILTERS=$1" tests
+docker-compose -f "docker-compose.altcoins.yml" down --v
+docker-compose -f "docker-compose.altcoins.yml" pull
+docker-compose -f "docker-compose.altcoins.yml" build
+docker-compose -f "docker-compose.altcoins.yml" run -e "TEST_FILTERS=$1" tests

.editorconfig

@@ -10,8 +10,9 @@ root = true
 insert_final_newline = true
 indent_style = space
 indent_size = 4
+charset = utf-8
 
-[project.json]
+[launchSettings.json]
 indent_size = 2
 
 # C# files
@@ -146,4 +147,4 @@ indent_size = 2
 [*.sh]
 end_of_line = lf
 [*.{cmd, bat}]
-end_of_line = crlf
+end_of_line = crlf

.github/ISSUE_TEMPLATE/bug-report.md

@@ -0,0 +1,63 @@
+---
+name: "\U0001F41B Bug report"
+about: Report a bug or a technical issue
+
+---
+
+<!--
+Thank you for reporting a technical issue.
+
+This issue tracker is only for bug reports and problems. 
+
+For general questions please read our documentation docs.btcpayserver.org. You can ask technical questions in discussions https://github.com/btcpayserver/btcpayserver/discussions and general support on our community chat chat.btcpayserver.org
+
+Please fill in as much of the template below as you're able. 
+-->
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce the bug**
+Steps to reproduce the reported bug:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+
+<!--
+A clear and concise description of what you expected to happen.
+-->
+
+**Screenshots**
+
+
+<!--
+If applicable, add screenshots to help explain your problem.
+-->
+
+**Your BTCPay Environment (please complete the following information):**
+- BTCPay Server Version:    <!--[available in the right bottom corner of footer] -->
+- Deployment Method:        <!--[e.g. Docker, Manual, Third-Party-host]-->
+- Browser:                  <!--[e.g. Chrome, Safari]-->
+
+**Logs (if applicable)**
+
+
+<!--
+Basic logs can be found in Server Settings > Logs. 
+More logs https://docs.btcpayserver.org/Troubleshooting/#2-looking-through-the-logs
+-->
+
+**Setup Parameters**
+
+<!--
+If you're reporting a deployment issue run `. btcpay-setup.sh -i` and paste the setup parameters here with your private information removed or obscured.
+-->
+
+**Additional context**
+
+<!--
+Add any other context about the problem here.
+-->

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,34 +0,0 @@
----
-name: Report a problem
-about: File a technical problem or report a bug
----
-
-**Describe the problem/bug**
-A clear and concise description of what the bug is.
-
-**Your environment**
-* Version of BTCPay Server:
-* Deployment method: 
-* Other relevant environment details:
-
-**Logs (if applicable)**
-Basic logs can be found in Server Settings > Logs.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. Go to '...'
-2. Click on '....'
-3. Scroll down to '....'
-4. See error
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Actual behavior**
-Tell us what happens instead
-
-**Screenshots/Links**
-If applicable, add screenshots or links to help explain your problem.
-
-**Additional context**
-Add any other context about the problem here.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,11 @@
+blank_issues_enabled: false
+contact_links: 
+  - name: 🚀 Discussions  
+    url: https://github.com/btcpayserver/btcpayserver/discussions
+    about: Technical discussions, questions and feature requests    
+  - name: 📝 Official Documentation
+    url: https://docs.btcpayserver.org
+    about: Check our documentation for answers to common questions 
+  - name: 💬 Community Support Chat  
+    url: https://chat.btcpayserver.org/
+    about: Ask general questions and get community support in real-time

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,20 +0,0 @@
----
-name: Feature request
-about: Ideas and feature requests
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Provide examples**
-If applicable provide examples, wireframes, sketches or images to better explain your idea.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.gitignore

@@ -292,4 +292,10 @@ __pycache__/
 BTCPayServer/wwwroot/bundles/*
 !BTCPayServer/wwwroot/bundles/.gitignore
 
-.vscode
+.vscode/*
+!.vscode/launch.json
+!.vscode/tasks.json
+!.vscode/extensions.json
+BTCPayServer/testpwd
+.DS_Store
+Packed Plugins

.run/Pack Test Extension.run.xml

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

.vscode/extensions.json

@@ -0,0 +1,3 @@
+{
+    "recommendations": ["ms-dotnettools.csharp"]
+}

.vscode/launch.json

@@ -0,0 +1,33 @@
+{
+    // Use IntelliSense to find out which attributes exist for C# debugging
+    // Use hover for the description of the existing attributes
+    // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": ".NET Core Launch (web)",
+            "type": "coreclr",
+            "request": "launch",
+            "preLaunchTask": "build",
+            // If you have changed target frameworks, make sure to update the program path.
+            "program": "${workspaceFolder}/BTCPayServer/bin/Debug/netcoreapp3.1/BTCPayServer.dll",
+            "args": [],
+            "cwd": "${workspaceFolder}/BTCPayServer",
+            "stopAtEntry": false,
+            // Enable launching a web browser when ASP.NET Core starts. For more information: https://aka.ms/VSCode-CS-LaunchJson-WebBrowser
+            "serverReadyAction": {
+                "action": "openExternally",
+                "pattern": "\\bListening on\\s+(https?://\\S+)"
+            },
+            "env": {
+                "ASPNETCORE_ENVIRONMENT": "Development"
+            },
+            "sourceFileMap": {
+                "/Views": "${workspaceFolder}/Views"
+            },
+            "logging": {
+                "moduleLoad": false
+            }
+        }
+    ]
+}

.vscode/tasks.json

@@ -0,0 +1,42 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "build",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "build",
+                "${workspaceFolder}/BTCPayServer/BTCPayServer.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "publish",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "publish",
+                "${workspaceFolder}/BTCPayServer/BTCPayServer.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "watch",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "watch",
+                "run",
+                "${workspaceFolder}/BTCPayServer/BTCPayServer.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        }
+    ]
+}

BTCPayServer.Abstractions/BTCPayServer.Abstractions.csproj

@@ -0,0 +1,39 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../Build/Version.csproj" Condition="Exists('../Build/Version.csproj')" />
+  <Import Project="../Build/Common.csproj" />
+
+  <PropertyGroup>
+    <Company>BTCPay Server</Company>
+    <Copyright>Copyright © BTCPay Server 2020</Copyright>
+    <Description>A library for BTCPay Server plugin development</Description>
+    <PackageIcon>icon.png</PackageIcon>
+    <PackageTags>btcpay,btcpayserver</PackageTags>
+    <PackageProjectUrl>https://github.com/btcpayserver/btcpayserver/tree/master/BTCPayServer.Abstractions</PackageProjectUrl>
+    <PackageLicenseExpression>MIT</PackageLicenseExpression>
+    <RepositoryUrl>https://github.com/btcpayserver/btcpayserver</RepositoryUrl>
+    <RepositoryType>git</RepositoryType>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
+    <PublishRepositoryUrl>true</PublishRepositoryUrl>
+    <EmbedUntrackedSources>true</EmbedUntrackedSources>
+    <DebugType>portable</DebugType>
+    <Optimize>true</Optimize>
+    <NoWarn>1591;1573;1572;1584;1570;3021</NoWarn>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+  </PropertyGroup>  
+  <ItemGroup Condition=" '$(Configuration)' == 'Release' ">
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
+  </ItemGroup>
+  <ItemGroup>
+    <FrameworkReference Include="Microsoft.AspNetCore.App" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="icon.png" Pack="true" PackagePath="\" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="3.1.4" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="3.1.4" />
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="3.1.4" />
+    <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="3.1.1" />
+  </ItemGroup>
+</Project>

BTCPayServer.Abstractions/Configuration/DataDirectories.cs

@@ -0,0 +1,12 @@
+namespace BTCPayServer.Configuration
+{
+    public class DataDirectories
+    {
+        public string DataDir  { get; set; }
+        public string PluginDir  { get; set; }
+        public string TempStorageDir { get; set; }
+        public string StorageDir { get; set; }
+    }
+    
+    
+}

BTCPayServer.Abstractions/Constants/AuthenticationSchemes.cs

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

BTCPayServer.Abstractions/Contracts/BaseDbContextFactory.cs

@@ -0,0 +1,109 @@
+using System;
+using BTCPayServer.Abstractions.Models;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.Extensions.Options;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Migrations.Operations;
+
+namespace BTCPayServer.Abstractions.Contracts
+{
+    public abstract class BaseDbContextFactory<T> where T: DbContext
+    {
+        private readonly IOptions<DatabaseOptions> _options;
+        private readonly string _schemaPrefix;
+
+        public BaseDbContextFactory(IOptions<DatabaseOptions> options, string schemaPrefix)
+        {
+            _options = options;
+            _schemaPrefix = schemaPrefix;
+        }
+
+        public abstract T CreateContext();
+
+        class CustomNpgsqlMigrationsSqlGenerator : NpgsqlMigrationsSqlGenerator
+        {
+            public CustomNpgsqlMigrationsSqlGenerator(MigrationsSqlGeneratorDependencies dependencies, IMigrationsAnnotationProvider annotations, Npgsql.EntityFrameworkCore.PostgreSQL.Infrastructure.Internal.INpgsqlOptions opts) : base(dependencies, annotations, opts)
+            {
+            }
+
+            protected override void Generate(NpgsqlCreateDatabaseOperation operation, IModel model, MigrationCommandListBuilder builder)
+            {
+                builder
+                    .Append("CREATE DATABASE ")
+                    .Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Name));
+
+                // POSTGRES gotcha: Indexed Text column (even if PK) are not used if we are not using C locale
+                builder
+                    .Append(" TEMPLATE ")
+                    .Append(Dependencies.SqlGenerationHelper.DelimitIdentifier("template0"));
+
+                builder
+                    .Append(" LC_CTYPE ")
+                    .Append(Dependencies.SqlGenerationHelper.DelimitIdentifier("C"));
+
+                builder
+                    .Append(" LC_COLLATE ")
+                    .Append(Dependencies.SqlGenerationHelper.DelimitIdentifier("C"));
+
+                builder
+                    .Append(" ENCODING ")
+                    .Append(Dependencies.SqlGenerationHelper.DelimitIdentifier("UTF8"));
+
+                if (operation.Tablespace != null)
+                {
+                    builder
+                        .Append(" TABLESPACE ")
+                        .Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Tablespace));
+                }
+
+                builder.AppendLine(Dependencies.SqlGenerationHelper.StatementTerminator);
+
+                EndStatement(builder, suppressTransaction: true);
+            }
+        }
+
+        public void ConfigureBuilder(DbContextOptionsBuilder builder)
+        {
+            switch (_options.Value.DatabaseType)
+            {
+                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, o =>
+                    {
+                        o.EnableRetryOnFailure(10);
+                            
+                        if (!string.IsNullOrEmpty(_schemaPrefix))
+                        {
+                            o.MigrationsHistoryTable(_schemaPrefix);
+                        }
+                    });
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+        
+    }
+}

BTCPayServer.Abstractions/Contracts/IBTCPayServerPlugin.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Text.Json.Serialization;
+using BTCPayServer.Abstractions.Converters;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace BTCPayServer.Abstractions.Contracts
+{
+    public interface IBTCPayServerPlugin
+    {
+        public string Identifier { get; }
+        string Name { get; }
+        [JsonConverter(typeof(VersionConverter))]
+        Version Version { get; }
+        string Description { get; }
+        bool SystemPlugin { get; set; }
+        PluginDependency[] Dependencies { get; }
+        void Execute(IApplicationBuilder applicationBuilder, IServiceProvider applicationBuilderApplicationServices);
+        void Execute(IServiceCollection applicationBuilder);
+
+        public class PluginDependency
+        {
+            public string Identifier { get; set; }
+            public string Condition { get; set; }
+            public override string ToString()
+            {
+                return $"{Identifier}: {Condition}";
+            }
+        }
+    }
+    
+}

BTCPayServer.Abstractions/Contracts/INotificationHandler.cs

@@ -0,0 +1,27 @@
+using System;
+
+namespace BTCPayServer.Abstractions.Contracts
+{
+    public abstract class BaseNotification
+    {
+        public abstract string Identifier { get; }
+        public abstract string NotificationType { get; }
+    }
+    
+    public interface INotificationHandler
+    {
+        string NotificationType { get; }
+        Type NotificationBlobType { get; }
+        public (string identifier, string name)[] Meta { get; }
+        void FillViewModel(object notification, NotificationViewModel vm);
+    }
+    
+    public class NotificationViewModel
+    {
+        public string Id { get; set; }
+        public DateTimeOffset Created { get; set; }
+        public string Body { get; set; }
+        public string ActionLink { get; set; }
+        public bool Seen { get; set; }
+    }
+}

BTCPayServer.Abstractions/Contracts/IPluginHookAction.cs

@@ -0,0 +1,10 @@
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Abstractions.Contracts
+{
+    public interface IPluginHookAction
+    {
+        public string Hook { get; }
+        Task Execute(object args);
+    }
+}

BTCPayServer.Abstractions/Contracts/IPluginHookFilter.cs

@@ -0,0 +1,11 @@
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Abstractions.Contracts
+{
+    public interface IPluginHookFilter
+    {
+        public string Hook { get; }
+        
+        Task<object> Execute(object args);
+    }
+}

BTCPayServer.Abstractions/Contracts/IPluginHookService.cs

@@ -0,0 +1,10 @@
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Abstractions.Contracts
+{
+    public interface IPluginHookService
+    {
+        Task ApplyAction(string hook, object args);
+        Task<object> ApplyFilter(string hook, object args);
+    }
+}

BTCPayServer.Abstractions/Contracts/ISettingsRepository.cs

@@ -0,0 +1,12 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Abstractions.Contracts
+{
+    public interface ISettingsRepository
+    {
+        Task<T> GetSettingAsync<T>(string name = null);
+        Task UpdateSetting<T>(T obj, string name = null);
+        Task<T> WaitSettingsChanged<T>(CancellationToken cancellationToken = default);
+    }
+}

BTCPayServer.Abstractions/Contracts/IStartupTask.cs

@@ -1,10 +1,7 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace BTCPayServer
+namespace BTCPayServer.Abstractions.Contracts
 {
     public interface IStartupTask
     {

BTCPayServer.Abstractions/Contracts/ISyncSummaryProvider.cs

@@ -0,0 +1,9 @@
+namespace BTCPayServer.Abstractions.Contracts
+{
+    public interface ISyncSummaryProvider
+    {
+        bool AllAvailable();
+
+        string Partial { get; }
+    }
+}

BTCPayServer.Abstractions/Contracts/IUIExtension.cs

@@ -0,0 +1,9 @@
+namespace BTCPayServer.Abstractions.Contracts
+{
+    public interface IUIExtension
+    {
+        string Partial { get; }
+        
+        string Location { get; }
+    }
+}

BTCPayServer.Abstractions/Converters/VersionConverter.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace BTCPayServer.Abstractions.Converters
+{
+    public class VersionConverter : JsonConverter<Version>
+    {
+        public override Version Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            return Version.Parse(reader.GetString());
+        }
+
+        public override void Write(Utf8JsonWriter writer, Version value, JsonSerializerOptions options)
+        {
+            writer.WriteStringValue(value.ToString());
+        }
+    }
+}

BTCPayServer.Abstractions/Extensions/Extensions.cs

@@ -0,0 +1,20 @@
+using System.Text.Json;
+using BTCPayServer.Abstractions.Models;
+using Microsoft.AspNetCore.Mvc.ViewFeatures;
+
+namespace BTCPayServer.Abstractions.Extensions
+{
+    public static class SetStatusMessageModelExtensions
+    {
+        public static void SetStatusMessageModel(this ITempDataDictionary tempData, StatusMessageModel statusMessage)
+        {
+            if (statusMessage == null)
+            {
+                tempData.Remove("StatusMessageModel");
+                return;
+            }
+
+            tempData["StatusMessageModel"] = JsonSerializer.Serialize(statusMessage, new JsonSerializerOptions());
+        }
+    }
+}

BTCPayServer.Abstractions/Extensions/ServiceCollectionExtensions.cs

@@ -0,0 +1,12 @@
+using BTCPayServer.Abstractions.Contracts;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace BTCPayServer.Abstractions.Extensions
+{
+    public static class ServiceCollectionExtensions
+    {
+        public static IServiceCollection AddStartupTask<T>(this IServiceCollection services)
+            where T : class, IStartupTask
+            => services.AddTransient<IStartupTask, T>();
+    }
+}

BTCPayServer.Abstractions/Models/BaseBTCPayServerPlugin.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Reflection;
+using BTCPayServer.Abstractions.Contracts;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace BTCPayServer.Abstractions.Models
+{
+    public abstract class BaseBTCPayServerPlugin : IBTCPayServerPlugin
+    {
+        public abstract string Identifier { get; }
+        public abstract string Name { get; }
+
+        public virtual Version Version
+        {
+            get
+            {
+                return Assembly.GetAssembly(GetType())?.GetName().Version ?? new Version(1, 0, 0, 0);
+            }
+        }
+
+        public abstract string Description { get; }
+        public bool SystemPlugin { get; set; }
+        public virtual IBTCPayServerPlugin.PluginDependency[] Dependencies { get; } = Array.Empty<IBTCPayServerPlugin.PluginDependency>();
+
+        public virtual void Execute(IApplicationBuilder applicationBuilder,
+            IServiceProvider applicationBuilderApplicationServices)
+        {
+        }
+
+        public virtual void Execute(IServiceCollection applicationBuilder)
+        {
+        }
+    }
+}

BTCPayServer.Abstractions/Models/DatabaseOptions.cs

@@ -0,0 +1,8 @@
+namespace BTCPayServer.Abstractions.Models
+{
+    public class DatabaseOptions
+    {
+        public DatabaseType DatabaseType { get; set; }
+        public string ConnectionString { get; set; }
+    }
+}

BTCPayServer.Abstractions/Models/DatabaseType.cs

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

BTCPayServer.Abstractions/Models/StatusMessageModel.cs

@@ -1,40 +1,19 @@
 using System;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
 
-namespace BTCPayServer.Models
+namespace BTCPayServer.Abstractions.Models
 {
     public class StatusMessageModel
     {
         public StatusMessageModel()
         {
         }
-
         public string Message { get; set; }
         public string Html { get; set; }
         public StatusSeverity Severity { get; set; }
         public bool AllowDismiss { get; set; } = true;
 
-        public string SeverityCSS
-        {
-            get
-            {
-                switch (Severity)
-                {
-                    case StatusSeverity.Info:
-                        return "info";
-                    case StatusSeverity.Error:
-                        return "danger";
-                    case StatusSeverity.Success:
-                        return "success";
-                    case StatusSeverity.Warning:
-                        return "warning";
-                    default:
-                        throw new ArgumentOutOfRangeException();
-                }
-            }
-        }
-        
+        public string SeverityCSS => ToString(Severity);
+
         private void ParseNonJsonStatus(string s)
         {
             Message = s;
@@ -43,6 +22,23 @@ namespace BTCPayServer.Models
                 : StatusSeverity.Success;
         }
 
+        public static string ToString(StatusSeverity severity)
+        {
+            switch (severity)
+            {
+                case StatusSeverity.Info:
+                    return "info";
+                case StatusSeverity.Error:
+                    return "danger";
+                case StatusSeverity.Success:
+                    return "success";
+                case StatusSeverity.Warning:
+                    return "warning";
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+
         public enum StatusSeverity
         {
             Info,

BTCPayServer.Abstractions/PushNuget.ps1

@@ -0,0 +1,7 @@
+rm "bin\release\" -Recurse -Force
+dotnet pack --configuration Release --include-symbols -p:SymbolPackageFormat=snupkg
+$package=(ls .\bin\Release\*.nupkg).FullName
+dotnet nuget push $package --source "https://api.nuget.org/v3/index.json"
+$ver = ((ls .\bin\release\*.nupkg)[0].Name -replace '.*(\d+\.\d+\.\d+)\.nupkg','$1')
+git tag -a "BTCPayServer.Abstractions/v$ver" -m "BTCPayServer.Abstractions/$ver"
+git push origin "BTCPayServer.Abstractions/v$ver"

BTCPayServer.Abstractions/Services/PluginAction.cs

@@ -0,0 +1,16 @@
+using System.Threading.Tasks;
+using BTCPayServer.Abstractions.Contracts;
+
+namespace BTCPayServer.Abstractions.Services
+{
+    public abstract class PluginAction<T>:IPluginHookAction
+    {
+        public abstract string Hook { get; }
+        public Task Execute(object args)
+        {
+            return Execute(args is T args1 ? args1 : default);
+        }
+
+        public abstract Task Execute(T arg);
+    }
+}

BTCPayServer.Abstractions/Services/PluginHookFilter.cs

@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+using BTCPayServer.Abstractions.Contracts;
+
+namespace BTCPayServer.Abstractions.Services
+{
+    public abstract class PluginHookFilter<T>:IPluginHookFilter
+    {
+        public abstract string Hook { get; }
+
+        public Task<object> Execute(object args)
+        {
+            return Execute(args is T args1 ? args1 : default).ContinueWith(task => task.Result as object);
+        }
+
+        public abstract Task<T> Execute(T arg);
+    }
+}

BTCPayServer.Abstractions/Services/UIExtension.cs

@@ -0,0 +1,16 @@
+using BTCPayServer.Abstractions.Contracts;
+
+namespace BTCPayServer.Abstractions.Services
+{
+    public class UIExtension: IUIExtension
+    {
+        public UIExtension(string partial, string location)
+        {
+            Partial = partial;
+            Location = location;
+        }
+
+        public string Partial { get; }
+        public string Location { get; }
+    }
+}

BTCPayServer.Client/BTCPayServer.Client.csproj

@@ -0,0 +1,37 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>netstandard2.1</TargetFramework>
+        <Company>BTCPay Server</Company>
+        <Copyright>Copyright © BTCPay Server 2020</Copyright>
+        <Description>A client library for BTCPay Server Greenfield API</Description>
+        <PackageIcon>icon.png</PackageIcon>
+        <PackageTags>btcpay,btcpayserver</PackageTags>
+        <PackageProjectUrl>https://github.com/btcpayserver/btcpayserver/tree/master/BTCPayServer.Client</PackageProjectUrl>
+        <PackageLicenseExpression>MIT</PackageLicenseExpression>
+        <RepositoryUrl>https://github.com/btcpayserver/btcpayserver</RepositoryUrl>
+        <RepositoryType>git</RepositoryType>
+    </PropertyGroup>
+  <PropertyGroup>
+    <Version Condition=" '$(Version)' == '' ">1.2.0</Version>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
+    <PublishRepositoryUrl>true</PublishRepositoryUrl>
+    <EmbedUntrackedSources>true</EmbedUntrackedSources>
+    <DebugType>portable</DebugType>
+    <Optimize>true</Optimize>
+    <NoWarn>1591;1573;1572;1584;1570;3021</NoWarn>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+  </PropertyGroup>
+  <ItemGroup Condition=" '$(Configuration)' == 'Release' ">
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
+  </ItemGroup>
+    <ItemGroup>
+      <PackageReference Include="NBitcoin" Version="5.0.68" />
+      <PackageReference Include="BTCPayServer.Lightning.Common" Version="1.2.0" />
+      <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+    </ItemGroup>
+  <ItemGroup>
+    <None Include="icon.png" Pack="true" PackagePath="\" />
+  </ItemGroup>
+</Project>

BTCPayServer.Client/BTCPayServerClient.APIKeys.cs

@@ -0,0 +1,39 @@
+using System;
+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<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));
+            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 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));
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/api-keys/{apikey}", null, HttpMethod.Delete), token);
+            await HandleResponse(response);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.Authorization.cs

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

@@ -0,0 +1,15 @@
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Client.Models;
+
+namespace BTCPayServer.Client
+{
+    public partial class BTCPayServerClient
+    {
+        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

@@ -0,0 +1,89 @@
+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
+    {
+        public virtual async Task<IEnumerable<InvoiceData>> GetInvoices(string storeId, bool includeArchived = false,
+            CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/invoices",
+                        new Dictionary<string, object>() {{nameof(includeArchived), includeArchived}}), token);
+            return await HandleResponse<IEnumerable<InvoiceData>>(response);
+        }
+
+        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);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.Lightning.Internal.cs

@@ -0,0 +1,91 @@
+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
+    {
+        public async Task<LightningNodeInformationData> GetLightningNodeInfo(string cryptoCode,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/info",
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<LightningNodeInformationData>(response);
+        }
+
+        public 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 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 async Task<string> OpenLightningChannel(string cryptoCode, OpenLightningChannelRequest request,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/channels", bodyPayload: request,
+                    method: HttpMethod.Post), token);
+            return await HandleResponse<string>(response);
+        }
+
+        public async Task<string> GetLightningDepositAddress(string cryptoCode, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/server/lightning/{cryptoCode}/address", method: HttpMethod.Post), token);
+            return await HandleResponse<string>(response);
+        }
+
+
+        public async Task 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);
+            await HandleResponse(response);
+        }
+
+        public 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 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

@@ -0,0 +1,92 @@
+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
+    {
+        public async Task<LightningNodeInformationData> GetLightningNodeInfo(string storeId, string cryptoCode,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/info",
+                    method: HttpMethod.Get), token);
+            return await HandleResponse<LightningNodeInformationData>(response);
+        }
+
+        public 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 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 async Task<string> OpenLightningChannel(string storeId, string cryptoCode, OpenLightningChannelRequest request,
+            CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/channels", bodyPayload: request,
+                    method: HttpMethod.Post), token);
+            return await HandleResponse<string>(response);
+        }
+
+        public 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 async Task 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);
+            await HandleResponse(response);
+        }
+
+        public 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 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.LightningNetworkPaymentMethods.cs

@@ -0,0 +1,63 @@
+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,
+                CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LightningNetwork"), 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, LightningNetworkPaymentMethodData 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);
+        }
+
+        public virtual async Task<LightningNetworkPaymentMethodData>
+            UpdateStoreLightningNetworkPaymentMethodToInternalNode(string storeId,
+                string cryptoCode, LightningNetworkPaymentMethodData paymentMethod,
+                CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/LightningNetwork/{cryptoCode}/internal",
+                    method: HttpMethod.Put), token);
+            return await HandleResponse<LightningNetworkPaymentMethodData>(response);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.Notifications.cs

@@ -0,0 +1,47 @@
+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
+    {
+        public virtual async Task<IEnumerable<NotificationData>> GetNotifications(bool? seen = null,
+            CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/users/me/notifications",
+                        seen != null ? new Dictionary<string, object>() {{nameof(seen), seen}} : null), token);
+            return await HandleResponse<IEnumerable<NotificationData>>(response);
+        }
+
+        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<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

@@ -0,0 +1,74 @@
+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<OnChainPaymentMethodData>> GetStoreOnChainPaymentMethods(string storeId,
+            CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/Onchain"), token);
+            return await HandleResponse<IEnumerable<OnChainPaymentMethodData>>(response);
+        }
+
+        public virtual async Task<OnChainPaymentMethodData> GetStoreOnChainPaymentMethod(string storeId,
+            string cryptoCode, CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/Onchain/{cryptoCode}"), token);
+            return await HandleResponse<OnChainPaymentMethodData>(response);
+        }
+
+        public virtual async Task RemoveStoreOnChainPaymentMethod(string storeId,
+            string cryptoCode, CancellationToken token = default)
+        {
+            var response =
+                await _httpClient.SendAsync(
+                    CreateHttpRequest($"api/v1/stores/{storeId}/payment-methods/Onchain/{cryptoCode}",
+                        method: HttpMethod.Delete), token);
+            await HandleResponse(response);
+        }
+
+        public virtual async Task<OnChainPaymentMethodData> UpdateStoreOnChainPaymentMethod(string storeId,
+            string cryptoCode, OnChainPaymentMethodData 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, OnChainPaymentMethodData 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);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.PaymentRequests.cs

@@ -0,0 +1,62 @@
+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
+    {
+        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)
+        {
+            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)
+        {
+            var response = await _httpClient.SendAsync(
+                CreateHttpRequest($"api/v1/stores/{storeId}/payment-requests/{paymentRequestId}",
+                    method: HttpMethod.Delete), token);
+            await HandleResponse(response);
+        }
+
+        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));
+            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.PullPayments.cs

@@ -0,0 +1,61 @@
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Web;
+using BTCPayServer.Client.Models;
+
+namespace BTCPayServer.Client
+{
+    public partial class BTCPayServerClient
+    {
+        public async Task<PullPaymentData> CreatePullPayment(string storeId, CreatePullPaymentRequest request, CancellationToken cancellationToken = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/pull-payments", bodyPayload: request, method: HttpMethod.Post), cancellationToken);
+            return await HandleResponse<PullPaymentData>(response);
+        }
+        public 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 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 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 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 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 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 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);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.ServerInfo.cs

@@ -0,0 +1,15 @@
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Client.Models;
+
+namespace BTCPayServer.Client
+{
+    public partial class BTCPayServerClient
+    {
+        public virtual async Task<ServerInfoData> GetServerInfo(CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest("api/v1/server/info"), token);
+            return await HandleResponse<ServerInfoData>(response);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.Stores.cs

@@ -0,0 +1,51 @@
+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
+    {
+        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)
+        {
+            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)
+        {
+            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));
+            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));
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}", bodyPayload: request, method: HttpMethod.Put), token);
+            return await HandleResponse<StoreData>(response);
+        }
+
+    }
+}

BTCPayServer.Client/BTCPayServerClient.Users.cs

@@ -0,0 +1,23 @@
+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<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> 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);
+        }
+    }
+}

BTCPayServer.Client/BTCPayServerClient.Webhooks.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Client.Models;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Client
+{
+    public partial class BTCPayServerClient
+    {
+        public 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 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 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 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 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 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 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 await HandleResponse<WebhookDeliveryData>(response);
+        }
+        public async Task<string> RedeliverWebhook(string storeId, string webhookId, string deliveryId, CancellationToken token = default)
+        {
+            var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/webhooks/{webhookId}/deliveries/{deliveryId}/redeliver", null, HttpMethod.Post), token);
+            return await HandleResponse<string>(response);
+        }
+
+        public 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

@@ -0,0 +1,140 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Text;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client
+{
+    public partial class BTCPayServerClient
+    {
+        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 string APIKey => _apiKey;
+
+        public BTCPayServerClient(Uri btcpayHost, HttpClient httpClient = null)
+        {
+            if (btcpayHost == null)
+                throw new ArgumentNullException(nameof(btcpayHost));
+            _btcpayHost = btcpayHost;
+            _httpClient = httpClient ?? new HttpClient();
+        }
+        public BTCPayServerClient(Uri btcpayHost, string APIKey, HttpClient httpClient = null)
+        {
+            _apiKey = APIKey;
+            _btcpayHost = btcpayHost;
+            _httpClient = httpClient ?? new HttpClient();
+        }
+
+        public BTCPayServerClient(Uri btcpayHost, string username, string password, HttpClient httpClient = null)
+        {
+            _apiKey = APIKey;
+            _btcpayHost = btcpayHost;
+            _username = username;
+            _password = password;
+            _httpClient = httpClient ?? new HttpClient();
+        }
+
+        protected async Task HandleResponse(HttpResponseMessage message)
+        {
+            if (message.StatusCode == System.Net.HttpStatusCode.UnprocessableEntity)
+            {
+                var err = JsonConvert.DeserializeObject<Models.GreenfieldValidationError[]>(await message.Content.ReadAsStringAsync());
+                ;
+                throw new GreenFieldValidationException(err);
+            }
+            else if (message.StatusCode == System.Net.HttpStatusCode.BadRequest)
+            {
+                var err = JsonConvert.DeserializeObject<Models.GreenfieldAPIError>(await message.Content.ReadAsStringAsync());
+                throw new GreenFieldAPIException(err);
+            }
+
+            message.EnsureSuccessStatusCode();
+        }
+
+        protected async Task<T> HandleResponse<T>(HttpResponseMessage message)
+        {
+            await HandleResponse(message);
+            var str = await message.Content.ReadAsStringAsync();
+            return JsonConvert.DeserializeObject<T>(str);
+        }
+
+        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())
+            {
+                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
+            {
+                uriBuilder.Query = uriBuilder.Query + Uri.EscapeDataString(keyValuePair.Key) + "=" +
+                                   Uri.EscapeDataString(keyValuePair.Value.ToString()) + "&";
+            }
+            uri.Query = uri.Query.Trim('&');
+        }
+
+        public static void AppendPayloadToQuery(UriBuilder uri, Dictionary<string, object> payload)
+        {
+            if (uri.Query.Length > 1)
+                uri.Query += "&";
+            foreach (KeyValuePair<string, object> keyValuePair in payload)
+            {
+                AppendPayloadToQuery(uri, keyValuePair);
+            }
+        }
+    }
+}

BTCPayServer.Client/GreenFieldAPIException.cs

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

BTCPayServer.Client/GreenFieldValidationException.cs

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

BTCPayServer.Client/JsonConverters/LightMoneyJsonConverter.cs

@@ -0,0 +1,15 @@
+using System.Globalization;
+using BTCPayServer.Lightning;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.JsonConverters
+{
+    public class LightMoneyJsonConverter : BTCPayServer.Lightning.JsonConverters.LightMoneyJsonConverter
+    {
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            if (value != null)
+                writer.WriteValue(((LightMoney)value).MilliSatoshi.ToString(CultureInfo.InvariantCulture));
+        }
+    }
+}

BTCPayServer.Client/JsonConverters/MoneyJsonConverter.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Globalization;
+using NBitcoin;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.JsonConverters
+{
+    public class MoneyJsonConverter : NBitcoin.JsonConverters.MoneyJsonConverter
+    {
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.String)
+            {
+                return new Money(long.Parse((string)reader.Value));
+            }
+            return base.ReadJson(reader, objectType, existingValue, serializer);
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            if (value != null)
+                writer.WriteValue(((Money)value).Satoshi.ToString(CultureInfo.InvariantCulture));
+        }
+    }
+}

BTCPayServer.Client/JsonConverters/NodeUriJsonConverter.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using BTCPayServer.Lightning;
+using NBitcoin.JsonConverters;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.JsonConverters
+{
+    public class NodeUriJsonConverter : JsonConverter<NodeInfo>
+    {
+        public override NodeInfo ReadJson(JsonReader reader, Type objectType, [AllowNull] NodeInfo existingValue, bool hasExistingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType != JsonToken.String)
+                throw new JsonObjectException(reader.Path, "Unexpected token type for NodeUri");
+            if (NodeInfo.TryParse((string)reader.Value, out var info))
+                return info;
+            throw new JsonObjectException(reader.Path, "Invalid NodeUri");
+        }
+
+        public override void WriteJson(JsonWriter writer, [AllowNull] NodeInfo value, JsonSerializer serializer)
+        {
+            if (value is NodeInfo)
+                writer.WriteValue(value.ToString());
+        }
+    }
+}

BTCPayServer.Client/JsonConverters/NumericStringJsonConverter.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Globalization;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.JsonConverters
+{
+    public class NumericStringJsonConverter : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+        {
+            return (objectType == typeof(decimal) ||
+                    objectType == typeof(decimal?) ||
+                    objectType == typeof(double) ||
+                    objectType == typeof(double?));
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue,
+            JsonSerializer serializer)
+        {
+            JToken token = JToken.Load(reader);
+            switch (token.Type)
+            {
+                case JTokenType.Float:
+                case JTokenType.Integer:
+                case JTokenType.String:
+                    if (objectType == typeof(decimal) || objectType == typeof(decimal?) )
+                        return decimal.Parse(token.ToString(), CultureInfo.InvariantCulture);
+                    if (objectType == typeof(double) || objectType == typeof(double?))
+                        return double.Parse(token.ToString(), CultureInfo.InvariantCulture);
+
+                    throw new JsonSerializationException("Unexpected object type: " + objectType);
+                case JTokenType.Null when objectType == typeof(decimal?) || objectType == typeof(double?):
+                    return null;
+                default:
+                    throw new JsonSerializationException("Unexpected token type: " +
+                                                         token.Type);
+            }
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            switch (value)
+            {
+                case null:
+                    break;
+                case decimal x:
+                    writer.WriteValue(x.ToString(CultureInfo.InvariantCulture));
+                    break;
+                case double x:
+                    writer.WriteValue(x.ToString(CultureInfo.InvariantCulture));
+                    break;
+            }
+        }
+    }
+}

BTCPayServer.Client/JsonConverters/PermissionJsonConverter.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Reflection;
+using NBitcoin.JsonConverters;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.JsonConverters
+{
+    public class PermissionJsonConverter : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+        {
+            return typeof(Permission).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("Type 'Permission' is expected to be a 'String'", reader);
+            if (reader.Value is String s && Permission.TryParse(s, out var permission))
+                return permission;
+            throw new JsonObjectException("Invalid 'Permission' String", reader);
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            if (value is Permission v)
+                writer.WriteValue(v.ToString());
+        }
+    }
+}

BTCPayServer.Client/JsonConverters/TimeSpanJsonConverter.cs

@@ -0,0 +1,68 @@
+using System;
+using NBitcoin.JsonConverters;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.JsonConverters
+{
+    public abstract class TimeSpanJsonConverter : JsonConverter
+    {
+        public class Seconds : TimeSpanJsonConverter
+        {
+            protected override long ToLong(TimeSpan value)
+            {
+                return (long)value.TotalSeconds;
+            }
+
+            protected override TimeSpan ToTimespan(long value)
+            {
+                return TimeSpan.FromSeconds(value);
+            }
+        }
+        public class Minutes : TimeSpanJsonConverter
+        {
+            protected override long ToLong(TimeSpan value)
+            {
+                return (long)value.TotalMinutes;
+            }
+            protected override TimeSpan ToTimespan(long value)
+            {
+                return TimeSpan.FromMinutes(value);
+            }
+        }
+        public override bool CanConvert(Type objectType)
+        {
+            return objectType == typeof(TimeSpan) || objectType == typeof(TimeSpan?);
+        }
+
+        protected abstract TimeSpan ToTimespan(long value);
+        protected abstract long ToLong(TimeSpan value);
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            try
+            {
+                var nullable = objectType == typeof(TimeSpan?);
+                if (reader.TokenType == JsonToken.Null)
+                {
+                    if (nullable)
+                        return null;
+                    return TimeSpan.Zero;
+                }
+                if (reader.TokenType != JsonToken.Integer)
+                    throw new JsonObjectException("Invalid timespan, expected integer", reader);
+                return ToTimespan((long)reader.Value);
+            }
+            catch
+            {
+                throw new JsonObjectException("Invalid timespan", reader);
+            }
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            if (value is TimeSpan s)
+            {
+                writer.WriteValue(ToLong(s));
+            }
+        }
+    }
+}

BTCPayServer.Client/Models/AddCustomerEmailRequest.cs

@@ -0,0 +1,7 @@
+namespace BTCPayServer.Client.Models
+{
+    public class AddCustomerEmailRequest
+    {
+        public string Email { get; set; }
+    }
+}

BTCPayServer.Client/Models/ApiHealthData.cs

@@ -0,0 +1,7 @@
+namespace BTCPayServer.Client.Models
+{
+    public class ApiHealthData
+    {
+        public bool Synchronized { get; set; }
+    }
+}

BTCPayServer.Client/Models/ApiKeyData.cs

@@ -0,0 +1,14 @@
+using BTCPayServer.Client.JsonConverters;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models
+{
+    public class ApiKeyData
+    {
+        public string ApiKey { get; set; }
+        public string Label { get; set; }
+
+        [JsonProperty(ItemConverterType = typeof(PermissionJsonConverter))]
+        public Permission[] Permissions { get; set; }
+    }
+}

BTCPayServer.Client/Models/ApplicationUserData.cs

@@ -0,0 +1,39 @@
+using System;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models
+{
+    public class ApplicationUserData
+    {
+        /// <summary>
+        /// the id of the user
+        /// </summary>
+        public string Id { get; set; }
+
+        /// <summary>
+        /// the email AND username of the user
+        /// </summary>
+        public string Email { get; set; }
+
+        /// <summary>
+        /// Whether the user has verified their email
+        /// </summary>
+        public bool EmailConfirmed { get; set; }
+
+        /// <summary>
+        /// whether the user needed to verify their email on account creation
+        /// </summary>
+        public bool RequiresEmailConfirmation { get; set; }
+
+        /// <summary>
+        /// the roles of the user
+        /// </summary>
+        public string[] Roles { get; set; }
+
+        /// <summary>
+        /// the date the user was created. Null if created before v1.0.5.6.
+        /// </summary>
+        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+        public DateTimeOffset? Created { get; set; }
+    }
+}

BTCPayServer.Client/Models/ApprovePayoutRequest.cs

@@ -0,0 +1,8 @@
+namespace BTCPayServer.Client.Models
+{
+    public class ApprovePayoutRequest
+    {
+        public int Revision { get; set; }
+        public string RateRule { get; set; }
+    }
+}

BTCPayServer.Client/Models/ConnectToNodeRequest.cs

@@ -0,0 +1,21 @@
+using BTCPayServer.Client.JsonConverters;
+using BTCPayServer.Lightning;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models
+{
+    public class ConnectToNodeRequest
+    {
+        public ConnectToNodeRequest()
+        {
+
+        }
+        public ConnectToNodeRequest(NodeInfo nodeInfo)
+        {
+            NodeURI = nodeInfo;
+        }
+        [JsonConverter(typeof(NodeUriJsonConverter))]
+        [JsonProperty("nodeURI")]
+        public NodeInfo NodeURI { get; set; }
+    }
+}

BTCPayServer.Client/Models/CreateApiKeyRequest.cs

@@ -0,0 +1,13 @@
+using BTCPayServer.Client.JsonConverters;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models
+{
+    public class CreateApiKeyRequest
+    {
+        public string Label { get; set; }
+
+        [JsonProperty(ItemConverterType = typeof(PermissionJsonConverter))]
+        public Permission[] Permissions { get; set; }
+    }
+}

BTCPayServer.Client/Models/CreateApplicationUserRequest.cs

@@ -0,0 +1,20 @@
+namespace BTCPayServer.Client.Models
+{
+    public class CreateApplicationUserRequest
+    {
+        /// <summary>
+        /// the email AND username of the new user
+        /// </summary>
+        public string Email { get; set; }
+
+        /// <summary>
+        /// password of the new user
+        /// </summary>
+        public string Password { get; set; }
+
+        /// <summary>
+        /// Whether this user is an administrator. If left null and there are no admins in the system, the user will be created as an admin.
+        /// </summary>
+        public bool? IsAdministrator { get; set; }
+    }
+}

BTCPayServer.Client/Models/CreateInvoiceRequest.cs

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

BTCPayServer.Client/Models/CreateLightningInvoiceRequest.cs

@@ -0,0 +1,28 @@
+using System;
+using BTCPayServer.Lightning;
+using BTCPayServer.Lightning.JsonConverters;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models
+{
+    public class CreateLightningInvoiceRequest
+    {
+        public CreateLightningInvoiceRequest()
+        {
+
+        }
+        public CreateLightningInvoiceRequest(LightMoney amount, string description, TimeSpan expiry)
+        {
+            Amount = amount;
+            Description = description;
+            Expiry = expiry;
+        }
+        [JsonConverter(typeof(LightMoneyJsonConverter))]
+        public LightMoney Amount { get; set; }
+        public string Description { get; set; }
+        [JsonConverter(typeof(JsonConverters.TimeSpanJsonConverter.Seconds))]
+        public TimeSpan Expiry { get; set; }
+        public bool PrivateRouteHints { get; set; }
+
+    }
+}

BTCPayServer.Client/Models/CreatePaymentRequestRequest.cs

@@ -0,0 +1,6 @@
+namespace BTCPayServer.Client.Models
+{
+    public class CreatePaymentRequestRequest : PaymentRequestBaseData
+    {
+    }
+}

BTCPayServer.Client/Models/CreatePayoutRequest.cs

@@ -0,0 +1,13 @@
+using BTCPayServer.JsonConverters;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models
+{
+    public class CreatePayoutRequest
+    {
+        public string Destination { get; set; }
+        [JsonConverter(typeof(NumericStringJsonConverter))]
+        public decimal? Amount { get; set; }
+        public string PaymentMethod { get; set; }
+    }
+}

BTCPayServer.Client/Models/CreatePullPaymentRequest.cs

@@ -0,0 +1,22 @@
+using System;
+using BTCPayServer.Client.JsonConverters;
+using BTCPayServer.JsonConverters;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models
+{
+    public class CreatePullPaymentRequest
+    {
+        public string Name { get; set; }
+        [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(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+        public DateTimeOffset? ExpiresAt { get; set; }
+        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+        public DateTimeOffset? StartsAt { get; set; }
+        public string[] PaymentMethods { get; set; }
+    }
+}

BTCPayServer.Client/Models/CreateStoreRequest.cs

@@ -0,0 +1,6 @@
+namespace BTCPayServer.Client.Models
+{
+    public class CreateStoreRequest : StoreBaseData
+    {
+    }
+}

BTCPayServer.Client/Models/GreenfieldAPIError.cs

@@ -0,0 +1,22 @@
+using System;
+
+namespace BTCPayServer.Client.Models
+{
+    public class GreenfieldAPIError
+    {
+        public GreenfieldAPIError()
+        {
+
+        }
+        public GreenfieldAPIError(string code, string message)
+        {
+            code = code ?? "generic-error";
+            if (message == null)
+                throw new ArgumentNullException(nameof(message));
+            Code = code;
+            Message = message;
+        }
+        public string Code { get; set; }
+        public string Message { get; set; }
+    }
+}

BTCPayServer.Client/Models/GreenfieldValidationError.cs

@@ -0,0 +1,24 @@
+using System;
+
+namespace BTCPayServer.Client.Models
+{
+    public class GreenfieldValidationError
+    {
+        public GreenfieldValidationError()
+        {
+
+        }
+        public GreenfieldValidationError(string path, string message)
+        {
+            if (path == null)
+                throw new ArgumentNullException(nameof(path));
+            if (message == null)
+                throw new ArgumentNullException(nameof(message));
+            Path = path;
+            Message = message;
+        }
+
+        public string Path { get; set; }
+        public string Message { get; set; }
+    }
+}

BTCPayServer.Client/Models/InvoiceData.cs

@@ -0,0 +1,30 @@
+using System;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace BTCPayServer.Client.Models
+{
+    public class InvoiceData : CreateInvoiceRequest
+    {
+        public string Id { get; set; }
+        public string CheckoutLink { get; set; }
+        [JsonConverter(typeof(StringEnumConverter))]
+        public InvoiceStatus Status { get; set; }
+        [JsonConverter(typeof(StringEnumConverter))]
+        public InvoiceExceptionStatus AdditionalStatus { get; set; }
+        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+        public DateTimeOffset MonitoringExpiration { get; set; }
+        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+        public DateTimeOffset ExpirationTime { get; set; }
+        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+        public DateTimeOffset CreatedTime { get; set; }
+    }
+    public enum InvoiceStatus
+    {
+        New,
+        Processing,
+        Expired,
+        Invalid,
+        Settled
+    }
+}

BTCPayServer.Client/Models/InvoiceExceptionStatus.cs

@@ -0,0 +1,12 @@
+namespace BTCPayServer.Client.Models
+{
+    public enum InvoiceExceptionStatus
+    {
+        None,
+        PaidLate,
+        PaidPartial,
+        Marked,
+        Invalid,
+        PaidOver
+    }
+}

BTCPayServer.Client/Models/InvoicePaymentMethodDataModel.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using BTCPayServer.JsonConverters;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace BTCPayServer.Client.Models
+{
+    public class InvoicePaymentMethodDataModel
+    {
+        public string Destination { get; set; }
+        public string PaymentLink { get; set; }
+
+        [JsonConverter(typeof(NumericStringJsonConverter))]
+        public decimal Rate { get; set; }
+
+        [JsonConverter(typeof(NumericStringJsonConverter))]
+        public decimal PaymentMethodPaid { get; set; }
+
+        [JsonConverter(typeof(NumericStringJsonConverter))]
+        public decimal TotalPaid { get; set; }
+
+        [JsonConverter(typeof(NumericStringJsonConverter))]
+        public decimal Due { get; set; }
+
+        [JsonConverter(typeof(NumericStringJsonConverter))]
+        public decimal Amount { get; set; }
+
+        [JsonConverter(typeof(NumericStringJsonConverter))]
+        public decimal NetworkFee { get; set; }
+
+        public List<Payment> Payments { get; set; }
+        public string PaymentMethod { get; set; }
+
+        public class Payment
+        {
+            public string Id { get; set; }
+
+            [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+            public DateTime ReceivedDate { get; set; }
+
+            [JsonConverter(typeof(NumericStringJsonConverter))]
+            public decimal Value { get; set; }
+
+            [JsonConverter(typeof(NumericStringJsonConverter))]
+            public decimal Fee { get; set; }
+
+            [JsonConverter(typeof(StringEnumConverter))]
+            public PaymentStatus Status { get; set; }
+
+            public string Destination { get; set; }
+            
+            public enum PaymentStatus
+            {
+                Invalid,
+                Processing,
+                Settled
+            }
+        }
+    }
+}

BTCPayServer.Client/Models/LightningInvoiceData.cs

@@ -0,0 +1,30 @@
+using System;
+using BTCPayServer.Client.JsonConverters;
+using BTCPayServer.Lightning;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace BTCPayServer.Client.Models
+{
+    public class LightningInvoiceData
+    {
+        public string Id { get; set; }
+
+        [JsonConverter(typeof(StringEnumConverter))]
+        public LightningInvoiceStatus Status { get; set; }
+
+        [JsonProperty("BOLT11")]
+        public string BOLT11 { get; set; }
+
+        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+        public DateTimeOffset? PaidAt { get; set; }
+        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+        public DateTimeOffset ExpiresAt { get; set; }
+
+        [JsonConverter(typeof(LightMoneyJsonConverter))]
+        public LightMoney Amount { get; set; }
+
+        [JsonConverter(typeof(LightMoneyJsonConverter))]
+        public LightMoney AmountReceived { get; set; }
+    }
+}

BTCPayServer.Client/Models/LightningNetworkPaymentMethodData.cs

@@ -0,0 +1,28 @@
+namespace BTCPayServer.Client.Models
+{
+    public class LightningNetworkPaymentMethodData
+    {
+        /// <summary>
+        /// Whether the payment method is enabled
+        /// </summary>
+        public bool Enabled { get; set; }
+
+        /// <summary>
+        /// Crypto code of the payment method
+        /// </summary>
+        public string CryptoCode { get; set; }
+
+        public string ConnectionString { get; set; }
+
+        public LightningNetworkPaymentMethodData()
+        {
+        }
+
+        public LightningNetworkPaymentMethodData(string cryptoCode, string connectionString, bool enabled)
+        {
+            Enabled = enabled;
+            CryptoCode = cryptoCode;
+            ConnectionString = connectionString;
+        }
+    }
+}

BTCPayServer.Client/Models/LightningNodeInformationData.cs

@@ -0,0 +1,30 @@
+using BTCPayServer.Client.JsonConverters;
+using BTCPayServer.Lightning;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models
+{
+    public class LightningNodeInformationData
+    {
+        [JsonProperty("nodeURIs", ItemConverterType = typeof(NodeUriJsonConverter))]
+        public NodeInfo[] NodeURIs { get; set; }
+        public int BlockHeight { get; set; }
+    }
+
+    public class LightningChannelData
+    {
+        public string RemoteNode { get; set; }
+
+        public bool IsPublic { get; set; }
+
+        public bool IsActive { get; set; }
+
+        [JsonConverter(typeof(LightMoneyJsonConverter))]
+        public LightMoney Capacity { get; set; }
+
+        [JsonConverter(typeof(LightMoneyJsonConverter))]
+        public LightMoney LocalBalance { get; set; }
+
+        public string ChannelPoint { get; set; }
+    }
+}

BTCPayServer.Client/Models/MarkInvoiceStatusRequest.cs

@@ -0,0 +1,11 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace BTCPayServer.Client.Models
+{
+    public class MarkInvoiceStatusRequest
+    {
+        [JsonConverter(typeof(StringEnumConverter))]
+        public InvoiceStatus Status { get; set; }
+    }
+}

BTCPayServer.Client/Models/NotificationData.cs

@@ -0,0 +1,16 @@
+using System;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models
+{
+    public class NotificationData
+    {
+        public string Id { get; set; }
+        public string Body { get; set; }
+        public bool Seen { get; set; }
+        public Uri Link { get; set; }
+
+        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+        public DateTimeOffset CreatedTime { get; set; }
+    }
+}

BTCPayServer.Client/Models/OnChainPaymentMethodData.cs

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

BTCPayServer.Client/Models/OnChainPaymentMethodPreviewResultData.cs

@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+
+namespace BTCPayServer.Client.Models
+{
+    public class OnChainPaymentMethodPreviewResultData
+    {
+        /// <summary>
+        /// a list of addresses generated by the derivation scheme
+        /// </summary>
+        public IList<OnChainPaymentMethodPreviewResultAddressItem> Addresses { get; set; } =
+            new List<OnChainPaymentMethodPreviewResultAddressItem>();
+
+        public class OnChainPaymentMethodPreviewResultAddressItem
+        {
+            /// <summary>
+            /// The key path relative to the account key path. 
+            /// </summary>
+            public string KeyPath { get; set; }
+            //The address generated at the key path
+            public string Address { get; set; }
+        }
+    }
+}

BTCPayServer.Client/Models/OpenLightningChannelRequest.cs

@@ -0,0 +1,21 @@
+using BTCPayServer.Client.JsonConverters;
+using BTCPayServer.Lightning;
+using NBitcoin;
+using NBitcoin.JsonConverters;
+using Newtonsoft.Json;
+using MoneyJsonConverter = BTCPayServer.Client.JsonConverters.MoneyJsonConverter;
+
+namespace BTCPayServer.Client.Models
+{
+    public class OpenLightningChannelRequest
+    {
+        [JsonConverter(typeof(NodeUriJsonConverter))]
+        [JsonProperty("nodeURI")]
+        public NodeInfo NodeURI { get; set; }
+        [JsonConverter(typeof(MoneyJsonConverter))]
+        public Money ChannelAmount { get; set; }
+
+        [JsonConverter(typeof(FeeRateJsonConverter))]
+        public FeeRate FeeRate { get; set; }
+    }
+}

BTCPayServer.Client/Models/PayLightningInvoiceRequest.cs

@@ -0,0 +1,8 @@
+namespace BTCPayServer.Client.Models
+{
+    public class PayLightningInvoiceRequest
+    {
+        [Newtonsoft.Json.JsonProperty("BOLT11")]
+        public string BOLT11 { get; set; }
+    }
+}

BTCPayServer.Client/Models/PaymentRequestBaseData.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using BTCPayServer.JsonConverters;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Client.Models
+{
+    public class PaymentRequestBaseData
+    {
+        [JsonProperty(ItemConverterType = typeof(NumericStringJsonConverter))]
+        public decimal Amount { get; set; }
+        public string Currency { get; set; }
+        public DateTime? ExpiryDate { get; set; }
+        public string Title { get; set; }
+        public string Description { get; set; }
+        public string Email { get; set; }
+
+        public string EmbeddedCSS { get; set; }
+        public string CustomCSSLink { get; set; }
+        public bool AllowCustomPaymentAmounts { get; set; }
+
+        [JsonExtensionData]
+        public IDictionary<string, JToken> AdditionalData { get; set; }
+    }
+}

BTCPayServer.Client/Models/PaymentRequestData.cs

@@ -0,0 +1,22 @@
+using System;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace BTCPayServer.Client.Models
+{
+    public class PaymentRequestData : PaymentRequestBaseData
+    {
+        [JsonConverter(typeof(StringEnumConverter))]
+        public PaymentRequestData.PaymentRequestStatus Status { get; set; }
+        public DateTimeOffset Created { get; set; }
+        public string Id { get; set; }
+        public bool Archived { get; set; }
+
+        public enum PaymentRequestStatus
+        {
+            Pending = 0,
+            Completed = 1,
+            Expired = 2
+        }
+    }
+}

BTCPayServer.Client/Models/PayoutData.cs

@@ -0,0 +1,32 @@
+using System;
+using BTCPayServer.JsonConverters;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace BTCPayServer.Client.Models
+{
+    public enum PayoutState
+    {
+        AwaitingApproval,
+        AwaitingPayment,
+        InProgress,
+        Completed,
+        Cancelled
+    }
+    public class PayoutData
+    {
+        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+        public DateTimeOffset Date { get; set; }
+        public string Id { get; set; }
+        public string PullPaymentId { get; set; }
+        public string Destination { get; set; }
+        public string PaymentMethod { get; set; }
+        [JsonConverter(typeof(NumericStringJsonConverter))]
+        public decimal Amount { get; set; }
+        [JsonConverter(typeof(NumericStringJsonConverter))]
+        public decimal? PaymentMethodAmount { get; set; }
+        [JsonConverter(typeof(StringEnumConverter))]
+        public PayoutState State { get; set; }
+        public int Revision { get; set; }
+    }
+}

BTCPayServer.Client/Models/PullPaymentBaseData.cs

@@ -0,0 +1,24 @@
+using System;
+using BTCPayServer.Client.JsonConverters;
+using BTCPayServer.JsonConverters;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models
+{
+    public class PullPaymentData
+    {
+        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+        public DateTimeOffset StartsAt { get; set; }
+        [JsonConverter(typeof(NBitcoin.JsonConverters.DateTimeToUnixTimeConverter))]
+        public DateTimeOffset? ExpiresAt { get; set; }
+        public string Id { get; set; }
+        public string Name { get; set; }
+        public string Currency { get; set; }
+        [JsonConverter(typeof(NumericStringJsonConverter))]
+        public decimal Amount { get; set; }
+        [JsonConverter(typeof(TimeSpanJsonConverter.Seconds))]
+        public TimeSpan? Period { get; set; }
+        public bool Archived { get; set; }
+        public string ViewLink { get; set; }
+    }
+}

BTCPayServer.Client/Models/ServerInfoData.cs

@@ -0,0 +1,47 @@
+using System.Collections.Generic;
+
+namespace BTCPayServer.Client.Models
+{
+    public class ServerInfoData
+    {
+        /// <summary>
+        /// the BTCPay Server version
+        /// </summary>
+        public string Version { get; set; }
+
+        /// <summary>
+        /// the Tor hostname
+        /// </summary>
+        public string Onion { get; set; }
+
+        /// <summary>
+        /// the payment methods this server supports
+        /// </summary>
+        public IEnumerable<string> SupportedPaymentMethods { get; set; }
+
+        /// <summary>
+        /// are all chains fully synched
+        /// </summary>
+        public bool FullySynched { get; set; }
+
+        /// <summary>
+        /// detailed sync information per chain
+        /// </summary>
+        public IEnumerable<ServerInfoSyncStatusData> SyncStatus { get; set; }
+    }
+
+    public class ServerInfoSyncStatusData
+    {
+        public string CryptoCode { get; set; }
+        public int ChainHeight { get; set; }
+        public int? SyncHeight { get; set; }
+        public ServerInfoNodeData NodeInformation { get; set; }
+    }
+
+    public class ServerInfoNodeData
+    {
+        public int Headers { get; set; }
+        public int Blocks { get; set; }
+        public double VerificationProgress { get; set; }
+    }
+}

BTCPayServer.Client/Models/StoreBaseData.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using BTCPayServer.Client.JsonConverters;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Client.Models
+{
+    public abstract class StoreBaseData
+    {
+        /// <summary>
+        /// the name of the store
+        /// </summary>
+        public string Name { get; set; }
+
+        public string Website { get; set; }
+
+        [JsonConverter(typeof(TimeSpanJsonConverter.Seconds))]
+        [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
+        public TimeSpan InvoiceExpiration { get; set; } = TimeSpan.FromMinutes(15);
+
+        [JsonConverter(typeof(TimeSpanJsonConverter.Seconds))]
+        [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
+        public TimeSpan MonitoringExpiration { get; set; } = TimeSpan.FromMinutes(60);
+
+        [JsonConverter(typeof(StringEnumConverter))]
+        public SpeedPolicy SpeedPolicy { get; set; }
+        public string LightningDescriptionTemplate { get; set; }
+        public double PaymentTolerance { get; set; } = 0;
+        public bool AnyoneCanCreateInvoice { get; set; }
+
+
+        public bool RequiresRefundEmail { get; set; }
+        public bool LightningAmountInSatoshi { get; set; }
+        public bool LightningPrivateRouteHints { get; set; }
+        public bool OnChainWithLnInvoiceFallback { get; set; }
+        public bool RedirectAutomatically { get; set; }
+
+        [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
+        public bool ShowRecommendedFee { get; set; } = true;
+        [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
+        public int RecommendedFeeBlockTarget { get; set; } = 1;
+        
+        public string DefaultPaymentMethod { get; set; }
+        
+        [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
+        public string DefaultLang { get; set; } = "en";
+
+        public string CustomLogo { get; set; }
+
+        public string CustomCSS { get; set; }
+
+        public string HtmlTitle { get; set; }
+
+
+
+        [JsonConverter(typeof(StringEnumConverter))]
+        [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
+        public NetworkFeeMode NetworkFeeMode { get; set; } = NetworkFeeMode.Never;
+
+        public bool PayJoinEnabled { get; set; }
+
+
+        [JsonExtensionData]
+        public IDictionary<string, JToken> AdditionalData { get; set; }
+    }
+
+    public enum NetworkFeeMode
+    {
+        MultiplePaymentsOnly,
+        Always,
+        Never
+    }
+
+    public enum SpeedPolicy
+    {
+        HighSpeed = 0,
+        MediumSpeed = 1,
+        LowSpeed = 2,
+        LowMediumSpeed = 3
+    }
+}

BTCPayServer.Client/Models/StoreData.cs

@@ -0,0 +1,10 @@
+namespace BTCPayServer.Client.Models
+{
+    public class StoreData : StoreBaseData
+    {
+        /// <summary>
+        /// the id of the store
+        /// </summary>
+        public string Id { get; set; }
+    }
+}

BTCPayServer.Client/Models/StoreWebhookData.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Client.Models
+{
+    public class StoreWebhookBaseData
+    {
+        public class AuthorizedEventsData
+        {
+            public bool Everything { get; set; } = true;
+
+            [JsonProperty(ItemConverterType = typeof(Newtonsoft.Json.Converters.StringEnumConverter))]
+            public WebhookEventType[] SpecificEvents { get; set; } = Array.Empty<WebhookEventType>();
+        }
+
+        public bool Enabled { get; set; } = true;
+        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public string Secret { get; set; }
+        public bool AutomaticRedelivery { get; set; } = true;
+        public string Url { get; set; }
+        public AuthorizedEventsData AuthorizedEvents { get; set; } = new AuthorizedEventsData();
+    }
+    public class UpdateStoreWebhookRequest : StoreWebhookBaseData
+    {
+    }
+    public class CreateStoreWebhookRequest : StoreWebhookBaseData
+    {
+    }
+    public class StoreWebhookData : StoreWebhookBaseData
+    {
+        public string Id { get; set; }
+    }
+}

BTCPayServer.Client/Models/UpdateInvoiceRequest.cs

@@ -0,0 +1,9 @@
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Client.Models
+{
+    public class UpdateInvoiceRequest
+    {
+        public JObject Metadata { get; set; }
+    }
+}