Update submodule fix

btcpayserver/.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

btcpayserver/.circleci/config.yml

@@ -0,0 +1,84 @@
+version: 2
+jobs:
+  fast_tests:
+    machine:
+      image: ubuntu-2004:2024.11.1
+    steps:
+      - checkout
+      - run:
+          command: |
+            cd .circleci && ./run-tests.sh "Fast=Fast|ThirdParty=ThirdParty" && ./can-build.sh
+  playwright_tests:
+    machine:
+      image: ubuntu-2004:2024.11.1
+    steps:
+      - checkout
+      - run:
+          command: |
+            cd .circleci && ./run-tests.sh "Playwright=Playwright"
+  selenium_tests:
+    machine:
+      image: ubuntu-2004:2024.11.1
+    steps:
+      - checkout
+      - run:
+          command: |
+            cd .circleci && ./run-tests.sh "Selenium=Selenium"
+  integration_tests:
+    machine:
+      image: ubuntu-2004:2024.11.1
+    steps:
+      - checkout
+      - run:
+          command: |
+            cd .circleci && ./run-tests.sh "Integration=Integration"
+  trigger_docs_build:
+    machine:
+      image: ubuntu-2004:2024.11.1
+    steps:
+      - run:
+          command: |
+            curl -X POST -H "Authorization: token $GH_PAT" -H "Accept: application/vnd.github.everest-preview+json" -H "Content-Type: application/json" https://api.github.com/repos/btcpayserver/btcpayserver-doc/dispatches --data '{"event_type": "build_docs"}'
+  # publish jobs require $DOCKERHUB_REPO, $DOCKERHUB_USER, $DOCKERHUB_PASS defined
+  docker:
+    docker:
+      - image: cimg/base:stable
+    steps:
+      - setup_remote_docker
+      - checkout
+      - run:
+          command: |
+            LATEST_TAG=${CIRCLE_TAG:1} #trim v from tag
+            GIT_COMMIT=$(git rev-parse HEAD)
+            #
+            docker login --username=$DOCKERHUB_USER --password=$DOCKERHUB_PASS
+            docker buildx create --use
+            DOCKER_BUILDX_OPTS="--platform linux/amd64,linux/arm64,linux/arm/v7 --build-arg GIT_COMMIT=${GIT_COMMIT} --push"
+            docker buildx build $DOCKER_BUILDX_OPTS -t $DOCKERHUB_REPO:$LATEST_TAG .
+workflows:
+  version: 2
+  build_and_test:
+    jobs:
+      - fast_tests
+      - playwright_tests 
+      - selenium_tests
+      - integration_tests
+  publish:
+    jobs:
+      - trigger_docs_build:
+          filters:
+            branches:
+              ignore: /.*/
+            # only act on version tags
+            tags:
+              only: /(v[1-9]+(\.[0-9]+)*(-[a-z0-9-]+)?)|(v[a-z0-9-]+)/
+      - docker:
+          filters:
+            # ignore any commit on any branch by default
+            branches:
+              ignore: /.*/
+            # 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]+)*(-[a-z0-9-]+)?)|(v[a-z0-9-]+)/

btcpayserver/.circleci/run-tests.sh

@@ -0,0 +1,18 @@
+#!/bin/sh
+set -e
+
+cd ../BTCPayServer.Tests
+docker-compose --version
+docker-compose -f "docker-compose.altcoins.yml" down -v
+
+# For some reason, docker-compose pull fails time to time, so we try several times
+n=0
+until [ "$n" -ge 10 ]
+do
+   docker-compose -f "docker-compose.altcoins.yml" pull && break
+   n=$((n+1)) 
+   sleep 5
+done
+
+docker-compose -f "docker-compose.altcoins.yml" build
+docker-compose -f "docker-compose.altcoins.yml" run -e "TEST_FILTERS=$1" tests

btcpayserver/.coderabbit.yaml

@@ -0,0 +1,140 @@
+language: en-US
+tone_instructions: ''
+early_access: false
+enable_free_tier: true
+auto_resolve_threads: true
+reviews:
+  summaries:
+    include_walkthrough: false
+  profile: chill
+  request_changes_workflow: false
+  high_level_summary: false
+  high_level_summary_placeholder: '@coderabbitai summary'
+  high_level_summary_in_walkthrough: false
+  auto_title_placeholder: '@coderabbitai'
+  auto_title_instructions: ''
+  review_status: true
+  commit_status: true
+  fail_commit_status: false
+  collapse_walkthrough: false
+  changed_files_summary: false
+  sequence_diagrams: false
+  assess_linked_issues: true
+  related_issues: true
+  related_prs: true
+  suggested_labels: true
+  auto_apply_labels: false
+  suggested_reviewers: true
+  auto_assign_reviewers: false
+  poem: false
+  labeling_instructions: []
+  path_filters: []
+  path_instructions: []
+  abort_on_close: true
+  pr_description: false
+  auto_review:
+    enabled: true
+    auto_incremental_review: true
+    ignore_title_keywords: []
+    labels: []
+    drafts: false
+    base_branches: []
+  finishing_touches:
+    docstrings:
+      enabled: true
+  tools:
+    ast-grep:
+      rule_dirs: []
+      util_dirs: []
+      essential_rules: true
+      packages: []
+    shellcheck:
+      enabled: true
+    ruff:
+      enabled: true
+    markdownlint:
+      enabled: true
+    github-checks:
+      enabled: true
+      timeout_ms: 90000
+    languagetool:
+      enabled: true
+      enabled_rules: []
+      disabled_rules: []
+      enabled_categories: []
+      disabled_categories: []
+      enabled_only: false
+      level: default
+    biome:
+      enabled: true
+    hadolint:
+      enabled: true
+    swiftlint:
+      enabled: true
+    phpstan:
+      enabled: true
+      level: default
+    golangci-lint:
+      enabled: true
+    yamllint:
+      enabled: true
+    gitleaks:
+      enabled: true
+    checkov:
+      enabled: true
+    detekt:
+      enabled: true
+    eslint:
+      enabled: true
+    rubocop:
+      enabled: true
+    buf:
+      enabled: true
+    regal:
+      enabled: true
+    actionlint:
+      enabled: true
+    pmd:
+      enabled: true
+    cppcheck:
+      enabled: true
+    semgrep:
+      enabled: true
+    circleci:
+      enabled: true
+    sqlfluff:
+      enabled: true
+    prismaLint:
+      enabled: true
+    oxc:
+      enabled: true
+    shopifyThemeCheck:
+      enabled: true
+chat:
+  auto_reply: true
+  create_issues: true
+  integrations:
+    jira:
+      usage: auto
+    linear:
+      usage: auto
+knowledge_base:
+  opt_out: false
+  web_search:
+    enabled: true
+  learnings:
+    scope: auto
+  issues:
+    scope: auto
+  jira:
+    usage: auto
+    project_keys: []
+  linear:
+    usage: auto
+    team_keys: []
+  pull_requests:
+    scope: auto
+code_generation:
+  docstrings:
+    language: en-US
+    path_instructions: []

btcpayserver/.dockerignore

@@ -0,0 +1,124 @@
+# Build Folders (you can keep bin if you'd like, to store dlls and pdbs)
+**/[Bb]in/
+**/[Oo]bj/
+node_modules/
+dist/
+
+# mstest test results
+TestResults
+
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+
+# User-specific files
+*.suo
+*.user
+*.sln.docstates
+
+# Build results
+[Dd]ebug/
+[Rr]elease/
+x64/
+*_i.c
+*_p.c
+*.ilk
+*.meta
+*.obj
+*.pch
+*.pdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.log
+*.vspscc
+*.vssscc
+.builds
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opensdf
+*.sdf
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*
+
+# NCrunch
+*.ncrunch*
+.*crunch*.local.xml
+
+# Installshield output folder 
+[Ee]xpress
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish
+
+# Publish Web Output
+*.Publish.xml
+
+# NuGet Packages Directory
+packages
+
+# Windows Azure Build Output
+csx
+*.build.csdef
+
+# Windows Store app package directory
+AppPackages/
+
+# Others
+[Bb]in
+[Oo]bj
+sql
+TestResults
+[Tt]est[Rr]esult*
+*.Cache
+ClientBin
+[Ss]tyle[Cc]op.*
+~$*
+*.dbmdl
+Generated_Code #added for RIA/Silverlight projects
+
+# Backup & report files from converting an old project file to a newer
+# Visual Studio version. Backup files are not needed, because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+
+src/Rapporteringsregisteret.Web/assets/less/*.css
+
+MetricResults/
+*.sln.ide/
+
+_configs/
+
+# vnext stuff
+bower_components
+output
+
+.vs
+**/launchSettings.json

btcpayserver/.editorconfig

@@ -0,0 +1,277 @@
+root = true
+# editorconfig.org
+
+# top-most EditorConfig file
+
+# Default settings:
+# A newline ending every file
+# Use 4 spaces as indentation
+[*]
+insert_final_newline = true
+indent_style = space
+indent_size = 4
+charset = utf-8
+space_before_self_closing = true
+ij_html_space_inside_empty_tag = true
+max_line_length = 160
+end_of_line = crlf
+trim_trailing_whitespace = true
+
+# Microsoft .NET properties
+csharp_new_line_before_members_in_object_initializers = false
+csharp_preferred_modifier_order = public, private, protected, internal, file, new, static, abstract, virtual, sealed, readonly, override, extern, unsafe, volatile, async, required:suggestion
+csharp_style_prefer_utf8_string_literals = true:suggestion
+csharp_style_var_elsewhere = true:suggestion
+csharp_style_var_for_built_in_types = true:suggestion
+csharp_style_var_when_type_is_apparent = true:suggestion
+dotnet_naming_rule.unity_serialized_field_rule.import_to_resharper = True
+dotnet_naming_rule.unity_serialized_field_rule.resharper_description = Unity serialized field
+dotnet_naming_rule.unity_serialized_field_rule.resharper_guid = 5f0fdb63-c892-4d2c-9324-15c80b22a7ef
+dotnet_naming_rule.unity_serialized_field_rule.severity = none
+dotnet_naming_rule.unity_serialized_field_rule.style = lower_camel_case_style
+dotnet_naming_rule.unity_serialized_field_rule.symbols = unity_serialized_field_symbols
+dotnet_naming_rule.unity_serialized_field_rule_1.import_to_resharper = True
+dotnet_naming_rule.unity_serialized_field_rule_1.resharper_description = Unity serialized field
+dotnet_naming_rule.unity_serialized_field_rule_1.resharper_guid = 5f0fdb63-c892-4d2c-9324-15c80b22a7ef
+dotnet_naming_rule.unity_serialized_field_rule_1.severity = none
+dotnet_naming_rule.unity_serialized_field_rule_1.style = lower_camel_case_style
+dotnet_naming_rule.unity_serialized_field_rule_1.symbols = unity_serialized_field_symbols_1
+dotnet_naming_style.lower_camel_case_style.capitalization = camel_case
+dotnet_naming_symbols.unity_serialized_field_symbols.applicable_accessibilities = *
+dotnet_naming_symbols.unity_serialized_field_symbols.applicable_kinds = 
+dotnet_naming_symbols.unity_serialized_field_symbols.resharper_applicable_kinds = unity_serialised_field
+dotnet_naming_symbols.unity_serialized_field_symbols.resharper_required_modifiers = instance
+dotnet_naming_symbols.unity_serialized_field_symbols_1.applicable_accessibilities = *
+dotnet_naming_symbols.unity_serialized_field_symbols_1.applicable_kinds = 
+dotnet_naming_symbols.unity_serialized_field_symbols_1.resharper_applicable_kinds = unity_serialised_field
+dotnet_naming_symbols.unity_serialized_field_symbols_1.resharper_required_modifiers = instance
+dotnet_style_parentheses_in_arithmetic_binary_operators = never_if_unnecessary:none
+dotnet_style_parentheses_in_other_binary_operators = always_for_clarity:none
+dotnet_style_parentheses_in_relational_binary_operators = never_if_unnecessary:none
+dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion
+dotnet_style_predefined_type_for_member_access = true:suggestion
+dotnet_style_qualification_for_event = false:suggestion
+dotnet_style_qualification_for_field = false:suggestion
+dotnet_style_qualification_for_method = false:suggestion
+dotnet_style_qualification_for_property = false:suggestion
+dotnet_style_require_accessibility_modifiers = for_non_interface_members:suggestion
+
+# ReSharper properties
+resharper_apply_auto_detected_rules = false
+resharper_autodetect_indent_settings = true
+resharper_cpp_insert_final_newline = true
+resharper_csharp_insert_final_newline = false
+resharper_formatter_off_tag = @formatter:off
+resharper_formatter_on_tag = @formatter:on
+resharper_formatter_tags_enabled = true
+resharper_fsharp_insert_final_newline = false
+resharper_html_insert_final_newline = false
+resharper_resx_insert_final_newline = false
+resharper_shaderlab_insert_final_newline = false
+resharper_t4_insert_final_newline = false
+resharper_use_indent_from_vs = false
+resharper_vb_insert_final_newline = false
+resharper_xmldoc_insert_final_newline = false
+resharper_xml_insert_final_newline = false
+
+# ReSharper inspection severities
+resharper_access_to_disposed_closure_highlighting = none
+resharper_arrange_redundant_parentheses_highlighting = hint
+resharper_arrange_this_qualifier_highlighting = hint
+resharper_arrange_type_member_modifiers_highlighting = hint
+resharper_arrange_type_modifiers_highlighting = hint
+resharper_built_in_type_reference_style_for_member_access_highlighting = hint
+resharper_built_in_type_reference_style_highlighting = hint
+resharper_convert_type_check_pattern_to_null_check_highlighting = none
+resharper_empty_general_catch_clause_highlighting = none
+resharper_inconsistent_naming_highlighting = none
+resharper_mvc_action_not_resolved_highlighting = warning
+resharper_mvc_area_not_resolved_highlighting = warning
+resharper_mvc_controller_not_resolved_highlighting = warning
+resharper_mvc_masterpage_not_resolved_highlighting = warning
+resharper_mvc_partial_view_not_resolved_highlighting = warning
+resharper_mvc_template_not_resolved_highlighting = warning
+resharper_mvc_view_component_not_resolved_highlighting = warning
+resharper_mvc_view_component_view_not_resolved_highlighting = warning
+resharper_mvc_view_not_resolved_highlighting = warning
+resharper_razor_assembly_not_resolved_highlighting = warning
+resharper_redundant_base_qualifier_highlighting = warning
+resharper_redundant_explicit_tuple_component_name_highlighting = none
+resharper_suggest_var_or_type_built_in_types_highlighting = hint
+resharper_suggest_var_or_type_elsewhere_highlighting = hint
+resharper_suggest_var_or_type_simple_types_highlighting = hint
+resharper_use_collection_expression_highlighting = none
+resharper_use_object_or_collection_initializer_highlighting = none
+resharper_web_config_module_not_resolved_highlighting = warning
+resharper_web_config_type_not_resolved_highlighting = warning
+resharper_web_config_wrong_module_highlighting = warning
+
+[*.json]
+indent_size = 2
+
+[swagger*.json]
+indent_size = 4
+
+# C# files
+[*.cs]
+# New line preferences
+csharp_new_line_before_open_brace = all
+csharp_new_line_before_else = true
+csharp_new_line_before_catch = true
+csharp_new_line_before_finally = true
+csharp_new_line_before_members_in_object_initializers = true
+csharp_new_line_before_members_in_anonymous_types = true
+csharp_new_line_within_query_expression_clauses = true
+
+# Indentation preferences
+csharp_indent_block_contents = true
+csharp_indent_braces = false
+csharp_indent_case_contents = true
+csharp_indent_switch_labels = true
+csharp_indent_labels = flush_left
+
+# avoid this. unless absolutely necessary
+dotnet_style_qualification_for_field = false:suggestion
+dotnet_style_qualification_for_property = false:suggestion
+dotnet_style_qualification_for_method = false:suggestion
+dotnet_style_qualification_for_event = false:suggestion
+
+# always use var when possible
+csharp_style_var_for_built_in_types = true:suggestion
+csharp_style_var_when_type_is_apparent = true:suggestion
+csharp_style_var_elsewhere = true:suggestion
+
+# use language keywords instead of BCL types
+dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion
+dotnet_style_predefined_type_for_member_access = true:suggestion
+
+# name all constant fields using PascalCase
+dotnet_naming_rule.constant_fields_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.constant_fields_should_be_pascal_case.symbols = constant_fields
+dotnet_naming_rule.constant_fields_should_be_pascal_case.style = pascal_case_style
+
+dotnet_naming_symbols.constant_fields.applicable_kinds = field
+dotnet_naming_symbols.constant_fields.required_modifiers = const
+
+dotnet_naming_style.pascal_case_style.capitalization = pascal_case
+
+# internal and private fields should be _camelCase
+dotnet_naming_rule.camel_case_for_private_internal_fields.severity = suggestion
+dotnet_naming_rule.camel_case_for_private_internal_fields.symbols = private_internal_fields
+dotnet_naming_rule.camel_case_for_private_internal_fields.style = camel_case_underscore_style
+
+dotnet_naming_symbols.private_internal_fields.applicable_kinds = field
+dotnet_naming_symbols.private_internal_fields.applicable_accessibilities = private, internal
+
+dotnet_naming_style.camel_case_underscore_style.required_prefix = _
+dotnet_naming_style.camel_case_underscore_style.capitalization = camel_case
+
+# Code style defaults
+dotnet_sort_system_directives_first = true
+csharp_preserve_single_line_blocks = true
+csharp_preserve_single_line_statements = false
+
+# Expression-level preferences
+dotnet_style_object_initializer = true:suggestion
+dotnet_style_collection_initializer = true:suggestion
+dotnet_style_explicit_tuple_names = true:suggestion
+dotnet_style_coalesce_expression = true:suggestion
+dotnet_style_null_propagation = true:suggestion
+
+# Expression-bodied members
+csharp_style_expression_bodied_methods = false:none
+csharp_style_expression_bodied_constructors = false:none
+csharp_style_expression_bodied_operators = false:none
+csharp_style_expression_bodied_properties = true:none
+csharp_style_expression_bodied_indexers = true:none
+csharp_style_expression_bodied_accessors = true:none
+
+# Property and accessor preferences
+csharp_style_auto_properties = true:suggestion
+csharp_style_inlined_variable_declaration = true:suggestion
+csharp_keep_existing_attribute_arrangement = true
+csharp_keep_existing_initializer_arrangement = true
+csharp_prefer_simple_auto_property = true:suggestion
+
+# Pattern matching
+csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion
+csharp_style_pattern_matching_over_as_with_null_check = true:suggestion
+csharp_style_inlined_variable_declaration = true:suggestion
+
+# Null checking preferences
+csharp_style_throw_expression = true:suggestion
+csharp_style_conditional_delegate_call = true:suggestion
+
+# Space preferences
+csharp_space_after_cast = false
+csharp_space_after_colon_in_inheritance_clause = true
+csharp_space_after_comma = true
+csharp_space_after_dot = false
+csharp_space_after_keywords_in_control_flow_statements = true
+csharp_space_after_semicolon_in_for_statement = true
+csharp_space_around_binary_operators = before_and_after
+csharp_space_around_declaration_statements = do_not_ignore
+csharp_space_before_colon_in_inheritance_clause = true
+csharp_space_before_comma = false
+csharp_space_before_dot = false
+csharp_space_before_open_square_brackets = false
+csharp_space_before_semicolon_in_for_statement = false
+csharp_space_between_empty_square_brackets = false
+csharp_space_between_method_call_empty_parameter_list_parentheses = false
+csharp_space_between_method_call_name_and_opening_parenthesis = false
+csharp_space_between_method_call_parameter_list_parentheses = false
+csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
+csharp_space_between_method_declaration_name_and_open_parenthesis = false
+csharp_space_between_method_declaration_parameter_list_parentheses = false
+csharp_space_between_parentheses = false
+csharp_space_between_square_brackets = false
+csharp_style_prefer_null_check_over_type_check = true:warning
+csharp_prefer_simple_using_statement = true:warning
+
+# C++ Files
+
+[*.{cpp,h,in}]
+curly_bracket_next_line = true
+indent_brace_style = Allman
+
+# Xml project files
+[*.{csproj,vcxproj,vcxproj.filters,proj,nativeproj,locproj}]
+indent_size = 2
+
+# Xml build files
+[*.builds]
+indent_size = 2
+
+# Xml files
+[*.{xml,stylecop,resx,ruleset}]
+indent_size = 2
+
+# Xml config files
+[*.{props,targets,config,nuspec}]
+indent_size = 2
+
+# Shell scripts
+[*.{cmd, bat}]
+end_of_line = crlf
+
+[{*.bash,*.sh,*.zsh}]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+
+[{*.har,*.jsb2,*.jsb3,*.jsonc,*.postman_collection,*.postman_collection.json,*.postman_environment,*.postman_environment.json,.babelrc,.eslintrc,.prettierrc,.stylelintrc,.ws-context,jest.config}]
+indent_style = space
+indent_size = 2
+
+[{*.yaml,*.yml}]
+indent_style = space
+indent_size = 2
+
+[*.map]
+indent_style = space
+indent_size = 2
+
+[*.{appxmanifest,asax,ascx,aspx,axaml,blockshader,build,c,c++,c++m,cc,ccm,cginc,compute,cp,cpp,cppm,cs,cshtml,cu,cuh,cxx,cxxm,dtd,fs,fsi,fsscript,fsx,fx,fxh,h,h++,hh,hlsl,hlsli,hlslinc,hp,hpp,hxx,icc,inc,inl,ino,ipp,ixx,master,ml,mli,mpp,mq4,mq5,mqh,mxx,nuspec,paml,razor,resw,resx,shader,shaderFoundry,skin,tcc,tpp,urtshader,usf,ush,uxml,vb,xaml,xamlx,xoml,xsd}]
+indent_style = space
+indent_size = 4
+tab_width = 4

btcpayserver/.gitattributes

@@ -0,0 +1,17 @@
+# Set the default behavior, in case people don't have core.autocrlf set.
+* text=auto
+
+# Explicitly declare text files you want to always be normalized and converted
+# to native line endings on checkout.
+*.c text
+*.h text
+
+# Declare files that will always have CRLF line endings on checkout.
+*.sln text eol=crlf
+
+# Declare files that will always have CRLF line endings on checkout.
+*.sh text eol=lf
+
+# Denote all files that are truly binary and should not be modified.
+*.png binary
+*.jpg binary

btcpayserver/.github/FUNDING.yml

@@ -0,0 +1,2 @@
+# These are supported funding model platforms
+custom: https://foundation.btcpayserver.org

btcpayserver/.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,68 @@
+name: 🐛 Bug Report
+description: File a bug report
+title: "[Bug]: "
+labels: ["bug"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this bug report! Please provide as much information as you can. It helps us better understand the problem and fix it faster.
+  - type: textarea
+    id: version
+    attributes:
+      label: What is your BTCPay version?
+      description: You can see the version in the footer's bottom right corner
+      placeholder: I'm running BTCPay v1.X.X.X
+    validations:
+      required: true
+  - type: textarea
+    id: deployment
+    attributes:
+      label: How did you deploy BTCPay Server?
+      description: Docker, manual, third-party host? Read more on deployment methods [here](https://docs.btcpayserver.org/Deployment/)
+      placeholder: I'm running BTCPay Server on a...
+    validations:
+      required: true
+  - type: textarea
+    id: what-happened
+    attributes:
+      label: What happened?
+      description: A clear and concise description of what the bug is.
+      placeholder: Tell us what you see!
+    validations:
+      required: true
+  - type: textarea
+    id: reproduce
+    attributes:
+      label: How did you encounter this bug?
+      description: Step by step describe how did you encounter the bug?
+      placeholder: 1. I clicked X 2. Then I clicked Y 3. See error
+    validations:
+      required: true
+  - type: textarea
+    id: logoutput
+    attributes:
+      label: Relevant log output
+      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks. Logs can be found in Server Settings > Logs. Here's how you can [troubleshoot an issue](https://docs.btcpayserver.org/Troubleshooting/)
+      render: shell
+  - type: textarea
+    id: browser
+    attributes:
+      label: What browser do you use?
+      description: Provide your browser and it's version. If you replicated issues on multiple browsers, let us know which ones.
+      placeholder: For example Safari 15.00, Chrome 10.0, Tor, Edge, etc
+    validations:
+      required: false
+  - type: textarea
+    id: additonal
+    attributes:
+      label: Additional information
+      description: Feel free to provide additional information. Screenshots are always helpful.
+  - type: checkboxes
+    id: terms
+    attributes:
+      label: Are you sure this is a bug report?
+      description: By submitting this report, you agree that this is not a support or a feature request. For general questions please read our [documentation](https://docs.btcpayserver.org). You can ask questions in [discussions](https://github.com/btcpayserver/btcpayserver/discussions) and [on our community chat](https://chat.btcpayserver.org) Beware of scammers we will never direct you to third-party sites for support or ask for sensitive information your private key especially. Ignore any bots and scammers replies to GitHub issues claiming to be support agents
+      options:
+        - label: I confirm this is a bug report
+          required: true

btcpayserver/.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,17 @@
+blank_issues_enabled: true
+contact_links:
+  - name: 💡 Request a feature
+    url: https://github.com/btcpayserver/btcpayserver/discussions/categories/ideas-feature-requests
+    about: Submit a feature request or vote on ideas posted by others. Features with most upvotes become roadmap candidates
+  - name: 🧑‍💻 Ask a technical question
+    url: https://github.com/btcpayserver/btcpayserver/discussions/new?category=technical-support
+    about: If you're experiencing a technical problem post it to our community support forum
+  - name: 🔌 Report a problem with a plugin
+    url: https://github.com/btcpayserver/btcpayserver/discussions/new?category=plugins-integrations
+    about: Experiencing a problem with a third-party plugin? Post it here and we will tag their developers to assist
+  - name: 📝 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

btcpayserver/.github/codeql/codeql-config.yml

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

btcpayserver/.github/workflows/codeql.yml

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

btcpayserver/.gitignore

@@ -0,0 +1,304 @@
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+##
+## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
+
+# User-specific files
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+.vs/
+
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+bld/
+[Bb]in/
+[Oo]bj/
+[Ll]og/
+
+# Visual Studio 2015 cache/options directory
+.vs/
+# Uncomment if you have tasks that create the project's static files in wwwroot
+#wwwroot/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+# NUNIT
+*.VisualState.xml
+TestResult.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+# .NET Core
+project.lock.json
+project.fragment.lock.json
+artifacts/
+
+*_i.c
+*_p.c
+*_i.h
+*.ilk
+*.meta
+*.obj
+*.pch
+*.pdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
+*.VC.db
+*.VC.VC.opendb
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+*.sap
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# JustCode is a .NET coding add-in
+.JustCode
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# Visual Studio code coverage results
+*.coverage
+*.coveragexml
+
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+nCrunchTemp_*
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+# TODO: Comment the next line if you want to checkin your web deploy settings
+# but database connection strings (with potential passwords) will be unencrypted
+*.pubxml
+*.publishproj
+
+# Microsoft Azure Web App publish settings. Comment the next line if you want to
+# checkin your Azure Web App publish settings, but sensitive information contained
+# in these scripts will be unencrypted
+PublishScripts/
+
+# NuGet Packages
+*.nupkg
+# The packages folder can be ignored because of Package Restore
+**/packages/*
+# except build/, which is used as an MSBuild target.
+!**/packages/build/
+# Uncomment if necessary however generally it will be regenerated when needed
+#!**/packages/repositories.config
+# NuGet v3's project.json files produces more ignorable files
+*.nuget.props
+*.nuget.targets
+
+# Microsoft Azure Build Output
+csx/
+*.build.csdef
+
+# Microsoft Azure Emulator
+ecf/
+rcf/
+
+# Windows Store app package directories and files
+AppPackages/
+BundleArtifacts/
+Package.StoreAssociation.xml
+_pkginfo.txt
+
+# Visual Studio cache files
+# files ending in .cache can be ignored
+*.[Cc]ache
+# but keep track of directories ending in .cache
+!*.[Cc]ache/
+
+# Others
+ClientBin/
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.jfm
+*.pfx
+*.publishsettings
+orleans.codegen.cs
+
+# Since there are multiple workflows, uncomment next line to ignore bower_components
+# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
+#bower_components/
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+
+# SQL Server files
+*.mdf
+*.ldf
+*.ndf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# GhostDoc plugin setting file
+*.GhostDoc.xml
+
+# Node.js Tools for Visual Studio
+.ntvs_analysis.dat
+node_modules/
+
+# Typescript v1 declaration files
+typings/
+
+# Visual Studio 6 build log
+*.plg
+
+# Visual Studio 6 workspace options file
+*.opt
+
+# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
+*.vbw
+
+# Visual Studio LightSwitch build output
+**/*.HTMLClient/GeneratedArtifacts
+**/*.DesktopClient/GeneratedArtifacts
+**/*.DesktopClient/ModelManifest.xml
+**/*.Server/GeneratedArtifacts
+**/*.Server/ModelManifest.xml
+_Pvt_Extensions
+
+# Paket dependency manager
+.paket/paket.exe
+paket-files/
+
+# FAKE - F# Make
+.fake/
+
+# JetBrains Rider
+.idea/
+*.sln.iml
+.run
+
+# CodeRush
+.cr/
+
+# Python Tools for Visual Studio (PTVS)
+__pycache__/
+*.pyc
+
+# Cake - Uncomment if you are using it
+# tools/**
+# !tools/packages.config
+
+# Telerik's JustMock configuration file
+*.jmconfig
+
+# BizTalk build output
+*.btp.cs
+*.btm.cs
+*.odx.cs
+*.xsd.cs
+/BTCPayServer/Build/dockerfiles
+
+.vscode/*
+!.vscode/launch.json
+!.vscode/tasks.json
+!.vscode/extensions.json
+BTCPayServer/testpwd
+.DS_Store
+Packed Plugins
+Plugins/packed
+
+BTCPayServer/wwwroot/swagger/v1/openapi.json
+BTCPayServer/appsettings.dev.json
+BTCPayServer.Tests/monero_wallet
+/BTCPayServer.Tests/NewBlocks.bat

btcpayserver/.vscode/extensions.json

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

btcpayserver/.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/net8.0/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": "\\bNow listening on:\\s+(https?://\\S+)"
+            },
+            "env": {
+                "ASPNETCORE_ENVIRONMENT": "Development"
+            },
+            "sourceFileMap": {
+                "/Views": "${workspaceFolder}/Views"
+            },
+            "logging": {
+                "moduleLoad": false
+            }
+        }
+    ]
+}

btcpayserver/.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/BTCPayServer.Abstractions/BTCPayServer.Abstractions.csproj

@@ -0,0 +1,41 @@
+<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="HtmlSanitizer" Version="8.0.838" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.11" />
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="8.0.11" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\BTCPayServer.Client\BTCPayServer.Client.csproj" />
+  </ItemGroup>
+</Project>

btcpayserver/BTCPayServer.Abstractions/CamelCaseSerializerSettings.cs

@@ -0,0 +1,18 @@
+using Newtonsoft.Json;
+
+namespace BTCPayServer.Abstractions
+{
+    public class CamelCaseSerializerSettings
+    {
+        static CamelCaseSerializerSettings()
+        {
+            Settings = new JsonSerializerSettings()
+            {
+                ContractResolver = new Newtonsoft.Json.Serialization.CamelCasePropertyNamesContractResolver()
+            };
+            Serializer = JsonSerializer.Create(Settings);
+        }
+        public static readonly JsonSerializerSettings Settings;
+        public static readonly JsonSerializer Serializer;
+    }
+}

btcpayserver/BTCPayServer.Abstractions/Configuration/DataDirectories.cs

@@ -0,0 +1,21 @@
+using System.IO;
+
+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; }
+        public string TempDir { get; set; }
+        public string LangsDir { get; set; }
+
+        public string ToDatadirFullPath(string path)
+        {
+            if (Path.IsPathRooted(path))
+                return path;
+            return Path.Combine(DataDir, path);
+        }
+    }
+}

btcpayserver/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/BTCPayServer.Abstractions/Constants/WellKnownTempData.cs

@@ -0,0 +1,7 @@
+namespace BTCPayServer.Abstractions.Constants;
+
+public class WellKnownTempData
+{
+    public const string SuccessMessage = nameof(SuccessMessage);
+    public const string ErrorMessage = nameof(ErrorMessage);
+}

btcpayserver/BTCPayServer.Abstractions/Contracts/BaseDbContextFactory.cs

@@ -0,0 +1,94 @@
+using System;
+using BTCPayServer.Abstractions.Models;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.Extensions.Options;
+using Npgsql;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Infrastructure;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Migrations.Operations;
+
+namespace BTCPayServer.Abstractions.Contracts
+{
+    public abstract class BaseDbContextFactory<T> where T : DbContext
+    {
+        private readonly IOptions<DatabaseOptions> _options;
+        private readonly string _migrationTableName;
+
+        public BaseDbContextFactory(IOptions<DatabaseOptions> options, string migrationTableName)
+        {
+            _options = options;
+            _migrationTableName = migrationTableName;
+        }
+
+        public T CreateContext() => CreateContext(null);
+        public abstract T CreateContext(Action<NpgsqlDbContextOptionsBuilder> npgsqlOptionsAction = null);
+        class CustomNpgsqlMigrationsSqlGenerator : NpgsqlMigrationsSqlGenerator
+        {
+#pragma warning disable EF1001 // Internal EF Core API usage.
+            public CustomNpgsqlMigrationsSqlGenerator(MigrationsSqlGeneratorDependencies dependencies, Npgsql.EntityFrameworkCore.PostgreSQL.Infrastructure.Internal.INpgsqlSingletonOptions opts) : base(dependencies, opts)
+#pragma warning restore EF1001 // Internal EF Core API usage.
+            {
+            }
+
+            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) => ConfigureBuilder(builder, null);
+        public void ConfigureBuilder(DbContextOptionsBuilder builder, Action<NpgsqlDbContextOptionsBuilder> npgsqlOptionsAction = null)
+        {
+            builder
+            .UseNpgsql(_options.Value.ConnectionString, o =>
+            {
+                o.EnableRetryOnFailure(10);
+                o.SetPostgresVersion(12, 0);
+                npgsqlOptionsAction?.Invoke(o);
+                var mainSearchPath = GetSearchPath(_options.Value.ConnectionString);
+                var schemaPrefix = string.IsNullOrEmpty(_migrationTableName) ? "__EFMigrationsHistory" : _migrationTableName;
+                o.MigrationsHistoryTable(schemaPrefix, mainSearchPath);
+            })
+            .ReplaceService<IMigrationsSqlGenerator, CustomNpgsqlMigrationsSqlGenerator>();
+        }
+
+        private string GetSearchPath(string connectionString)
+        {
+            var connectionStringBuilder = new NpgsqlConnectionStringBuilder(connectionString);
+            var searchPaths = connectionStringBuilder.SearchPath?.Split(',');
+            return searchPaths is not { Length: > 0 } ? null : searchPaths[0];
+        }
+    }
+}

btcpayserver/BTCPayServer.Abstractions/Contracts/IBTCPayServerClientFactory.cs

@@ -0,0 +1,12 @@
+using System.Threading.Tasks;
+using BTCPayServer.Client;
+using Microsoft.AspNetCore.Http;
+
+namespace BTCPayServer.Abstractions.Contracts
+{
+    public interface IBTCPayServerClientFactory
+    {
+        Task<BTCPayServerClient> Create(string userId, params string[] storeIds);
+        Task<BTCPayServerClient> Create(string userId, string[] storeIds, HttpContext httpRequest);
+    }
+}

btcpayserver/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/BTCPayServer.Abstractions/Contracts/IFileService.cs

@@ -0,0 +1,19 @@
+#nullable enable
+using System;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using BTCPayServer.Abstractions.Models;
+
+namespace BTCPayServer.Abstractions.Contracts;
+
+public interface IFileService
+{
+    Task<bool> IsAvailable();
+    Task<IStoredFile> AddFile(IFormFile file, string userId);
+    Task<IStoredFile> AddFile(Uri file, string userId);
+    Task<string?> GetFileUrl(Uri baseUri, string fileId);
+    Task<string?> GetTemporaryFileUrl(Uri baseUri, string fileId, DateTimeOffset expiry,
+        bool isDownload);
+    Task RemoveFile(string fileId, string userId);
+    Task<UploadImageResultModel> UploadImage(IFormFile file, string userId, long maxFileSizeInBytes = 1_000_000);
+}

btcpayserver/BTCPayServer.Abstractions/Contracts/INotificationHandler.cs

@@ -0,0 +1,30 @@
+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 string Identifier { get; set; }
+        public string Type { get; set; }
+        public DateTimeOffset Created { get; set; }
+        public string Body { get; set; }
+        public string ActionLink { get; set; }
+        public bool Seen { get; set; }
+        public string StoreId { get; set; }
+    }
+}

btcpayserver/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/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/BTCPayServer.Abstractions/Contracts/IPluginHookService.cs

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

btcpayserver/BTCPayServer.Abstractions/Contracts/IScopeProvider.cs

@@ -0,0 +1,7 @@
+#nullable enable
+namespace BTCPayServer.Abstractions.Contracts;
+
+public interface IScopeProvider
+{
+    string? GetCurrentStoreId();
+}

btcpayserver/BTCPayServer.Abstractions/Contracts/ISettingsRepository.cs

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

btcpayserver/BTCPayServer.Abstractions/Contracts/IStartupTask.cs

@@ -0,0 +1,10 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Abstractions.Contracts
+{
+    public interface IStartupTask
+    {
+        Task ExecuteAsync(CancellationToken cancellationToken = default);
+    }
+}

btcpayserver/BTCPayServer.Abstractions/Contracts/IStoreRepository.cs

@@ -0,0 +1,12 @@
+#nullable enable
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace BTCPayServer.Abstractions.Contracts;
+
+public interface IStoreRepository
+{
+    Task<T?> GetSettingAsync<T>(string storeId, string name) where T : class;
+    Task<Dictionary<string, T?>> GetSettingsAsync<T>(string name) where T : class;
+    Task UpdateSetting<T>(string storeId, string name, T obj) where T : class;
+}

btcpayserver/BTCPayServer.Abstractions/Contracts/IStoredFile.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace BTCPayServer.Abstractions.Contracts;
+
+public interface IStoredFile
+{
+    string Id { get; set; }
+    string FileName { get; set; }
+    string StorageFileName { get; set; }
+    DateTime Timestamp { get; set; }
+    string ApplicationUserId { get; set; }
+}

btcpayserver/BTCPayServer.Abstractions/Contracts/ISwaggerProvider.cs

@@ -0,0 +1,9 @@
+using System.Threading.Tasks;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Abstractions.Contracts;
+
+public interface ISwaggerProvider
+{
+    Task<JObject> Fetch();
+}

btcpayserver/BTCPayServer.Abstractions/Contracts/ISyncSummaryProvider.cs

@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+
+namespace BTCPayServer.Abstractions.Contracts
+{
+    public interface ISyncSummaryProvider
+    {
+        bool AllAvailable();
+
+        string Partial { get; }
+        IEnumerable<ISyncStatus> GetStatuses();
+    }
+
+    public interface ISyncStatus
+    {
+        public string PaymentMethodId { get; set; }
+        public bool Available { get; }
+    }
+}

btcpayserver/BTCPayServer.Abstractions/Contracts/IUIExtension.cs

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

btcpayserver/BTCPayServer.Abstractions/Contracts/IUTXOLocker.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using NBitcoin;
+
+namespace BTCPayServer.Payments.PayJoin;
+
+public interface IUTXOLocker
+{
+    Task<bool> TryLock(OutPoint outpoint);
+    Task<bool> TryUnlock(params OutPoint[] outPoints);
+    Task<bool> TryLockInputs(OutPoint[] outPoints);
+    Task<HashSet<OutPoint>> FindLocks(OutPoint[] outpoints);
+}

btcpayserver/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/BTCPayServer.Abstractions/Extensions/GreenfieldExtensions.cs

@@ -0,0 +1,47 @@
+using System.Collections.Generic;
+using BTCPayServer.Client.Models;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.ModelBinding;
+
+namespace BTCPayServer.Abstractions.Extensions;
+
+public static class GreenfieldExtensions
+{
+    public static IActionResult UserNotFound(this ControllerBase ctrl)
+    {
+        return ctrl.CreateAPIError(404, "user-not-found", "The user was not found");
+    }
+    public static IActionResult CreateValidationError(this ControllerBase controller, ModelStateDictionary modelState)
+    {
+        return controller.UnprocessableEntity(modelState.ToGreenfieldValidationError());
+    }
+
+    public static List<GreenfieldValidationError> ToGreenfieldValidationError(this ModelStateDictionary modelState)
+    {
+        List<GreenfieldValidationError> errors = new List<GreenfieldValidationError>();
+        foreach (var error in modelState)
+        {
+            foreach (var errorMessage in error.Value.Errors)
+            {
+                errors.Add(new GreenfieldValidationError(error.Key, errorMessage.ErrorMessage));
+            }
+        }
+
+        return errors;
+    }
+
+    public static IActionResult CreateAPIError(this ControllerBase controller, string errorCode, string errorMessage)
+    {
+        return controller.BadRequest(new GreenfieldAPIError(errorCode, errorMessage));
+    }
+
+    public static IActionResult CreateAPIError(this ControllerBase controller, int httpCode, string errorCode, string errorMessage)
+    {
+        return controller.StatusCode(httpCode, new GreenfieldAPIError(errorCode, errorMessage));
+    }
+
+    public static IActionResult CreateAPIPermissionError(this ControllerBase controller, string missingPermission, string message = null)
+    {
+        return controller.StatusCode(403, new GreenfieldPermissionAPIError(missingPermission, message));
+    }
+}

btcpayserver/BTCPayServer.Abstractions/Extensions/HttpRequestExtensions.cs

@@ -0,0 +1,131 @@
+using System;
+using Microsoft.AspNetCore.Http;
+
+namespace BTCPayServer.Abstractions.Extensions;
+
+public static class HttpRequestExtensions
+{
+    public static bool IsOnion(this HttpRequest request)
+    {
+        if (request?.Host.Host == null)
+            return false;
+        return request.Host.Host.EndsWith(".onion", StringComparison.OrdinalIgnoreCase);
+    }
+
+    public static string GetAbsoluteRoot(this HttpRequest request)
+    {
+        return string.Concat(
+            request.Scheme,
+            "://",
+            request.Host.ToUriComponent(),
+            request.PathBase.ToUriComponent());
+    }
+
+    public static Uri GetAbsoluteRootUri(this HttpRequest request)
+    {
+        return new Uri(request.GetAbsoluteRoot());
+    }
+
+    public static string GetCurrentUrl(this HttpRequest request)
+    {
+        return string.Concat(
+            request.Scheme,
+            "://",
+            request.Host.ToUriComponent(),
+            request.PathBase.ToUriComponent(),
+            request.Path.ToUriComponent());
+    }
+
+    public static string GetCurrentUrlWithQueryString(this HttpRequest request)
+    {
+        return string.Concat(
+            request.Scheme,
+            "://",
+            request.Host.ToUriComponent(),
+            request.PathBase.ToUriComponent(),
+            request.Path.ToUriComponent(),
+            request.QueryString.ToUriComponent());
+    }
+
+    public static string GetCurrentPath(this HttpRequest request)
+    {
+        return string.Concat(
+            request.PathBase.ToUriComponent(),
+            request.Path.ToUriComponent());
+    }
+
+    public static string GetCurrentPathWithQueryString(this HttpRequest request)
+    {
+        return request.PathBase + request.Path + request.QueryString;
+    }
+
+    /// <summary>
+    /// If 'toto' and RootPath is 'rootpath' returns '/rootpath/toto'
+    /// If 'toto' and RootPath is empty returns '/toto'
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="path"></param>
+    /// <returns></returns>
+    public static string GetRelativePath(this HttpRequest request, string path)
+    {
+        if (path.Length > 0 && path[0] != '/')
+            path = $"/{path}";
+        return string.Concat(
+            request.PathBase.ToUriComponent(),
+            path);
+    }
+
+    /// <summary>
+    /// If 'https://example.com/toto' returns 'https://example.com/toto'
+    /// If 'toto' and RootPath is 'rootpath' returns '/rootpath/toto'
+    /// If 'toto' and RootPath is empty returns '/toto'
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="path"></param>
+    /// <returns></returns>
+    public static string GetRelativePathOrAbsolute(this HttpRequest request, string path)
+    {
+        if (!Uri.TryCreate(path, UriKind.RelativeOrAbsolute, out var uri) ||
+            uri.IsAbsoluteUri)
+            return path;
+
+        if (path.Length > 0 && path[0] != '/')
+            path = $"/{path}";
+        return string.Concat(
+            request.PathBase.ToUriComponent(),
+            path);
+    }
+
+    public static string GetAbsoluteUri(this HttpRequest request, string redirectUrl)
+    {
+        bool isRelative =
+            (redirectUrl.Length > 0 && redirectUrl[0] == '/')
+            || !new Uri(redirectUrl, UriKind.RelativeOrAbsolute).IsAbsoluteUri;
+        return isRelative ? request.GetAbsoluteRoot() + redirectUrl : redirectUrl;
+    }
+
+    /// <summary>
+    /// Will return an absolute URL. 
+    /// If `relativeOrAbsolute` is absolute, returns it.
+    /// If `relativeOrAbsolute` is relative, send absolute url based on the HOST of this request (without PathBase)
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="relativeOrAbsolte"></param>
+    /// <returns></returns>
+    public static Uri GetAbsoluteUriNoPathBase(this HttpRequest request, Uri relativeOrAbsolute = null)
+    {
+        if (relativeOrAbsolute == null)
+        {
+            return new Uri(string.Concat(
+                request.Scheme,
+                "://",
+                request.Host.ToUriComponent()), UriKind.Absolute);
+        }
+        if (relativeOrAbsolute.IsAbsoluteUri)
+            return relativeOrAbsolute;
+        return new Uri(string.Concat(
+            request.Scheme,
+            "://",
+            request.Host.ToUriComponent()) + relativeOrAbsolute.ToString().WithStartingSlash(), UriKind.Absolute);
+    }
+}

btcpayserver/BTCPayServer.Abstractions/Extensions/ITempDataDictionaryExtensions.cs

@@ -0,0 +1,62 @@
+using System.Text.Json;
+using BTCPayServer.Abstractions.Constants;
+using BTCPayServer.Abstractions.Models;
+using Microsoft.AspNetCore.Mvc.ViewFeatures;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Abstractions.Extensions;
+
+public static class SetStatusMessageModelExtensions
+{
+    public static void SetStatusSuccess(this ITempDataDictionary tempData, string statusMessage)
+    {
+        tempData.SetStatusMessageModel(new StatusMessageModel
+        {
+            Severity = StatusMessageModel.StatusSeverity.Success,
+            Message = statusMessage
+        });
+    }
+    public static void SetStatusMessageModel(this ITempDataDictionary tempData, StatusMessageModel statusMessage)
+    {
+        if (statusMessage == null)
+        {
+            tempData.Remove("StatusMessageModel");
+            return;
+        }
+
+        tempData["StatusMessageModel"] = JsonSerializer.Serialize(statusMessage, new JsonSerializerOptions());
+    }
+
+    public static StatusMessageModel GetStatusMessageModel(this ITempDataDictionary tempData)
+    {
+        tempData.TryGetValue(WellKnownTempData.SuccessMessage, out var successMessage);
+        tempData.TryGetValue(WellKnownTempData.ErrorMessage, out var errorMessage);
+        tempData.TryGetValue("StatusMessageModel", out var model);
+        if (successMessage != null || errorMessage != null)
+        {
+            var parsedModel = new StatusMessageModel
+            {
+                Message = (string)successMessage ?? (string)errorMessage,
+                Severity = successMessage != null ? StatusMessageModel.StatusSeverity.Success : StatusMessageModel.StatusSeverity.Error
+            };
+            return parsedModel;
+        }
+        if (model is string str)
+        {
+            return JObject.Parse(str).ToObject<StatusMessageModel>();
+        }
+        return null;
+    }
+
+    public static bool HasStatusMessage(this ITempDataDictionary tempData)
+    {
+        return (tempData.Peek(WellKnownTempData.SuccessMessage) ??
+                tempData.Peek(WellKnownTempData.ErrorMessage) ??
+                tempData.Peek("StatusMessageModel")) != null;
+    }
+
+    public static bool HasErrorMessage(this ITempDataDictionary tempData)
+    {
+        return GetStatusMessageModel(tempData)?.Severity == StatusMessageModel.StatusSeverity.Error;
+    }
+}

btcpayserver/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/BTCPayServer.Abstractions/Extensions/StringExtensions.cs

@@ -0,0 +1,43 @@
+using System;
+using System.IO;
+using System.Linq;
+
+namespace BTCPayServer.Abstractions.Extensions;
+
+public static class StringExtensions
+{
+    public static bool IsValidFileName(this string fileName)
+    {
+        return !fileName.ToCharArray().Any(c => Path.GetInvalidFileNameChars().Contains(c)
+                                                || c == Path.AltDirectorySeparatorChar
+                                                || c == Path.DirectorySeparatorChar
+                                                || c == Path.PathSeparator
+                                                || c == '\\');
+    }
+
+    public static string Truncate(this string value, int maxLength)
+    {
+        if (string.IsNullOrEmpty(value))
+            return value;
+        return value.Length <= maxLength ? value : value.Substring(0, maxLength);
+    }
+
+    public static string WithTrailingSlash(this string str)
+    {
+        if (str.EndsWith("/", StringComparison.InvariantCulture))
+            return str;
+        return str + "/";
+    }
+    public static string WithStartingSlash(this string str)
+    {
+        if (str.StartsWith("/", StringComparison.InvariantCulture))
+            return str;
+        return $"/{str}";
+    }
+    public static string WithoutEndingSlash(this string str)
+    {
+        if (str.EndsWith("/", StringComparison.InvariantCulture))
+            return str.Substring(0, str.Length - 1);
+        return str;
+    }
+}

btcpayserver/BTCPayServer.Abstractions/Extensions/ViewsRazor.cs

@@ -0,0 +1,199 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using Microsoft.AspNetCore.Html;
+using Microsoft.AspNetCore.Mvc.ViewFeatures;
+
+namespace BTCPayServer.Abstractions.Extensions
+{
+    public static class ViewsRazor
+    {
+        private const string ACTIVE_CATEGORY_KEY = "ActiveCategory";
+        private const string ACTIVE_PAGE_KEY = "ActivePage";
+        private const string ACTIVE_ID_KEY = "ActiveId";
+        private const string ACTIVE_CLASS = "active";
+
+        public enum DateDisplayFormat
+        {
+            Localized,
+            Relative
+        }
+
+        public static void SetBlazorAllowed(this ViewDataDictionary viewData, bool allowed)
+        {
+            viewData["BlazorAllowed"] = allowed;
+        }
+        public static bool IsBlazorAllowed(this ViewDataDictionary viewData)
+        {
+            return viewData["BlazorAllowed"] is not false;
+        }
+
+        public static void SetActivePage<T>(this ViewDataDictionary viewData, T activePage, string title = null, string activeId = null)
+            where T : IConvertible
+        {
+            SetActivePage(viewData, activePage.ToString(), activePage.GetType().ToString(), title, activeId);
+        }
+
+        public static void SetActivePage(this ViewDataDictionary viewData, string activePage, string category, string title = null, string activeId = null)
+        {
+            // Page Title
+            viewData["Title"] = title ?? activePage;
+            // Navigation
+            viewData[ACTIVE_PAGE_KEY] = activePage;
+            viewData[ACTIVE_ID_KEY] = activeId;
+            SetActiveCategory(viewData, category);
+        }
+
+        public static void SetActiveCategory<T>(this ViewDataDictionary viewData, T activeCategory)
+        {
+            SetActiveCategory(viewData, activeCategory.ToString());
+        }
+
+        public static void SetActiveCategory(this ViewDataDictionary viewData, string activeCategory)
+        {
+            viewData[ACTIVE_CATEGORY_KEY] = activeCategory;
+        }
+
+        public static bool IsCategoryActive(this ViewDataDictionary viewData, string category, object id = null)
+        {
+            if (!viewData.ContainsKey(ACTIVE_CATEGORY_KEY)) return false;
+            var activeId = viewData[ACTIVE_ID_KEY];
+            var activeCategory = viewData[ACTIVE_CATEGORY_KEY]?.ToString();
+            var categoryMatch = category.Equals(activeCategory, StringComparison.InvariantCultureIgnoreCase);
+            var idMatch = id == null || activeId == null || id.Equals(activeId);
+            return categoryMatch && idMatch;
+        }
+
+        public static bool IsCategoryActive<T>(this ViewDataDictionary viewData, T category, object id = null)
+        {
+            return IsCategoryActive(viewData, category.ToString(), id);
+        }
+
+        public static bool IsPageActive(this ViewDataDictionary viewData, string page, string category, object id = null)
+        {
+            if (!viewData.ContainsKey(ACTIVE_PAGE_KEY)) return false;
+            var activeId = viewData[ACTIVE_ID_KEY];
+            var activePage = viewData[ACTIVE_PAGE_KEY]?.ToString();
+            var activeCategory = viewData[ACTIVE_CATEGORY_KEY]?.ToString();
+            var categoryAndPageMatch = page.Equals(activePage, StringComparison.InvariantCultureIgnoreCase) &&
+                (category == null || activeCategory != null && activeCategory.Equals(category, StringComparison.InvariantCultureIgnoreCase));
+            var idMatch = id == null || activeId == null || id.Equals(activeId);
+            return categoryAndPageMatch && idMatch;
+        }
+        
+        public static bool IsPageActive<T>(this ViewDataDictionary viewData, IEnumerable<T> pages, object id = null)
+            where T : IConvertible
+        {
+            return pages.Any(page => ActivePageClass(viewData, page.ToString(), page.GetType().ToString(), id) == ACTIVE_CLASS);
+        }
+
+        public static string ActiveCategoryClass<T>(this ViewDataDictionary viewData, T category, object id = null)
+        {
+            return ActiveCategoryClass(viewData, category.ToString(), id);
+        }
+
+        public static string ActiveCategoryClass(this ViewDataDictionary viewData, string category, object id = null)
+        {
+            return IsCategoryActive(viewData, category, id) ? ACTIVE_CLASS : null;
+        }
+
+        public static string ActivePageClass<T>(this ViewDataDictionary viewData, T page, object id = null)
+            where T : IConvertible
+        {
+            return ActivePageClass(viewData, page.ToString(), page.GetType().ToString(), id);
+        }
+
+        public static string ActivePageClass(this ViewDataDictionary viewData, string page, string category, object id = null)
+        {
+            return IsPageActive(viewData, page, category, id) ? ACTIVE_CLASS : null;
+        }
+
+        public static string ActivePageClass<T>(this ViewDataDictionary viewData, IEnumerable<T> pages, object id = null) where T : IConvertible
+        {
+            return IsPageActive(viewData, pages, id) ? ACTIVE_CLASS : null;
+        }
+
+        [Obsolete("Use ActiveCategoryClass instead")]
+        public static string IsActiveCategory<T>(this ViewDataDictionary viewData, T category, object id = null)
+        {
+            return ActiveCategoryClass(viewData, category, id);
+        }
+
+        [Obsolete("Use ActiveCategoryClass instead")]
+        public static string IsActiveCategory(this ViewDataDictionary viewData, string category, object id = null)
+        {
+            return ActiveCategoryClass(viewData, category, id);
+        }
+
+        [Obsolete("Use ActivePageClass instead")]
+        public static string IsActivePage<T>(this ViewDataDictionary viewData, T page, object id = null) where T : IConvertible
+        {
+            return ActivePageClass(viewData, page, id);
+        }
+
+        [Obsolete("Use ActivePageClass instead")]
+        public static string IsActivePage<T>(this ViewDataDictionary viewData, IEnumerable<T> pages, object id = null) where T : IConvertible
+        {
+            return ActivePageClass(viewData, pages, id);
+        }
+
+        [Obsolete("Use ActivePageClass instead")]
+        public static string IsActivePage(this ViewDataDictionary viewData, string page, string category, object id = null)
+        {
+            return ActivePageClass(viewData, page, category, id);
+        }
+
+        public static HtmlString ToBrowserDate(this DateTimeOffset date, string netFormat, string jsDateFormat = "short", string jsTimeFormat = "short")
+        {
+            var dateTime = date.ToString("o", CultureInfo.InvariantCulture);
+            var displayDate = date.ToString(netFormat, CultureInfo.InvariantCulture);
+            var tooltip = dateTime.Replace("T", " ");
+            return new HtmlString($"<time datetime=\"{dateTime}\" data-date-style=\"{jsDateFormat}\" data-time-style=\"{jsTimeFormat}\" data-initial=\"localized\" data-bs-toggle=\"tooltip\" data-bs-title=\"{tooltip}\">{displayDate}</time>");
+        }
+
+        public static HtmlString ToBrowserDate(this DateTimeOffset date, DateDisplayFormat format = DateDisplayFormat.Localized)
+        {
+            var relative = date.ToTimeAgo();
+            var initial = format.ToString().ToLower();
+            var dateTime = date.ToString("o", CultureInfo.InvariantCulture);
+            var displayDate = format == DateDisplayFormat.Relative ? relative : date.ToString("g", CultureInfo.InvariantCulture);
+            return new HtmlString($"<time datetime=\"{dateTime}\" data-relative=\"{relative}\" data-initial=\"{initial}\">{displayDate}</time>");
+        }
+
+        public static HtmlString ToBrowserDate(this DateTime date, DateDisplayFormat format = DateDisplayFormat.Localized)
+        {
+            var relative = date.ToTimeAgo();
+            var initial = format.ToString().ToLower();
+            var dateTime = date.ToString("o", CultureInfo.InvariantCulture);
+            var displayDate = format == DateDisplayFormat.Relative ? relative : date.ToString("g", CultureInfo.InvariantCulture);
+            return new HtmlString($"<time datetime=\"{dateTime}\" data-relative=\"{relative}\" data-initial=\"{initial}\">{displayDate}</time>");
+        }
+
+        public static string ToTimeAgo(this DateTimeOffset date) => (DateTimeOffset.UtcNow - date).ToTimeAgo();
+
+        public static string ToTimeAgo(this DateTime date) => (DateTimeOffset.UtcNow - date).ToTimeAgo();
+
+        public static string ToTimeAgo(this TimeSpan diff) => diff.TotalSeconds > 0 ? $"{diff.TimeString()} ago" : $"in {diff.Negate().TimeString()}";
+
+        public static string TimeString(this TimeSpan timeSpan)
+        {
+            if (timeSpan.TotalMinutes < 1)
+            {
+                return $"{(int)timeSpan.TotalSeconds} second{Plural((int)timeSpan.TotalSeconds)}";
+            }
+            if (timeSpan.TotalHours < 1)
+            {
+                return $"{(int)timeSpan.TotalMinutes} minute{Plural((int)timeSpan.TotalMinutes)}";
+            }
+            return timeSpan.Days < 1
+                ? $"{(int)timeSpan.TotalHours} hour{Plural((int)timeSpan.TotalHours)}"
+                : $"{(int)timeSpan.TotalDays} day{Plural((int)timeSpan.TotalDays)}";
+        }
+
+        private static string Plural(int value)
+        {
+            return value == 1 ? string.Empty : "s";
+        }
+    }
+}

btcpayserver/BTCPayServer.Abstractions/Form/AlertMessage.cs

@@ -0,0 +1,37 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace BTCPayServer.Abstractions.Form;
+
+public class AlertMessage
+{
+    // Corresponds to the Bootstrap CSS "alert alert-xxx" messages:
+    // Success = green
+    // Warning = orange
+    // Danger = red
+    // Info = blue
+    public enum AlertMessageType
+    {
+        Success,
+        Warning,
+        Danger,
+        Info
+    }
+
+    [JsonConverter(typeof(StringEnumConverter))]
+    public AlertMessageType Type;
+
+    // The translated message to be shown to the user
+    public string Message;
+
+    public AlertMessage()
+    {
+
+    }
+
+    public AlertMessage(AlertMessageType type, string message)
+    {
+        this.Type = type;
+        this.Message = message;
+    }
+}

btcpayserver/BTCPayServer.Abstractions/Form/Field.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.AspNetCore.Mvc.ModelBinding;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Abstractions.Form;
+
+public class Field
+{
+    public static Field Create(string label, string name, string value, bool required, string helpText, string type = "text")
+    {
+        return new Field
+        {
+            Label = label,
+            Name = name,
+            Value = value,
+            OriginalValue = value,
+            Required = required,
+            HelpText = helpText,
+            Type = type
+        };
+    }
+    // The name of the HTML5 node. Should be used as the key for the posted data.
+    public string Name;
+
+    public bool Constant;
+
+    // HTML5 compatible type string like "text", "textarea", "email", "password", etc.
+    public string Type;
+
+    public static Field CreateFieldset()
+    {
+        return new Field { Type = "fieldset" };
+    }
+
+    // The value field is what is currently in the DB or what the user entered, but possibly not saved yet due to validation errors.
+    // If this is the first the user sees the form, then value and original value are the same. Value changes as the user starts interacting with the form.
+    public string Value;
+
+    public bool Required;
+
+    // The translated label of the field.
+    public string Label;
+
+    // The original value is the value that is currently saved in the backend. A "reset" button can be used to revert back to this. Should only be set from the constructor.
+    public string OriginalValue;
+
+    // A useful note shown below the field or via a tooltip / info icon. Should be translated for the user.
+    public string HelpText;
+
+    [JsonExtensionData] public IDictionary<string, JToken> AdditionalData { get; set; }
+    public List<Field> Fields { get; set; } = new();
+
+    // The field is considered "valid" if there are no validation errors
+    public List<string> ValidationErrors = new();
+
+    public virtual bool IsValid()
+    {
+        return ValidationErrors.Count == 0 && Fields.All(field => field.IsValid());
+    }
+}

btcpayserver/BTCPayServer.Abstractions/Form/Form.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Primitives;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Abstractions.Form;
+
+public class Form
+{
+#nullable enable
+    public static Form Parse(string str)
+    {
+        ArgumentNullException.ThrowIfNull(str);
+        return JObject.Parse(str).ToObject<Form>(CamelCaseSerializerSettings.Serializer) ?? throw new InvalidOperationException("Impossible to deserialize Form");
+    }
+    public override string ToString()
+    {
+        return JObject.FromObject(this, CamelCaseSerializerSettings.Serializer).ToString(Newtonsoft.Json.Formatting.Indented);
+    }
+#nullable restore
+
+    // Messages to be shown at the top of the form indicating user feedback like "Saved successfully" or "Please change X because of Y." or a warning, etc...
+    public List<AlertMessage> TopMessages { get; set; } = new();
+
+    // Groups of fields in the form
+    public List<Field> Fields { get; set; } = new();
+
+    // Are all the fields valid in the form?
+    public bool IsValid()
+    {
+        if (TopMessages?.Any(t => t.Type == AlertMessage.AlertMessageType.Danger) is true)
+            return false;
+        return Fields.Select(f => f.IsValid()).All(o => o);
+    }
+
+    public Field GetFieldByFullName(string fullName)
+    {
+        foreach (var f in GetAllFields())
+        {
+            if (f.FullName == fullName)
+                return f.Field;
+        }
+        return null;
+    }
+
+    public IEnumerable<(string FullName, List<string> Path, Field Field)> GetAllFields()
+    {
+        HashSet<string> nameReturned = new();
+        foreach (var f in GetAllFieldsCore(new List<string>(), Fields))
+        {
+            var fullName = string.Join('_', f.Path.Where(s => !string.IsNullOrEmpty(s)));
+            if (!nameReturned.Add(fullName))
+                continue;
+            yield return (fullName, f.Path, f.Field);
+        }
+    }
+
+    public bool ValidateFieldNames(out List<string> errors)
+    {
+        errors = new List<string>();
+        HashSet<string> nameReturned = new();
+        foreach (var f in GetAllFieldsCore(new List<string>(), Fields))
+        {
+            var fullName = string.Join('_', f.Path.Where(s => !string.IsNullOrEmpty(s)));
+            if (!nameReturned.Add(fullName))
+            {
+                errors.Add($"Form contains duplicate field names '{fullName}'");
+            }
+        }
+        return errors.Count == 0;
+    }
+
+    IEnumerable<(List<string> Path, Field Field)> GetAllFieldsCore(List<string> path, List<Field> fields)
+    {
+        foreach (var field in fields)
+        {
+            List<string> thisPath = new(path.Count + 1);
+            thisPath.AddRange(path);
+            if (!string.IsNullOrEmpty(field.Name))
+            {
+                thisPath.Add(field.Name);
+                yield return (thisPath, field);
+            }
+            foreach (var descendant in GetAllFieldsCore(thisPath, field.Fields))
+            {
+                descendant.Field.Constant = field.Constant || descendant.Field.Constant;
+                yield return descendant;
+            }
+        }
+    }
+
+    public void ApplyValuesFromForm(IEnumerable<KeyValuePair<string, StringValues>> form)
+    {
+        var values = form.GroupBy(f => f.Key, f => f.Value).ToDictionary(g => g.Key, g => g.First());
+        foreach (var f in GetAllFields())
+        {
+            if (f.Field.Constant || !values.TryGetValue(f.FullName, out var val))
+                continue;
+
+            f.Field.Value = val;
+        }
+    }
+
+    
+
+
+}

btcpayserver/BTCPayServer.Abstractions/Models/BaseBTCPayServerPlugin.cs

@@ -0,0 +1,69 @@
+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 virtual string Identifier
+        {
+            get
+            {
+                return GetType().GetTypeInfo().Assembly.GetName().Name;
+            }
+        }
+        public virtual string Name
+        {
+            get
+            {
+                return GetType().GetTypeInfo().Assembly
+                        .GetCustomAttribute<AssemblyProductAttribute>()?
+                        .Product ?? "???";
+            }
+        }
+
+        public virtual Version Version
+        {
+            get
+            {
+                return GetVersion(GetType().GetTypeInfo().Assembly
+                        .GetCustomAttribute<AssemblyInformationalVersionAttribute>()?
+                        .InformationalVersion) ??
+                        Assembly.GetAssembly(GetType())?.GetName()?.Version ??
+                        new Version(1, 0, 0, 0);
+            }
+        }
+
+        private static Version GetVersion(string informationalVersion)
+        {
+            if (informationalVersion is null)
+                return null;
+            Version.TryParse(informationalVersion, out var r);
+            return r;
+        }
+
+        public virtual string Description
+        {
+            get
+            {
+                return GetType().GetTypeInfo().Assembly
+                        .GetCustomAttribute<AssemblyDescriptionAttribute>()?
+                        .Description ?? string.Empty;
+            }
+        }
+        public 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/BTCPayServer.Abstractions/Models/ConfirmModel.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace BTCPayServer.Abstractions.Models
+{
+    public class ConfirmModel
+    {
+        private const string ButtonClassDefault = "btn-danger";
+        public ConfirmModel() { }
+
+        public ConfirmModel(string title, string desc, string action = null, string buttonClass = ButtonClassDefault, string actionName = null, string controllerName = null)
+        {
+            Title = title;
+            Description = desc;
+            Action = action;
+            ActionName = actionName;
+            ControllerName = controllerName;
+            ButtonClass = buttonClass;
+
+            if (Description.Contains("<strong>", StringComparison.InvariantCultureIgnoreCase))
+            {
+                DescriptionHtml = true;
+            }
+        }
+
+        public bool GenerateForm { get; set; } = true;
+        public string Title { get; set; }
+        public string Description { get; set; }
+        public bool DescriptionHtml { get; set; }
+        public string Action { get; set; }
+        public string ActionName { get; set; }
+        public string ControllerName { get; set; }
+        public string ButtonClass { get; set; } = ButtonClassDefault;
+    }
+}

btcpayserver/BTCPayServer.Abstractions/Models/DatabaseOptions.cs

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

btcpayserver/BTCPayServer.Abstractions/Models/StatusMessageModel.cs

@@ -0,0 +1,42 @@
+using System;
+
+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 => ToString(Severity);
+
+        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,
+            Error,
+            Success,
+            Warning
+        }
+    }
+}

btcpayserver/BTCPayServer.Abstractions/Models/UploadImageResultModel.cs

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

btcpayserver/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/BTCPayServer.Abstractions/Security/AuthorizationFilterHandle.cs

@@ -0,0 +1,27 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+
+namespace BTCPayServer.Security;
+
+public class AuthorizationFilterHandle
+{
+    public AuthorizationHandlerContext Context { get; }
+    public PolicyRequirement Requirement { get; }
+    public HttpContext HttpContext { get; }
+    public bool Success { get; private set; }
+
+    public AuthorizationFilterHandle(
+        AuthorizationHandlerContext context,
+        PolicyRequirement requirement,
+        HttpContext httpContext)
+    {
+        Context = context;
+        Requirement = requirement;
+        HttpContext = httpContext;
+    }
+
+    public void MarkSuccessful()
+    {
+        Success = true;
+    }
+}

btcpayserver/BTCPayServer.Abstractions/Security/ContentSecurityPolicies.cs

@@ -0,0 +1,151 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NBitcoin.Crypto;
+
+namespace BTCPayServer.Security
+{
+    public class ConsentSecurityPolicy
+    {
+        public ConsentSecurityPolicy(string name, string value)
+        {
+            if (value.Contains(';', StringComparison.OrdinalIgnoreCase))
+                throw new FormatException();
+            _Value = value;
+            _Name = name;
+        }
+
+
+        private readonly string _Name;
+        public string Name
+        {
+            get
+            {
+                return _Name;
+            }
+        }
+
+        private readonly string _Value;
+        public string Value
+        {
+            get
+            {
+                return _Value;
+            }
+        }
+
+
+        public override bool Equals(object obj)
+        {
+            ConsentSecurityPolicy item = obj as ConsentSecurityPolicy;
+            if (item == null)
+                return false;
+            return GetHashCode().Equals(item.GetHashCode());
+        }
+        public static bool operator ==(ConsentSecurityPolicy a, ConsentSecurityPolicy b)
+        {
+            if (System.Object.ReferenceEquals(a, b))
+                return true;
+            if (((object)a == null) || ((object)b == null))
+                return false;
+            return a.GetHashCode() == b.GetHashCode();
+        }
+
+        public static bool operator !=(ConsentSecurityPolicy a, ConsentSecurityPolicy b)
+        {
+            return !(a == b);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(Name, Value);
+        }
+    }
+    public class ContentSecurityPolicies
+    {
+        public ContentSecurityPolicies()
+        {
+
+        }
+
+        readonly HashSet<ConsentSecurityPolicy> _Policies = new HashSet<ConsentSecurityPolicy>();
+
+        /// <summary>
+        /// Allow a specific script as event handler
+        /// </summary>
+        /// <param name="script"></param>
+        public void AllowUnsafeHashes(string script = null)
+        {
+            if (!allowUnsafeHashes)
+            {
+                Add("script-src", $"'unsafe-hashes'");
+                allowUnsafeHashes = true;
+            }
+            if (script != null)
+            {
+                var sha = GetSha256(script);
+                Add("script-src", $"'sha256-{sha}'");
+            }
+        }
+
+        bool allowUnsafeHashes = false;
+        /// <summary>
+        /// Allow the injection of script tag with the following script
+        /// </summary>
+        /// <param name="script"></param>
+        public void AllowInline(string script)
+        {
+            ArgumentNullException.ThrowIfNull(script);
+            var sha = GetSha256(script);
+            Add("script-src", $"'sha256-{sha}'");
+        }
+
+        static string GetSha256(string script)
+        {
+            return Convert.ToBase64String(Hashes.SHA256(Encoding.UTF8.GetBytes(script.Replace("\r\n", "\n", StringComparison.Ordinal))));
+        }
+
+        public void Add(string name, string value)
+        {
+            Add(new ConsentSecurityPolicy(name, value));
+        }
+        public void Add(ConsentSecurityPolicy policy)
+        {
+            _Policies.Add(policy);
+        }
+
+        public void UnsafeEval()
+        {
+            Add("script-src", "'unsafe-eval'");
+        }
+
+        public IEnumerable<ConsentSecurityPolicy> Rules => _Policies;
+        public bool HasRules => _Policies.Count != 0;
+
+        public override string ToString()
+        {
+            StringBuilder value = new StringBuilder();
+            bool firstGroup = true;
+            foreach (var group in Rules.GroupBy(r => r.Name))
+            {
+                if (!firstGroup)
+                {
+                    value.Append(';');
+                }
+                HashSet<string> values = new HashSet<string>();
+                List<string> valuesList = new List<string>();
+                values.Add(group.Key);
+                valuesList.Add(group.Key);
+                foreach (var v in group)
+                {
+                    if (values.Add(v.Value))
+                        valuesList.Add(v.Value);
+                }
+                value.Append(String.Join(" ", valuesList.OfType<object>().ToArray()));
+                firstGroup = false;
+            }
+            return value.ToString();
+        }
+    }
+}

btcpayserver/BTCPayServer.Abstractions/Security/PolicyRequirement.cs

@@ -0,0 +1,15 @@
+using System;
+using Microsoft.AspNetCore.Authorization;
+
+namespace BTCPayServer.Security
+{
+    public class PolicyRequirement : IAuthorizationRequirement
+    {
+        public PolicyRequirement(string policy)
+        {
+            ArgumentNullException.ThrowIfNull(policy);
+            Policy = policy;
+        }
+        public string Policy { get; }
+    }
+}

btcpayserver/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/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/BTCPayServer.Abstractions/Services/Safe.cs

@@ -0,0 +1,72 @@
+using System.Web;
+using Ganss.Xss;
+using Microsoft.AspNetCore.Html;
+using Microsoft.AspNetCore.Mvc.Rendering;
+
+namespace BTCPayServer.Abstractions.Services
+{
+    public class Safe
+    {
+        private readonly IHtmlHelper _htmlHelper;
+        private readonly IJsonHelper _jsonHelper;
+        private readonly HtmlSanitizer _htmlSanitizer;
+
+        public Safe(IHtmlHelper htmlHelper, IJsonHelper jsonHelper, HtmlSanitizer htmlSanitizer)
+        {
+            _htmlHelper = htmlHelper;
+            _jsonHelper = jsonHelper;
+            _htmlSanitizer = htmlSanitizer;
+
+
+        }
+
+        public IHtmlContent Raw(string value)
+        {
+            return _htmlHelper.Raw(_htmlSanitizer.Sanitize(value));
+        }
+        
+        public IHtmlContent RawEncode(string value)
+        {
+            return _htmlHelper.Raw(HttpUtility.HtmlEncode(_htmlSanitizer.Sanitize(value)));
+        }
+
+        public IHtmlContent Json(object model)
+        {
+            return _htmlHelper.Raw(_jsonHelper.Serialize(model));
+        }
+
+        public IHtmlContent Meta(string inputHtml) => _htmlHelper.Raw(RawMeta(inputHtml, out _));
+
+        public string RawMeta(string inputHtml, out bool isHtmlModified)
+        {
+             bool bHtmlModified;
+             HtmlSanitizer sane = new HtmlSanitizer();
+
+            sane.AllowedTags.Clear();
+            sane.AllowedTags.Add("meta");
+
+            sane.AllowedAttributes.Clear();
+            sane.AllowedAttributes.Add("name");
+            sane.AllowedAttributes.Add("http-equiv");
+            sane.AllowedAttributes.Add("content");
+            sane.AllowedAttributes.Add("value");
+            sane.AllowedAttributes.Add("property");
+
+            sane.AllowDataAttributes = false;
+
+            sane.RemovingTag += (sender, e) => bHtmlModified = true;
+            sane.RemovingAtRule += (sender, e) => bHtmlModified = true;
+            sane.RemovingAttribute += (sender, e) => bHtmlModified = true;
+            sane.RemovingComment += (sender, e) => bHtmlModified = true;
+            sane.RemovingCssClass += (sender, e) => bHtmlModified = true;
+            sane.RemovingStyle += (sender, e) => bHtmlModified = true;
+            
+            bHtmlModified = false;
+
+            var sRet = sane.Sanitize(inputHtml);
+            isHtmlModified = bHtmlModified;
+
+            return sRet;
+        }
+    }
+}

btcpayserver/BTCPayServer.Abstractions/Services/UIExtension.cs

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

btcpayserver/BTCPayServer.Abstractions/TagHelpers/CSPA.cs

@@ -0,0 +1,30 @@
+using System;
+using BTCPayServer.Security;
+using Microsoft.AspNetCore.Razor.TagHelpers;
+
+namespace BTCPayServer.Abstractions.TagHelpers;
+
+/// <summary>
+/// Add sha256- to allow inline event handlers in a:href=javascript:
+/// </summary>
+[HtmlTargetElement("a", Attributes = "csp-allow")]
+public class CSPA : TagHelper
+{
+    private readonly ContentSecurityPolicies _csp;
+    public CSPA(ContentSecurityPolicies csp)
+    {
+        _csp = csp;
+    }
+    public override void Process(TagHelperContext context, TagHelperOutput output)
+    {
+        output.Attributes.RemoveAll("csp-allow");
+        if (output.Attributes.TryGetAttribute("href", out var attr))
+        {
+            var v = attr.Value.ToString();
+            if (v.StartsWith("javascript:", StringComparison.OrdinalIgnoreCase))
+            {
+                _csp.AllowUnsafeHashes(v);
+            }
+        }
+    }
+}

btcpayserver/BTCPayServer.Abstractions/TagHelpers/CSPEventTagHelper.cs

@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+using System.Linq;
+using BTCPayServer.Security;
+using Microsoft.AspNetCore.Razor.TagHelpers;
+
+namespace BTCPayServer.Abstractions.TagHelpers;
+
+/// <summary>
+/// Add 'unsafe-hashes' and sha256- to allow inline event handlers in CSP
+/// </summary>
+[HtmlTargetElement(Attributes = "onclick")]
+[HtmlTargetElement(Attributes = "onkeypress")]
+[HtmlTargetElement(Attributes = "onchange")]
+[HtmlTargetElement(Attributes = "onsubmit")]
+public class CSPEventTagHelper : TagHelper
+{
+    public const string EventNames = "onclick,onkeypress,onchange,onsubmit";
+    private readonly ContentSecurityPolicies _csp;
+
+    readonly static HashSet<string> EventSet = EventNames.Split(',')
+                                                .ToHashSet();
+    public CSPEventTagHelper(ContentSecurityPolicies csp)
+    {
+        _csp = csp;
+    }
+    public override void Process(TagHelperContext context, TagHelperOutput output)
+    {
+        foreach (var attr in output.Attributes)
+        {
+            var n = attr.Name.ToLowerInvariant();
+            if (EventSet.Contains(n))
+            {
+                _csp.AllowUnsafeHashes(attr.Value.ToString());
+            }
+        }
+    }
+}

btcpayserver/BTCPayServer.Abstractions/TagHelpers/CSPInlineScriptTagHelper.cs

@@ -0,0 +1,33 @@
+using BTCPayServer.Security;
+using Microsoft.AspNetCore.Razor.TagHelpers;
+using NBitcoin;
+
+namespace BTCPayServer.Abstractions.TagHelpers;
+
+/// <summary>
+/// Add a nonce-* so the inline-script can pass CSP rule when they are rendered server-side
+/// </summary>
+[HtmlTargetElement("script")]
+public class CSPInlineScriptTagHelper : TagHelper
+{
+    private readonly ContentSecurityPolicies _csp;
+
+    public CSPInlineScriptTagHelper(ContentSecurityPolicies csp)
+    {
+        _csp = csp;
+    }
+
+    public override void Process(TagHelperContext context, TagHelperOutput output)
+    {
+        if (output.Attributes.ContainsName("src"))
+            return;
+        if (output.Attributes.TryGetAttribute("type", out var attr))
+        {
+            if (attr.Value?.ToString() != "text/javascript")
+                return;
+        }
+        var nonce = RandomUtils.GetUInt256().ToString().Substring(0, 32);
+        output.Attributes.Add(new TagHelperAttribute("nonce", nonce));
+        _csp.Add("script-src", $"'nonce-{nonce}'");
+    }
+}

btcpayserver/BTCPayServer.Abstractions/TagHelpers/CSPTemplate.cs

@@ -0,0 +1,25 @@
+using System.Threading.Tasks;
+using BTCPayServer.Security;
+using Microsoft.AspNetCore.Razor.TagHelpers;
+
+namespace BTCPayServer.Abstractions.TagHelpers;
+
+/// <summary>
+/// Add sha256- to allow inline event handlers in CSP
+/// </summary>
+[HtmlTargetElement("template", Attributes = "csp-allow")]
+public class CSPTemplate : TagHelper
+{
+    private readonly ContentSecurityPolicies _csp;
+    public CSPTemplate(ContentSecurityPolicies csp)
+    {
+        _csp = csp;
+    }
+    public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
+    {
+        output.Attributes.RemoveAll("csp-allow");
+        var childContent = await output.GetChildContentAsync();
+        var content = childContent.GetContent();
+        _csp.AllowInline(content);
+    }
+}

btcpayserver/BTCPayServer.Abstractions/TagHelpers/PermissionTagHelper.cs

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

btcpayserver/BTCPayServer.Abstractions/TagHelpers/PermissionedFormTagHelper.cs

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

btcpayserver/BTCPayServer.Abstractions/TagHelpers/SVGUse.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Text.Encodings.Web;
+using Microsoft.AspNetCore.Html;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Razor.TagHelpers;
+using Microsoft.AspNetCore.Mvc.Rendering;
+using Microsoft.AspNetCore.Mvc.Routing;
+using Microsoft.AspNetCore.Mvc.ViewFeatures;
+using Microsoft.AspNetCore.Razor.TagHelpers;
+
+namespace BTCPayServer.Abstractions.TagHelpers;
+
+// Make sure that <svg><use href=/ are correctly working if rootpath is present
+[HtmlTargetElement("use", Attributes = "href")]
+public class SVGUse : UrlResolutionTagHelper2
+{
+    private readonly IFileVersionProvider _fileVersionProvider;
+
+    public SVGUse(IUrlHelperFactory urlHelperFactory, HtmlEncoder htmlEncoder, IFileVersionProvider fileVersionProvider) : base(urlHelperFactory, htmlEncoder)
+    {
+        _fileVersionProvider = fileVersionProvider;
+    }
+
+    public override void Process(TagHelperContext context, TagHelperOutput output)
+    {
+        var attr = output.Attributes["href"].Value.ToString();
+        var symbolIndex = attr!.IndexOf("#", StringComparison.InvariantCulture);
+        var start = attr.IndexOf("~", StringComparison.InvariantCulture) + 1;
+        var length = (symbolIndex != -1 ? symbolIndex : attr.Length) - start;
+        var filePath = attr.Substring(start, length);
+        if (!string.IsNullOrEmpty(filePath))
+        {
+            var versioned = _fileVersionProvider.AddFileVersionToPath(ViewContext.HttpContext.Request.PathBase, filePath);
+            attr = attr.Replace(filePath, versioned);
+        }
+        output.Attributes.SetAttribute("href", attr);
+        base.Process(context, output);
+    }
+}

btcpayserver/BTCPayServer.Abstractions/TagHelpers/SrvModel.cs

@@ -0,0 +1,31 @@
+using BTCPayServer.Abstractions.Services;
+using BTCPayServer.Security;
+using Microsoft.AspNetCore.Razor.TagHelpers;
+using NBitcoin;
+
+namespace BTCPayServer.Abstractions.TagHelpers;
+
+[HtmlTargetElement("srv-model")]
+public class SrvModel : TagHelper
+{
+    private readonly Safe _safe;
+    private readonly ContentSecurityPolicies _csp;
+
+    public SrvModel(Safe safe, ContentSecurityPolicies csp)
+    {
+        _safe = safe;
+        _csp = csp;
+    }
+    public string VarName { get; set; } = "srvModel";
+    public object Model { get; set; }
+    public override void Process(TagHelperContext context, TagHelperOutput output)
+    {
+        output.TagName = "script";
+        output.TagMode = TagMode.StartTagAndEndTag;
+        output.Attributes.Add(new TagHelperAttribute("type", "text/javascript"));
+        var nonce = RandomUtils.GetUInt256().ToString().Substring(0, 32);
+        output.Attributes.Add(new TagHelperAttribute("nonce", nonce));
+        _csp.Add("script-src", $"'nonce-{nonce}'");
+        output.Content.SetHtmlContent($"var {VarName} = {_safe.Json(Model)};");
+    }
+}

btcpayserver/BTCPayServer.Abstractions/TagHelpers/UrlResolutionTagHelper2.cs

@@ -0,0 +1,314 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Text.Encodings.Web;
+using Microsoft.AspNetCore.Html;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Razor.TagHelpers;
+using Microsoft.AspNetCore.Mvc.Rendering;
+using Microsoft.AspNetCore.Mvc.Routing;
+using Microsoft.AspNetCore.Mvc.ViewFeatures;
+using Microsoft.AspNetCore.Razor.TagHelpers;
+
+
+namespace BTCPayServer.Abstractions.TagHelpers
+{
+    // A copy of https://github.com/dotnet/aspnetcore/blob/39f0e0b8f40b4754418f81aef0de58a9204a1fe5/src/Mvc/Mvc.Razor/src/TagHelpers/UrlResolutionTagHelper.cs
+    // slightly modified to also work on use tag.
+    public class UrlResolutionTagHelper2 : TagHelper
+    {
+        // Valid whitespace characters defined by the HTML5 spec.
+        private static readonly char[] ValidAttributeWhitespaceChars =
+            new[] { '\t', '\n', '\u000C', '\r', ' ' };
+        private static readonly Dictionary<string, string[]> ElementAttributeLookups =
+            new(StringComparer.OrdinalIgnoreCase)
+            {
+                { "use", new[] { "href" } },
+                { "a", new[] { "href" } },
+                { "applet", new[] { "archive" } },
+                { "area", new[] { "href" } },
+                { "audio", new[] { "src" } },
+                { "base", new[] { "href" } },
+                { "blockquote", new[] { "cite" } },
+                { "button", new[] { "formaction" } },
+                { "del", new[] { "cite" } },
+                { "embed", new[] { "src" } },
+                { "form", new[] { "action" } },
+                { "html", new[] { "manifest" } },
+                { "iframe", new[] { "src" } },
+                { "img", new[] { "src", "srcset" } },
+                { "input", new[] { "src", "formaction" } },
+                { "ins", new[] { "cite" } },
+                { "link", new[] { "href" } },
+                { "menuitem", new[] { "icon" } },
+                { "object", new[] { "archive", "data" } },
+                { "q", new[] { "cite" } },
+                { "script", new[] { "src" } },
+                { "source", new[] { "src", "srcset" } },
+                { "track", new[] { "src" } },
+                { "video", new[] { "poster", "src" } },
+            };
+
+        /// <summary>
+        /// Creates a new <see cref="UrlResolutionTagHelper"/>.
+        /// </summary>
+        /// <param name="urlHelperFactory">The <see cref="IUrlHelperFactory"/>.</param>
+        /// <param name="htmlEncoder">The <see cref="HtmlEncoder"/>.</param>
+        public UrlResolutionTagHelper2(IUrlHelperFactory urlHelperFactory, HtmlEncoder htmlEncoder)
+        {
+            UrlHelperFactory = urlHelperFactory;
+            HtmlEncoder = htmlEncoder;
+        }
+
+        /// <inheritdoc />
+        public override int Order => -1000 - 999;
+
+        /// <summary>
+        /// The <see cref="IUrlHelperFactory"/>.
+        /// </summary>
+        protected IUrlHelperFactory UrlHelperFactory { get; }
+
+        /// <summary>
+        /// The <see cref="HtmlEncoder"/>.
+        /// </summary>
+        protected HtmlEncoder HtmlEncoder { get; }
+
+        /// <summary>
+        /// The <see cref="ViewContext"/>.
+        /// </summary>
+        [HtmlAttributeNotBound]
+        [ViewContext]
+        public ViewContext ViewContext { get; set; } = default!;
+
+        /// <inheritdoc />
+        public override void Process(TagHelperContext context, TagHelperOutput output)
+        {
+            ArgumentNullException.ThrowIfNull(context);
+            ArgumentNullException.ThrowIfNull(output);
+
+            if (output.TagName == null)
+            {
+                return;
+            }
+
+            if (ElementAttributeLookups.TryGetValue(output.TagName, out var attributeNames))
+            {
+                for (var i = 0; i < attributeNames.Length; i++)
+                {
+                    ProcessUrlAttribute(attributeNames[i], output);
+                }
+            }
+
+            // itemid can be present on any HTML element.
+            ProcessUrlAttribute("itemid", output);
+        }
+
+        /// <summary>
+        /// Resolves and updates URL values starting with '~/' (relative to the application's 'webroot' setting) for
+        /// <paramref name="output"/>'s <see cref="TagHelperOutput.Attributes"/> whose
+        /// <see cref="TagHelperAttribute.Name"/> is <paramref name="attributeName"/>.
+        /// </summary>
+        /// <param name="attributeName">The attribute name used to lookup values to resolve.</param>
+        /// <param name="output">The <see cref="TagHelperOutput"/>.</param>
+        protected void ProcessUrlAttribute(string attributeName, TagHelperOutput output)
+        {
+            ArgumentNullException.ThrowIfNull(attributeName);
+            ArgumentNullException.ThrowIfNull(output);
+
+            var attributes = output.Attributes;
+            // Read interface .Count once rather than per iteration
+            var attributesCount = attributes.Count;
+            for (var i = 0; i < attributesCount; i++)
+            {
+                var attribute = attributes[i];
+                if (!string.Equals(attribute.Name, attributeName, StringComparison.OrdinalIgnoreCase))
+                {
+                    continue;
+                }
+
+                if (attribute.Value is string stringValue)
+                {
+                    if (TryResolveUrl(stringValue, resolvedUrl: out string? resolvedUrl))
+                    {
+                        attributes[i] = new TagHelperAttribute(
+                            attribute.Name,
+                            resolvedUrl,
+                            attribute.ValueStyle);
+                    }
+                }
+                else
+                {
+                    if (attribute.Value is IHtmlContent htmlContent)
+                    {
+                        var htmlString = htmlContent as HtmlString;
+                        if (htmlString != null)
+                        {
+                            // No need for a StringWriter in this case.
+                            stringValue = htmlString.ToString();
+                        }
+                        else
+                        {
+                            using var writer = new StringWriter();
+                            htmlContent.WriteTo(writer, HtmlEncoder);
+                            stringValue = writer.ToString();
+                        }
+
+                        if (TryResolveUrl(stringValue, resolvedUrl: out IHtmlContent? resolvedUrl))
+                        {
+                            attributes[i] = new TagHelperAttribute(
+                                attribute.Name,
+                                resolvedUrl,
+                                attribute.ValueStyle);
+                        }
+                        else if (htmlString == null)
+                        {
+                            // Not a ~/ URL. Just avoid re-encoding the attribute value later.
+                            attributes[i] = new TagHelperAttribute(
+                                attribute.Name,
+                                new HtmlString(stringValue),
+                                attribute.ValueStyle);
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Tries to resolve the given <paramref name="url"/> value relative to the application's 'webroot' setting.
+        /// </summary>
+        /// <param name="url">The URL to resolve.</param>
+        /// <param name="resolvedUrl">Absolute URL beginning with the application's virtual root. <c>null</c> if
+        /// <paramref name="url"/> could not be resolved.</param>
+        /// <returns><c>true</c> if the <paramref name="url"/> could be resolved; <c>false</c> otherwise.</returns>
+        protected bool TryResolveUrl(string url, out string? resolvedUrl)
+        {
+            resolvedUrl = null;
+            var start = FindRelativeStart(url);
+            if (start == -1)
+            {
+                return false;
+            }
+
+            var trimmedUrl = CreateTrimmedString(url, start);
+
+            var urlHelper = UrlHelperFactory.GetUrlHelper(ViewContext);
+            resolvedUrl = urlHelper.Content(trimmedUrl);
+
+            return true;
+        }
+
+        /// <summary>
+        /// Tries to resolve the given <paramref name="url"/> value relative to the application's 'webroot' setting.
+        /// </summary>
+        /// <param name="url">The URL to resolve.</param>
+        /// <param name="resolvedUrl">
+        /// Absolute URL beginning with the application's virtual root. <c>null</c> if <paramref name="url"/> could
+        /// not be resolved.
+        /// </param>
+        /// <returns><c>true</c> if the <paramref name="url"/> could be resolved; <c>false</c> otherwise.</returns>
+        protected bool TryResolveUrl(string url, [NotNullWhen(true)] out IHtmlContent? resolvedUrl)
+        {
+            resolvedUrl = null;
+            var start = FindRelativeStart(url);
+            if (start == -1)
+            {
+                return false;
+            }
+
+            var trimmedUrl = CreateTrimmedString(url, start);
+
+            var urlHelper = UrlHelperFactory.GetUrlHelper(ViewContext);
+            var appRelativeUrl = urlHelper.Content(trimmedUrl);
+            var postTildeSlashUrlValue = trimmedUrl.Substring(2);
+
+            if (!appRelativeUrl.EndsWith(postTildeSlashUrlValue, StringComparison.Ordinal))
+            {
+                throw new InvalidOperationException();
+            }
+
+            resolvedUrl = new EncodeFirstSegmentContent(
+                appRelativeUrl,
+                appRelativeUrl.Length - postTildeSlashUrlValue.Length,
+                postTildeSlashUrlValue);
+
+            return true;
+        }
+
+        private static int FindRelativeStart(string url)
+        {
+            if (url == null || url.Length < 2)
+            {
+                return -1;
+            }
+
+            var maxTestLength = url.Length - 2;
+
+            var start = 0;
+            for (; start < url.Length; start++)
+            {
+                if (start > maxTestLength)
+                {
+                    return -1;
+                }
+
+                if (!IsCharWhitespace(url[start]))
+                {
+                    break;
+                }
+            }
+
+            // Before doing more work, ensure that the URL we're looking at is app-relative.
+            if (url[start] != '~' || url[start + 1] != '/')
+            {
+                return -1;
+            }
+
+            return start;
+        }
+
+        private static string CreateTrimmedString(string input, int start)
+        {
+            var end = input.Length - 1;
+            for (; end >= start; end--)
+            {
+                if (!IsCharWhitespace(input[end]))
+                {
+                    break;
+                }
+            }
+
+            var len = end - start + 1;
+
+            // Substring returns same string if start == 0 && len == Length
+            return input.Substring(start, len);
+        }
+
+        private static bool IsCharWhitespace(char ch)
+        {
+            return ValidAttributeWhitespaceChars.AsSpan().IndexOf(ch) != -1;
+        }
+
+        private sealed class EncodeFirstSegmentContent : IHtmlContent
+        {
+            private readonly string _firstSegment;
+            private readonly int _firstSegmentLength;
+            private readonly string _secondSegment;
+
+            public EncodeFirstSegmentContent(string firstSegment, int firstSegmentLength, string secondSegment)
+            {
+                _firstSegment = firstSegment;
+                _firstSegmentLength = firstSegmentLength;
+                _secondSegment = secondSegment;
+            }
+
+            public void WriteTo(TextWriter writer, HtmlEncoder encoder)
+            {
+                encoder.Encode(writer, _firstSegment, 0, _firstSegmentLength);
+                writer.Write(_secondSegment);
+            }
+        }
+    }
+
+}

btcpayserver/BTCPayServer.Client/BTCPayServer.Client.csproj

@@ -0,0 +1,40 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>netstandard2.1</TargetFramework>
+        <LangVersion>10.0</LangVersion>
+        <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>
+        <Configurations>Debug;Release</Configurations>
+        <Platforms>AnyCPU</Platforms>
+    </PropertyGroup>
+  <PropertyGroup>
+    <Version Condition=" '$(Version)' == '' ">2.0.1</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="BTCPayServer.Lightning.Common" Version="1.5.2" />
+      <PackageReference Include="NBitcoin" Version="8.0.13" />
+      <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+    </ItemGroup>
+  <ItemGroup>
+    <None Include="icon.png" Pack="true" PackagePath="\" />
+  </ItemGroup>
+</Project>

btcpayserver/BTCPayServer.Client/BTCPayServerClient.APIKeys.cs

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

btcpayserver/BTCPayServer.Client/BTCPayServerClient.Apps.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 virtual async Task<PointOfSaleAppData> CreatePointOfSaleApp(string storeId,
+        PointOfSaleAppRequest request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<PointOfSaleAppData>($"api/v1/stores/{storeId}/apps/pos", request, HttpMethod.Post, token);
+    }
+
+    public virtual async Task<CrowdfundAppData> CreateCrowdfundApp(string storeId,
+        CrowdfundAppRequest request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<CrowdfundAppData>($"api/v1/stores/{storeId}/apps/crowdfund", request, HttpMethod.Post, token);
+    }
+
+    public virtual async Task<PointOfSaleAppData> UpdatePointOfSaleApp(string appId,
+        PointOfSaleAppRequest request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<PointOfSaleAppData>($"api/v1/apps/pos/{appId}", request, HttpMethod.Put, token);
+    }
+
+    public virtual async Task<AppBaseData> GetApp(string appId, CancellationToken token = default)
+    {
+        if (appId == null) throw new ArgumentNullException(nameof(appId));
+        return await SendHttpRequest<AppBaseData>($"api/v1/apps/{appId}", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<AppBaseData[]> GetAllApps(string storeId, CancellationToken token = default)
+    {
+        if (storeId == null) throw new ArgumentNullException(nameof(storeId));
+        return await SendHttpRequest<AppBaseData[]>($"api/v1/stores/{storeId}/apps", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<AppBaseData[]> GetAllApps(CancellationToken token = default)
+    {
+        return await SendHttpRequest<AppBaseData[]>("api/v1/apps", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<PointOfSaleAppData> GetPosApp(string appId, CancellationToken token = default)
+    {
+        if (appId == null) throw new ArgumentNullException(nameof(appId));
+        return await SendHttpRequest<PointOfSaleAppData>($"api/v1/apps/pos/{appId}", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<CrowdfundAppData> GetCrowdfundApp(string appId, CancellationToken token = default)
+    {
+        if (appId == null) throw new ArgumentNullException(nameof(appId));
+        return await SendHttpRequest<CrowdfundAppData>($"api/v1/apps/crowdfund/{appId}", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<AppSalesStats> GetAppSales(string appId, int numberOfDays = 7, CancellationToken token = default)
+    {
+        if (appId == null) throw new ArgumentNullException(nameof(appId));
+        var queryPayload = new Dictionary<string, object> { { nameof(numberOfDays), numberOfDays } };
+        return await SendHttpRequest<AppSalesStats>($"api/v1/apps/{appId}/sales", queryPayload, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<List<AppItemStats>> GetAppTopItems(string appId, int offset = 0, int count = 10, CancellationToken token = default)
+    {
+        if (appId == null) throw new ArgumentNullException(nameof(appId));
+        var queryPayload = new Dictionary<string, object> { { nameof(offset), offset }, { nameof(count), count } };
+        return await SendHttpRequest<List<AppItemStats>>($"api/v1/apps/{appId}/top-items", queryPayload, HttpMethod.Get, token);
+    }
+
+    public virtual async Task DeleteApp(string appId, CancellationToken token = default)
+    {
+        if (appId == null) throw new ArgumentNullException(nameof(appId));
+        await SendHttpRequest($"api/v1/apps/{appId}", null, HttpMethod.Delete, token);
+    }
+
+    public virtual async Task<FileData> UploadAppItemImage(string appId, string filePath, string mimeType, CancellationToken token = default)
+    {
+        return await UploadFileRequest<FileData>($"api/v1/apps/{appId}/image", filePath, mimeType, "file", HttpMethod.Post, token);
+    }
+
+    public virtual async Task DeleteAppItemImage(string appId, string fileId, CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/apps/{appId}/image/{fileId}", null, HttpMethod.Delete, token);
+    }
+}

btcpayserver/BTCPayServer.Client/BTCPayServerClient.Authorization.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+
+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) { 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/BTCPayServer.Client/BTCPayServerClient.Files.cs

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

btcpayserver/BTCPayServer.Client/BTCPayServerClient.Health.cs

@@ -0,0 +1,14 @@
+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<ApiHealthData> GetHealth(CancellationToken token = default)
+    {
+        return await SendHttpRequest<ApiHealthData>("api/v1/health", null, HttpMethod.Get, token);
+    }
+}

btcpayserver/BTCPayServer.Client/BTCPayServerClient.Invoices.cs

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

btcpayserver/BTCPayServer.Client/BTCPayServerClient.Lightning.Internal.cs

@@ -0,0 +1,112 @@
+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<LightningNodeInformationData> GetLightningNodeInfo(string cryptoCode,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<LightningNodeInformationData>($"api/v1/server/lightning/{cryptoCode}/info", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<LightningNodeBalanceData> GetLightningNodeBalance(string cryptoCode,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<LightningNodeBalanceData>($"api/v1/server/lightning/{cryptoCode}/balance", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<HistogramData> GetLightningNodeHistogram(string cryptoCode, HistogramType? type = null,
+        CancellationToken token = default)
+    {
+        var queryPayload = type == null ? null : new Dictionary<string, object> { { "type", type.ToString() } };
+        return await SendHttpRequest<HistogramData>($"api/v1/server/lightning/{cryptoCode}/histogram", queryPayload, HttpMethod.Get, token);
+    }
+
+    public virtual async Task ConnectToLightningNode(string cryptoCode, ConnectToNodeRequest request,
+        CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        await SendHttpRequest($"api/v1/server/lightning/{cryptoCode}/connect", request, HttpMethod.Post, token);
+    }
+
+    public virtual async Task<IEnumerable<LightningChannelData>> GetLightningNodeChannels(string cryptoCode,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<IEnumerable<LightningChannelData>>($"api/v1/server/lightning/{cryptoCode}/channels", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task OpenLightningChannel(string cryptoCode, OpenLightningChannelRequest request,
+        CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/server/lightning/{cryptoCode}/channels", request, HttpMethod.Post, token);
+    }
+
+    public virtual async Task<string> GetLightningDepositAddress(string cryptoCode, CancellationToken token = default)
+    {
+        return await SendHttpRequest<string>($"api/v1/server/lightning/{cryptoCode}/address", null, HttpMethod.Post, token);
+    }
+
+    public virtual async Task<LightningPaymentData> PayLightningInvoice(string cryptoCode, PayLightningInvoiceRequest request,
+        CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<LightningPaymentData>($"api/v1/server/lightning/{cryptoCode}/invoices/pay", request, HttpMethod.Post, token);
+    }
+
+    public virtual async Task<LightningPaymentData> GetLightningPayment(string cryptoCode,
+        string paymentHash, CancellationToken token = default)
+    {
+        if (paymentHash == null) throw new ArgumentNullException(nameof(paymentHash));
+        return await SendHttpRequest<LightningPaymentData>($"api/v1/server/lightning/{cryptoCode}/payments/{paymentHash}", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<LightningInvoiceData> GetLightningInvoice(string cryptoCode,
+        string invoiceId, CancellationToken token = default)
+    {
+        if (invoiceId == null) throw new ArgumentNullException(nameof(invoiceId));
+        return await SendHttpRequest<LightningInvoiceData>($"api/v1/server/lightning/{cryptoCode}/invoices/{invoiceId}", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<LightningInvoiceData[]> GetLightningInvoices(string cryptoCode,
+        bool? pendingOnly = null, long? offsetIndex = null, CancellationToken token = default)
+    {
+        var queryPayload = new Dictionary<string, object>();
+        if (pendingOnly is bool v)
+        {
+            queryPayload.Add("pendingOnly", v.ToString());
+        }
+        if (offsetIndex is > 0)
+        {
+            queryPayload.Add("offsetIndex", offsetIndex);
+        }
+        return await SendHttpRequest<LightningInvoiceData[]>($"api/v1/server/lightning/{cryptoCode}/invoices", queryPayload, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<LightningPaymentData[]> GetLightningPayments(string cryptoCode,
+        bool? includePending = null, long? offsetIndex = null, CancellationToken token = default)
+    {
+        var queryPayload = new Dictionary<string, object>();
+        if (includePending is bool v)
+        {
+            queryPayload.Add("includePending", v.ToString());
+        }
+        if (offsetIndex is > 0)
+        {
+            queryPayload.Add("offsetIndex", offsetIndex);
+        }
+        return await SendHttpRequest<LightningPaymentData[]>($"api/v1/server/lightning/{cryptoCode}/payments", queryPayload, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<LightningInvoiceData> CreateLightningInvoice(string cryptoCode, CreateLightningInvoiceRequest request,
+        CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<LightningInvoiceData>($"api/v1/server/lightning/{cryptoCode}/invoices", request, HttpMethod.Post, token);
+    }
+}

btcpayserver/BTCPayServer.Client/BTCPayServerClient.Lightning.Store.cs

@@ -0,0 +1,113 @@
+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<LightningNodeInformationData> GetLightningNodeInfo(string storeId, string cryptoCode,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<LightningNodeInformationData>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/info", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<LightningNodeBalanceData> GetLightningNodeBalance(string storeId, string cryptoCode,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<LightningNodeBalanceData>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/balance", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<HistogramData> GetLightningNodeHistogram(string storeId, string cryptoCode, HistogramType? type = null,
+        CancellationToken token = default)
+    {
+        var queryPayload = type == null ? null : new Dictionary<string, object> { { "type", type.ToString() } };
+        return await SendHttpRequest<HistogramData>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/histogram", queryPayload, HttpMethod.Get, token);
+    }
+
+    public virtual async Task ConnectToLightningNode(string storeId, string cryptoCode, ConnectToNodeRequest request,
+        CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        await SendHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/connect", request, HttpMethod.Post, token);
+    }
+
+    public virtual async Task<IEnumerable<LightningChannelData>> GetLightningNodeChannels(string storeId, string cryptoCode,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<IEnumerable<LightningChannelData>>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/channels", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task OpenLightningChannel(string storeId, string cryptoCode, OpenLightningChannelRequest request,
+        CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{storeId}/lightning/{cryptoCode}/channels", request, HttpMethod.Post, token);
+    }
+
+    public virtual async Task<string> GetLightningDepositAddress(string storeId, string cryptoCode,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<string>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/address", null, HttpMethod.Post, token);
+    }
+
+    public virtual async Task<LightningPaymentData> PayLightningInvoice(string storeId, string cryptoCode, PayLightningInvoiceRequest request,
+        CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<LightningPaymentData>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/invoices/pay", request, HttpMethod.Post, token);
+    }
+
+    public virtual async Task<LightningPaymentData> GetLightningPayment(string storeId, string cryptoCode,
+        string paymentHash, CancellationToken token = default)
+    {
+        if (paymentHash == null) throw new ArgumentNullException(nameof(paymentHash));
+        return await SendHttpRequest<LightningPaymentData>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/payments/{paymentHash}", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<LightningInvoiceData> GetLightningInvoice(string storeId, string cryptoCode,
+        string invoiceId, CancellationToken token = default)
+    {
+        if (invoiceId == null) throw new ArgumentNullException(nameof(invoiceId));
+        return await SendHttpRequest<LightningInvoiceData>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/invoices/{invoiceId}", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<LightningInvoiceData[]> GetLightningInvoices(string storeId, string cryptoCode,
+        bool? pendingOnly = null, long? offsetIndex = null, CancellationToken token = default)
+    {
+        var queryPayload = new Dictionary<string, object>();
+        if (pendingOnly is bool v)
+        {
+            queryPayload.Add("pendingOnly", v.ToString());
+        }
+        if (offsetIndex is > 0)
+        {
+            queryPayload.Add("offsetIndex", offsetIndex);
+        }
+        return await SendHttpRequest<LightningInvoiceData[]>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/invoices", queryPayload, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<LightningPaymentData[]> GetLightningPayments(string storeId, string cryptoCode,
+        bool? includePending = null, long? offsetIndex = null, CancellationToken token = default)
+    {
+        var queryPayload = new Dictionary<string, object>();
+        if (includePending is bool v)
+        {
+            queryPayload.Add("includePending", v.ToString());
+        }
+        if (offsetIndex is > 0)
+        {
+            queryPayload.Add("offsetIndex", offsetIndex);
+        }
+        return await SendHttpRequest<LightningPaymentData[]>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/payments", queryPayload, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<LightningInvoiceData> CreateLightningInvoice(string storeId, string cryptoCode,
+        CreateLightningInvoiceRequest request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<LightningInvoiceData>($"api/v1/stores/{storeId}/lightning/{cryptoCode}/invoices", request, HttpMethod.Post, token);
+    }
+}

btcpayserver/BTCPayServer.Client/BTCPayServerClient.LightningAddresses.cs

@@ -0,0 +1,34 @@
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Client.Models;
+
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
+{
+    public virtual async Task<LightningAddressData[]> GetStoreLightningAddresses(string storeId,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<LightningAddressData[]>($"api/v1/stores/{storeId}/lightning-addresses", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<LightningAddressData> GetStoreLightningAddress(string storeId, string username,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<LightningAddressData>($"api/v1/stores/{storeId}/lightning-addresses/{username}", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task RemoveStoreLightningAddress(string storeId, string username,
+        CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{storeId}/lightning-addresses/{username}", null, HttpMethod.Delete, token);
+    }
+
+    public virtual async Task<LightningAddressData> AddOrUpdateStoreLightningAddress(string storeId,
+        string username, LightningAddressData data,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<LightningAddressData>($"api/v1/stores/{storeId}/lightning-addresses/{username}", data, HttpMethod.Post, token);
+    }
+}

btcpayserver/BTCPayServer.Client/BTCPayServerClient.Misc.cs

@@ -0,0 +1,19 @@
+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<PermissionMetadata[]> GetPermissionMetadata(CancellationToken token = default)
+    {
+        return await SendHttpRequest<PermissionMetadata[]>("misc/permissions", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<Language[]> GetAvailableLanguages(CancellationToken token = default)
+    {
+        return await SendHttpRequest<Language[]>("misc/lang", null, HttpMethod.Get, token);
+    }
+}

btcpayserver/BTCPayServer.Client/BTCPayServerClient.Notifications.cs

@@ -0,0 +1,52 @@
+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, int? skip = null,
+        int? take = null, string[] storeId = null, CancellationToken token = default)
+    {
+        var queryPayload = new Dictionary<string, object>();
+        if (seen != null)
+            queryPayload.Add(nameof(seen), seen);
+        if (skip != null)
+            queryPayload.Add(nameof(skip), skip);
+        if (take != null)
+            queryPayload.Add(nameof(take), take);
+        if (storeId != null)
+            queryPayload.Add(nameof(storeId), storeId);
+        return await SendHttpRequest<IEnumerable<NotificationData>>("api/v1/users/me/notifications", queryPayload, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<NotificationData> GetNotification(string notificationId,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<NotificationData>($"api/v1/users/me/notifications/{notificationId}", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<NotificationData> UpdateNotification(string notificationId, bool? seen,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<NotificationData>($"api/v1/users/me/notifications/{notificationId}", new UpdateNotification { Seen = seen }, HttpMethod.Put, token);
+    }
+
+    public virtual async Task<NotificationSettingsData> GetNotificationSettings(CancellationToken token = default)
+    {
+        return await SendHttpRequest<NotificationSettingsData>("api/v1/users/me/notification-settings", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<NotificationSettingsData> UpdateNotificationSettings(UpdateNotificationSettingsRequest request, CancellationToken token = default)
+    {
+        return await SendHttpRequest<NotificationSettingsData>("api/v1/users/me/notification-settings", request, HttpMethod.Put, token);
+    }
+
+    public virtual async Task RemoveNotification(string notificationId, CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/users/me/notifications/{notificationId}", null, HttpMethod.Delete, token);
+    }
+}

btcpayserver/BTCPayServer.Client/BTCPayServerClient.OnChainPaymentMethods.cs

@@ -0,0 +1,39 @@
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Client.Models;
+using Newtonsoft.Json.Linq;
+
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
+{
+    public virtual async Task<OnChainPaymentMethodPreviewResultData>
+        PreviewProposedStoreOnChainPaymentMethodAddresses(
+            string storeId, string paymentMethodId, string derivationScheme, int offset = 0,
+            int amount = 10,
+            CancellationToken token = default)
+    {
+        return await SendHttpRequest<UpdatePaymentMethodRequest, OnChainPaymentMethodPreviewResultData>($"api/v1/stores/{storeId}/payment-methods/{paymentMethodId}/wallet/preview",
+            new Dictionary<string, object> { { "offset", offset }, { "amount", amount } },
+            new UpdatePaymentMethodRequest { Config = JValue.CreateString(derivationScheme) },
+            HttpMethod.Post, token);
+    }
+
+    public virtual async Task<OnChainPaymentMethodPreviewResultData> PreviewStoreOnChainPaymentMethodAddresses(
+        string storeId, string paymentMethodId, int offset = 0, int amount = 10,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<OnChainPaymentMethodPreviewResultData>($"api/v1/stores/{storeId}/payment-methods/{paymentMethodId}/wallet/preview",
+            new Dictionary<string, object> { { "offset", offset }, { "amount", amount } }, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<GenerateOnChainWalletResponse> GenerateOnChainWallet(string storeId,
+        string paymentMethodId, GenerateOnChainWalletRequest request,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<GenerateOnChainWalletResponse>($"api/v1/stores/{storeId}/payment-methods/{paymentMethodId}/wallet/generate", request, HttpMethod.Post, token);
+    }
+
+}

btcpayserver/BTCPayServer.Client/BTCPayServerClient.OnChainWallet.Objects.cs

@@ -0,0 +1,62 @@
+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<OnChainWalletObjectData> GetOnChainWalletObject(string storeId, string cryptoCode, OnChainWalletObjectId objectId, bool? includeNeighbourData = null, CancellationToken token = default)
+    {
+        var parameters = new Dictionary<string, object>();
+        if (includeNeighbourData is bool v)
+            parameters.Add("includeNeighbourData", v);
+        try
+        {
+            return await SendHttpRequest<OnChainWalletObjectData>($"api/v1/stores/{storeId}/payment-methods/{cryptoCode}-CHAIN/wallet/objects/{objectId.Type}/{objectId.Id}", parameters, HttpMethod.Get, token);
+        }
+        catch (GreenfieldAPIException err) when (err.APIError.Code == "wallet-object-not-found")
+        {
+            return null;
+        }
+    }
+    public virtual async Task<OnChainWalletObjectData[]> GetOnChainWalletObjects(string storeId, string cryptoCode, GetWalletObjectsRequest query = null, CancellationToken token = default)
+    {
+        Dictionary<string, object> parameters = new Dictionary<string, object>();
+        if (query?.Type is string s)
+            parameters.Add("type", s);
+        if (query?.Ids is string[] ids)
+            parameters.Add("ids", ids);
+        if (query?.IncludeNeighbourData is bool v)
+            parameters.Add("includeNeighbourData", v);
+        return await SendHttpRequest<OnChainWalletObjectData[]>($"api/v1/stores/{storeId}/payment-methods/{cryptoCode}-CHAIN/wallet/objects", parameters, HttpMethod.Get, token);
+    }
+    public virtual async Task RemoveOnChainWalletObject(string storeId, string cryptoCode, OnChainWalletObjectId objectId,
+        CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{storeId}/payment-methods/{cryptoCode}-CHAIN/wallet/objects/{objectId.Type}/{objectId.Id}", null, HttpMethod.Delete, token);
+    }
+    public virtual async Task<OnChainWalletObjectData> AddOrUpdateOnChainWalletObject(string storeId, string cryptoCode, AddOnChainWalletObjectRequest request,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<OnChainWalletObjectData>($"api/v1/stores/{storeId}/payment-methods/{cryptoCode}-CHAIN/wallet/objects", request, HttpMethod.Post, token);
+    }
+
+    public virtual async Task AddOrUpdateOnChainWalletLink(string storeId, string cryptoCode,
+        OnChainWalletObjectId objectId,
+        AddOnChainWalletObjectLinkRequest request = null,
+        CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{storeId}/payment-methods/{cryptoCode}-CHAIN/wallet/objects/{objectId.Type}/{objectId.Id}/links", request, HttpMethod.Post, token);
+    }
+
+    public virtual async Task RemoveOnChainWalletLinks(string storeId, string cryptoCode,
+        OnChainWalletObjectId objectId,
+        OnChainWalletObjectId link,
+        CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{storeId}/payment-methods/{cryptoCode}-CHAIN/wallet/objects/{objectId.Type}/{objectId.Id}/links/{link.Type}/{link.Id}", null, HttpMethod.Delete, token);
+    }
+}

btcpayserver/BTCPayServer.Client/BTCPayServerClient.OnChainWallet.cs

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

btcpayserver/BTCPayServer.Client/BTCPayServerClient.PaymentRequests.cs

@@ -0,0 +1,53 @@
+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<PaymentRequestBaseData>> GetPaymentRequests(string storeId,
+        bool includeArchived = false,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<IEnumerable<PaymentRequestBaseData>>($"api/v1/stores/{storeId}/payment-requests",
+            new Dictionary<string, object> { { nameof(includeArchived), includeArchived } }, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<PaymentRequestBaseData> GetPaymentRequest(string storeId, string paymentRequestId,
+        CancellationToken token = default)
+    {
+        return await SendHttpRequest<PaymentRequestBaseData>($"api/v1/stores/{storeId}/payment-requests/{paymentRequestId}", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task ArchivePaymentRequest(string storeId, string paymentRequestId,
+        CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{storeId}/payment-requests/{paymentRequestId}", null, HttpMethod.Delete, token);
+    }
+
+    public virtual async Task<Client.Models.InvoiceData> PayPaymentRequest(string storeId, string paymentRequestId, PayPaymentRequestRequest request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        if (storeId is null) throw new ArgumentNullException(nameof(storeId));
+        if (paymentRequestId is null) throw new ArgumentNullException(nameof(paymentRequestId));
+        return await SendHttpRequest<InvoiceData>($"api/v1/stores/{storeId}/payment-requests/{paymentRequestId}/pay", request, HttpMethod.Post, token);
+    }
+
+    public virtual async Task<PaymentRequestBaseData> CreatePaymentRequest(string storeId,
+        PaymentRequestBaseData request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<PaymentRequestBaseData>($"api/v1/stores/{storeId}/payment-requests", request, HttpMethod.Post, token);
+    }
+
+    public virtual async Task<PaymentRequestBaseData> UpdatePaymentRequest(string storeId, string paymentRequestId,
+        PaymentRequestBaseData request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<PaymentRequestBaseData>($"api/v1/stores/{storeId}/payment-requests/{paymentRequestId}", request, HttpMethod.Put, token);
+    }
+}

btcpayserver/BTCPayServer.Client/BTCPayServerClient.PayoutProcessors.cs

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

btcpayserver/BTCPayServer.Client/BTCPayServerClient.PullPayments.cs

@@ -0,0 +1,94 @@
+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 virtual async Task<PullPaymentData> CreatePullPayment(string storeId, CreatePullPaymentRequest request, CancellationToken cancellationToken = default)
+    {
+        return await SendHttpRequest<PullPaymentData>($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/pull-payments", request, HttpMethod.Post, cancellationToken);
+    }
+
+    public virtual async Task<PullPaymentData> GetPullPayment(string pullPaymentId, CancellationToken cancellationToken = default)
+    {
+        return await SendHttpRequest<PullPaymentData>($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}", null, HttpMethod.Get, cancellationToken);
+    }
+
+    public virtual async Task<RegisterBoltcardResponse> RegisterBoltcard(string pullPaymentId, RegisterBoltcardRequest request, CancellationToken cancellationToken = default)
+    {
+        return await SendHttpRequest<RegisterBoltcardResponse>($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}/boltcards", request, HttpMethod.Post, cancellationToken);
+    }
+
+    public virtual async Task<PullPaymentData[]> GetPullPayments(string storeId, bool includeArchived = false, CancellationToken cancellationToken = default)
+    {
+        var query = new Dictionary<string, object> { { "includeArchived", includeArchived } };
+        return await SendHttpRequest<PullPaymentData[]>($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/pull-payments", query, HttpMethod.Get, cancellationToken);
+    }
+
+    public virtual async Task ArchivePullPayment(string storeId, string pullPaymentId, CancellationToken cancellationToken = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}", null, HttpMethod.Delete, cancellationToken);
+    }
+
+    public virtual async Task<PayoutData[]> GetPayouts(string pullPaymentId, bool includeCancelled = false, CancellationToken cancellationToken = default)
+    {
+        var query = new Dictionary<string, object> { { "includeCancelled", includeCancelled } };
+        return await SendHttpRequest<PayoutData[]>($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}/payouts", query, HttpMethod.Get, cancellationToken);
+    }
+
+    public virtual async Task<PayoutData[]> GetStorePayouts(string storeId, bool includeCancelled = false, CancellationToken cancellationToken = default)
+    {
+        var query = new Dictionary<string, object> { { "includeCancelled", includeCancelled } };
+        return await SendHttpRequest<PayoutData[]>($"api/v1/stores/{storeId}/payouts", queryPayload: query, method: HttpMethod.Get, cancellationToken);
+    }
+
+    public virtual async Task<PayoutData> CreatePayout(string pullPaymentId, CreatePayoutRequest payoutRequest, CancellationToken cancellationToken = default)
+    {
+        return await SendHttpRequest<PayoutData>($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}/payouts", bodyPayload: payoutRequest, HttpMethod.Post, cancellationToken);
+    }
+
+    public virtual async Task<PayoutData> GetPullPaymentPayout(string pullPaymentId, string payoutId, CancellationToken cancellationToken = default)
+    {
+        return await SendHttpRequest<PayoutData>($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}/payouts/{payoutId}", null, HttpMethod.Get, cancellationToken);
+    }
+
+    public virtual async Task<PayoutData> GetStorePayout(string storeId, string payoutId, CancellationToken cancellationToken = default)
+    {
+        return await SendHttpRequest<PayoutData>($"api/v1/stores/{storeId}/payouts/{payoutId}", null, HttpMethod.Get, cancellationToken);
+    }
+
+    public virtual async Task<PayoutData> CreatePayout(string storeId, CreatePayoutThroughStoreRequest payoutRequest, CancellationToken cancellationToken = default)
+    {
+        return await SendHttpRequest<PayoutData>($"api/v1/stores/{storeId}/payouts", bodyPayload: payoutRequest, method: HttpMethod.Post, cancellationToken);
+    }
+
+    public virtual async Task CancelPayout(string storeId, string payoutId, CancellationToken cancellationToken = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/payouts/{HttpUtility.UrlEncode(payoutId)}", null, HttpMethod.Delete, cancellationToken);
+    }
+
+    public virtual async Task<PayoutData> ApprovePayout(string storeId, string payoutId, ApprovePayoutRequest request, CancellationToken cancellationToken = default)
+    {
+        return await SendHttpRequest<PayoutData>($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/payouts/{HttpUtility.UrlEncode(payoutId)}", request, HttpMethod.Post, cancellationToken);
+    }
+
+    public virtual async Task MarkPayoutPaid(string storeId, string payoutId, CancellationToken cancellationToken = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/payouts/{HttpUtility.UrlEncode(payoutId)}/mark-paid", null, HttpMethod.Post, cancellationToken);
+    }
+
+    public virtual async Task MarkPayout(string storeId, string payoutId, MarkPayoutRequest request, CancellationToken cancellationToken = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{HttpUtility.UrlEncode(storeId)}/payouts/{HttpUtility.UrlEncode(payoutId)}/mark", request, HttpMethod.Post, cancellationToken);
+    }
+
+    public virtual async Task<PullPaymentLNURL> GetPullPaymentLNURL(string pullPaymentId, CancellationToken cancellationToken = default)
+    {
+        return await SendHttpRequest<PullPaymentLNURL>($"api/v1/pull-payments/{HttpUtility.UrlEncode(pullPaymentId)}/lnurl", null, HttpMethod.Get, cancellationToken);
+    }
+}

btcpayserver/BTCPayServer.Client/BTCPayServerClient.ServerEmail.cs

@@ -0,0 +1,20 @@
+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<ServerEmailSettingsData> GetServerEmailSettings(CancellationToken token = default)
+    {
+        return await SendHttpRequest<ServerEmailSettingsData>("api/v1/server/email", null, HttpMethod.Get, token);
+    }
+    
+    public virtual async Task<ServerEmailSettingsData> UpdateServerEmailSettings(ServerEmailSettingsData request, CancellationToken token = default)
+    {
+        return await SendHttpRequest<ServerEmailSettingsData>("api/v1/server/email", request, HttpMethod.Put, token);
+    }
+}

btcpayserver/BTCPayServer.Client/BTCPayServerClient.ServerInfo.cs

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

btcpayserver/BTCPayServer.Client/BTCPayServerClient.StoreEmail.cs

@@ -0,0 +1,24 @@
+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<EmailSettingsData> GetStoreEmailSettings(string storeId, CancellationToken token = default)
+    {
+        return await SendHttpRequest<EmailSettingsData>($"api/v1/stores/{storeId}/email", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<EmailSettingsData> UpdateStoreEmailSettings(string storeId, EmailSettingsData request, CancellationToken token = default)
+    {
+        return await SendHttpRequest<EmailSettingsData>($"api/v1/stores/{storeId}/email", request, method: HttpMethod.Put, token);
+    }
+
+    public virtual async Task SendEmail(string storeId, SendEmailRequest request, CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{storeId}/email/send", request, HttpMethod.Post, token);
+    }
+}

btcpayserver/BTCPayServer.Client/BTCPayServerClient.StorePaymentMethods.cs

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

btcpayserver/BTCPayServer.Client/BTCPayServerClient.StorePayoutProcessors.cs

@@ -0,0 +1,41 @@
+#nullable enable
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using BTCPayServer.Client.Models;
+
+namespace BTCPayServer.Client;
+
+public partial class BTCPayServerClient
+{
+    public virtual async Task<IEnumerable<PayoutProcessorData>> GetPayoutProcessors(string storeId, CancellationToken token = default)
+    {
+        return await SendHttpRequest<IEnumerable<PayoutProcessorData>>($"api/v1/stores/{storeId}/payout-processors", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task RemovePayoutProcessor(string storeId, string processor, string paymentMethod, CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{storeId}/payout-processors/{processor}/{paymentMethod}", null, HttpMethod.Delete, token);
+    }
+
+    public virtual async Task<IEnumerable<LightningAutomatedPayoutSettings>> GetStoreLightningAutomatedPayoutProcessors(string storeId, string? payoutMethodId = null, CancellationToken token = default)
+    {
+        return await SendHttpRequest<IEnumerable<LightningAutomatedPayoutSettings>>($"api/v1/stores/{storeId}/payout-processors/LightningAutomatedPayoutSenderFactory{(payoutMethodId is null ? string.Empty : $"/{payoutMethodId}")}", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<LightningAutomatedPayoutSettings> UpdateStoreLightningAutomatedPayoutProcessors(string storeId, string payoutMethodId, LightningAutomatedPayoutSettings request, CancellationToken token = default)
+    {
+        return await SendHttpRequest<LightningAutomatedPayoutSettings>($"api/v1/stores/{storeId}/payout-processors/LightningAutomatedPayoutSenderFactory/{payoutMethodId}", request, HttpMethod.Put, token);
+    }
+
+    public virtual async Task<OnChainAutomatedPayoutSettings> UpdateStoreOnChainAutomatedPayoutProcessors(string storeId, string paymentMethod, OnChainAutomatedPayoutSettings request, CancellationToken token = default)
+    {
+        return await SendHttpRequest<OnChainAutomatedPayoutSettings>($"api/v1/stores/{storeId}/payout-processors/OnChainAutomatedPayoutSenderFactory/{paymentMethod}", request, HttpMethod.Put, token);
+    }
+
+    public virtual async Task<IEnumerable<OnChainAutomatedPayoutSettings>> GetStoreOnChainAutomatedPayoutProcessors(string storeId, string? paymentMethod = null, CancellationToken token = default)
+    {
+        return await SendHttpRequest<IEnumerable<OnChainAutomatedPayoutSettings>>($"api/v1/stores/{storeId}/payout-processors/OnChainAutomatedPayoutSenderFactory{(paymentMethod is null ? string.Empty : $"/{paymentMethod}")}", null, HttpMethod.Get, token);
+    }
+}

btcpayserver/BTCPayServer.Client/BTCPayServerClient.StoreRatesConfiguration.cs

@@ -0,0 +1,47 @@
+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<StoreRateConfiguration> GetStoreRateConfiguration(string storeId, bool? fallback = null, CancellationToken token = default)
+    {
+        var path = GetRateConfigPath(storeId, fallback);
+        return await SendHttpRequest<StoreRateConfiguration>(path, null, HttpMethod.Get, token);
+    }
+
+    private string GetRateConfigPath(string storeId, bool? fallback)
+    => fallback switch
+    {
+        null => $"api/v1/stores/{storeId}/rates/configuration",
+        true => $"api/v1/stores/{storeId}/rates/configuration/fallback",
+        false => $"api/v1/stores/{storeId}/rates/configuration/primary",
+    };
+
+    public virtual async Task<List<RateSource>> GetRateSources(CancellationToken token = default)
+    {
+        return await SendHttpRequest<List<RateSource>>("misc/rate-sources", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<StoreRateConfiguration> UpdateStoreRateConfiguration(string storeId, StoreRateConfiguration request, bool? fallback = null, CancellationToken token = default)
+    {
+        var path = GetRateConfigPath(storeId, fallback);
+        return await SendHttpRequest<StoreRateConfiguration>(path, request, HttpMethod.Put, token);
+    }
+
+    public virtual async Task<List<StoreRateResult>> PreviewUpdateStoreRateConfiguration(string storeId, StoreRateConfiguration request, string[] currencyPair = null, CancellationToken token = default)
+    {
+        var queryPayload = currencyPair == null ? null : new Dictionary<string, object> { { "currencyPair", currencyPair } };
+        return await SendHttpRequest<StoreRateConfiguration, List<StoreRateResult>>($"api/v1/stores/{storeId}/rates/configuration/preview", queryPayload, request, HttpMethod.Post, token);
+    }
+
+    public virtual async Task<List<StoreRateResult>> GetStoreRates(string storeId, string[] currencyPair = null, CancellationToken token = default)
+    {
+        var queryPayload = currencyPair == null ? null : new Dictionary<string, object> { { "currencyPair", currencyPair } };
+        return await SendHttpRequest<List<StoreRateResult>>($"api/v1/stores/{storeId}/rates", queryPayload, HttpMethod.Get, token);
+    }
+}

btcpayserver/BTCPayServer.Client/BTCPayServerClient.StoreUsers.cs

@@ -0,0 +1,38 @@
+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<List<RoleData>> GetStoreRoles(string storeId, CancellationToken token = default)
+    {
+        return await SendHttpRequest<List<RoleData>>($"api/v1/stores/{storeId}/roles", null,  HttpMethod.Get,token);
+    }
+        
+    public virtual async Task<IEnumerable<StoreUserData>> GetStoreUsers(string storeId, CancellationToken token = default)
+    {
+        return await SendHttpRequest<IEnumerable<StoreUserData>>($"api/v1/stores/{storeId}/users", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task RemoveStoreUser(string storeId, string userId, CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{storeId}/users/{userId}", null, HttpMethod.Delete, token);
+    }
+
+    public virtual async Task AddStoreUser(string storeId, StoreUserData request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        await SendHttpRequest<StoreUserData>($"api/v1/stores/{storeId}/users", request, HttpMethod.Post, token);
+    }
+
+    public virtual async Task UpdateStoreUser(string storeId, string userId, StoreUserData request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        await SendHttpRequest<StoreUserData>($"api/v1/stores/{storeId}/users/{userId}", request, HttpMethod.Put, token);
+    }
+}

btcpayserver/BTCPayServer.Client/BTCPayServerClient.Stores.cs

@@ -0,0 +1,55 @@
+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)
+    {
+        return await SendHttpRequest<IEnumerable<StoreData>>("api/v1/stores", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<StoreData> GetStore(string storeId, CancellationToken token = default)
+    {
+        return await SendHttpRequest<StoreData>($"api/v1/stores/{storeId}", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task RemoveStore(string storeId, CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{storeId}", null, HttpMethod.Delete, token);
+    }
+
+    public virtual async Task<StoreData> CreateStore(CreateStoreRequest request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        return await SendHttpRequest<StoreData>("api/v1/stores", request, HttpMethod.Post, token);
+    }
+
+    public async Task<StoreData> UpdateStore(string storeId, StoreData request, CancellationToken token = default)
+    {
+        if (request is null)
+            throw new ArgumentNullException(nameof(request));
+        return await UpdateStore(storeId, Newtonsoft.Json.JsonConvert.DeserializeObject<UpdateStoreRequest>(Newtonsoft.Json.JsonConvert.SerializeObject(request)), token);
+    }
+    public virtual async Task<StoreData> UpdateStore(string storeId, UpdateStoreRequest request, CancellationToken token = default)
+    {
+        if (request == null) throw new ArgumentNullException(nameof(request));
+        if (storeId == null) throw new ArgumentNullException(nameof(storeId));
+        return await SendHttpRequest<StoreData>($"api/v1/stores/{storeId}", request, HttpMethod.Put, token);
+    }
+
+    public virtual async Task<StoreData> UploadStoreLogo(string storeId, string filePath, string mimeType, CancellationToken token = default)
+    {
+        return await UploadFileRequest<StoreData>($"api/v1/stores/{storeId}/logo", filePath, mimeType, "file", HttpMethod.Post, token);
+    }
+
+    public virtual async Task DeleteStoreLogo(string storeId, CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/stores/{storeId}/logo", null, HttpMethod.Delete, token);
+    }
+}

btcpayserver/BTCPayServer.Client/BTCPayServerClient.Users.cs

@@ -0,0 +1,71 @@
+#nullable enable
+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)
+    {
+        return await SendHttpRequest<ApplicationUserData>("api/v1/users/me", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<ApplicationUserData> UpdateCurrentUser(UpdateApplicationUserRequest request, CancellationToken token = default)
+    {
+        return await SendHttpRequest<ApplicationUserData>("api/v1/users/me", request, HttpMethod.Put, token);
+    }
+
+    public virtual async Task<ApplicationUserData> UploadCurrentUserProfilePicture(string filePath, string mimeType, CancellationToken token = default)
+    {
+        return await UploadFileRequest<ApplicationUserData>("api/v1/users/me/picture", filePath, mimeType, "file", HttpMethod.Post, token);
+    }
+
+    public virtual async Task DeleteCurrentUserProfilePicture(CancellationToken token = default)
+    {
+        await SendHttpRequest("api/v1/users/me/picture", null, HttpMethod.Delete, token);
+    }
+    
+    public virtual async Task<ApplicationUserData> CreateUser(CreateApplicationUserRequest request, CancellationToken token = default)
+    {
+        return await SendHttpRequest<ApplicationUserData>("api/v1/users", request, HttpMethod.Post, token);
+    }
+
+    public virtual async Task DeleteUser(string userId, CancellationToken token = default)
+    {
+        await SendHttpRequest($"api/v1/users/{userId}", null, HttpMethod.Delete, token);
+    }
+
+    public virtual async Task<ApplicationUserData> GetUserByIdOrEmail(string idOrEmail, CancellationToken token = default)
+    {
+        return await SendHttpRequest<ApplicationUserData>($"api/v1/users/{idOrEmail}", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<bool> LockUser(string idOrEmail, bool locked, CancellationToken token = default)
+    {
+        var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/users/{idOrEmail}/lock", null,
+            new LockUserRequest { Locked = locked }, HttpMethod.Post), token);
+        await HandleResponse(response);
+        return response.IsSuccessStatusCode;
+    }
+
+    public virtual async Task<bool> ApproveUser(string idOrEmail, bool approved, CancellationToken token = default)
+    {
+        var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/users/{idOrEmail}/approve", null,
+            new ApproveUserRequest { Approved = approved }, HttpMethod.Post), token);
+        await HandleResponse(response);
+        return response.IsSuccessStatusCode;
+    }
+
+    public virtual async Task<ApplicationUserData[]> GetUsers(CancellationToken token = default)
+    {
+        return await SendHttpRequest<ApplicationUserData[]>("api/v1/users/", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task DeleteCurrentUser(CancellationToken token = default)
+    {
+        await DeleteUser("me", token);
+    }
+}

btcpayserver/BTCPayServer.Client/BTCPayServerClient.Webhooks.cs

@@ -0,0 +1,58 @@
+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<StoreWebhookData> CreateWebhook(string storeId, CreateStoreWebhookRequest create, CancellationToken token = default)
+    {
+        return await SendHttpRequest<StoreWebhookData>($"api/v1/stores/{storeId}/webhooks", create, HttpMethod.Post, token);
+    }
+
+    public virtual async Task<StoreWebhookData> GetWebhook(string storeId, string webhookId, CancellationToken token = default)
+    {
+        var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/webhooks/{webhookId}"), token);
+        return response.StatusCode == System.Net.HttpStatusCode.NotFound ? null : await HandleResponse<StoreWebhookData>(response);
+    }
+
+    public virtual async Task<StoreWebhookData> UpdateWebhook(string storeId, string webhookId, UpdateStoreWebhookRequest update, CancellationToken token = default)
+    {
+        return await SendHttpRequest<StoreWebhookData>($"api/v1/stores/{storeId}/webhooks/{webhookId}", update, HttpMethod.Put, token);
+    }
+
+    public virtual async Task<bool> DeleteWebhook(string storeId, string webhookId, CancellationToken token = default)
+    {
+        var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/webhooks/{webhookId}", method: HttpMethod.Delete), token);
+        return response.IsSuccessStatusCode;
+    }
+
+    public virtual async Task<StoreWebhookData[]> GetWebhooks(string storeId, CancellationToken token = default)
+    {
+        return await SendHttpRequest<StoreWebhookData[]>($"api/v1/stores/{storeId}/webhooks", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<WebhookDeliveryData[]> GetWebhookDeliveries(string storeId, string webhookId, CancellationToken token = default)
+    {
+        return await SendHttpRequest<WebhookDeliveryData[]>($"api/v1/stores/{storeId}/webhooks/{webhookId}/deliveries", null, HttpMethod.Get, token);
+    }
+
+    public virtual async Task<WebhookDeliveryData> GetWebhookDelivery(string storeId, string webhookId, string deliveryId, CancellationToken token = default)
+    {
+        var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/webhooks/{webhookId}/deliveries/{deliveryId}"), token);
+        return response.StatusCode == System.Net.HttpStatusCode.NotFound ? null : await HandleResponse<WebhookDeliveryData>(response);
+    }
+
+    public virtual async Task<string> RedeliverWebhook(string storeId, string webhookId, string deliveryId, CancellationToken token = default)
+    {
+        return await SendHttpRequest<string>($"api/v1/stores/{storeId}/webhooks/{webhookId}/deliveries/{deliveryId}/redeliver", null, HttpMethod.Post, token);
+    }
+
+    public virtual async Task<WebhookEvent> GetWebhookDeliveryRequest(string storeId, string webhookId, string deliveryId, CancellationToken token = default)
+    {
+        var response = await _httpClient.SendAsync(CreateHttpRequest($"api/v1/stores/{storeId}/webhooks/{webhookId}/deliveries/{deliveryId}/request"), token);
+        return response.StatusCode == System.Net.HttpStatusCode.NotFound ? null : await HandleResponse<WebhookEvent>(response);
+    }
+}

btcpayserver/BTCPayServer.Client/BTCPayServerClient.cs

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