From 7517e6d8851c7c9bfc271423e994f973052a9364 Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Wed, 26 Apr 2023 14:51:43 +0300
Subject: [PATCH 01/38] feat(packages/clients/consensus/nimbus-eth2): Init
 package at 23.3.2.dev

---
 .../clients/consensus/nimbus-eth2/default.nix | 79 +++++++++++++++++++
 packages/default.nix                          |  4 +
 2 files changed, 83 insertions(+)
 create mode 100644 packages/clients/consensus/nimbus-eth2/default.nix

diff --git a/packages/clients/consensus/nimbus-eth2/default.nix b/packages/clients/consensus/nimbus-eth2/default.nix
new file mode 100644
index 00000000..dc9bc28b
--- /dev/null
+++ b/packages/clients/consensus/nimbus-eth2/default.nix
@@ -0,0 +1,79 @@
+{
+  stdenv,
+  fetchFromGitHub,
+  darwin,
+  lib,
+  nim,
+  cmake,
+  which,
+  writeScriptBin,
+  # Options: nimbus_light_client, nimbus_validator_client, nimbus_signing_node
+  makeTargets ? ["all"],
+  # These are the only platforms tested in CI and considered stable.
+  stablePlatforms ? [
+    "x86_64-linux"
+    "aarch64-linux"
+    "armv7a-linux"
+    "x86_64-darwin"
+    "aarch64-darwin"
+    "x86_64-windows"
+  ],
+}:
+# Version 1.6.12 is known to be stable and overriden in top-level.
+assert nim.version == "1.6.12";
+  stdenv.mkDerivation rec {
+    pname = "nimbus";
+    rev = "499b870a1a8e6688ff03b958709955075064b7e5";
+    version = "23.3.2.dev";
+
+    src = fetchFromGitHub {
+      owner = "status-im";
+      repo = "nimbus-eth2";
+      inherit rev;
+      hash = "sha256-0w9XGXxCAhBAuMkQ42Wh67Lmetn7Ihbdoq3iBOSx71k=";
+      fetchSubmodules = true;
+    };
+
+    # Fix for Nim compiler calling 'git rev-parse' and 'lsb_release'.
+    nativeBuildInputs = let
+      fakeGit = writeScriptBin "git" "echo $commit";
+      fakeLsbRelease = writeScriptBin "lsb_release" "echo nix";
+    in
+      [fakeGit fakeLsbRelease nim which cmake]
+      ++ lib.optionals stdenv.isDarwin [darwin.cctools];
+
+    enableParallelBuilding = true;
+
+    # Disable CPU optmizations that make binary not portable.
+    NIMFLAGS = "-d:disableMarchNative -d:git_revision_override=${rev}";
+
+    makeFlags = makeTargets ++ ["USE_SYSTEM_NIM=1"];
+
+    # Generate the nimbus-build-system.paths file.
+    configurePhase = ''
+      patchShebangs scripts vendor/nimbus-build-system/scripts
+      make nimbus-build-system-paths
+    '';
+
+    installPhase = ''
+      mkdir -p $out/bin
+      rm build/generate_makefile
+      cp build/* $out/bin
+    '';
+
+    meta = with lib; {
+      homepage = "https://nimbus.guide/";
+      downloadPage = "https://github.com/status-im/nimbus-eth2/releases";
+      changelog = "https://github.com/status-im/nimbus-eth2/blob/stable/CHANGELOG.md";
+      description = "Nimbus is a lightweight client for the Ethereum consensus layer";
+      longDescription = ''
+        Nimbus is an extremely efficient consensus layer client implementation.
+        While it's optimised for embedded systems and resource-restricted devices --
+        including Raspberry Pis, its low resource usage also makes it an excellent choice
+        for any server or desktop (where it simply takes up fewer resources).
+      '';
+      license = with licenses; [asl20 mit];
+      mainProgram = "nimbus_beacon_node";
+      platforms = stablePlatforms;
+    };
+  }
diff --git a/packages/default.nix b/packages/default.nix
index 19421953..a842c1a9 100644
--- a/packages/default.nix
+++ b/packages/default.nix
@@ -28,6 +28,7 @@
       prysm = callPackage ./clients/consensus/prysm {inherit bls blst;};
       teku = callPackage ./clients/consensus/teku {};
       nimbus = callPackageUnstable ./clients/consensus/nimbus {};
+      nimbus-eth2 = callPackage ./clients/consensus/nimbus-eth2 {};
 
       # Execution Clients
       erigon = callPackage ./clients/execution/erigon {};
@@ -115,6 +116,9 @@
         nimbus-validator-client.bin = "nimbus_validator_client";
       };
 
+      # consensus / nimbus-eth2
+      nimbus-eth2.bin = "nimbus_beacon_node";
+
       # execution clients
       besu.bin = "besu";
       erigon.bin = "erigon";

From c9f02d73803857a6da7dc872059faffe7b51544b Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Tue, 2 May 2023 18:44:18 +0300
Subject: [PATCH 02/38] feat(modules/nimbus-eth2): Init `Nimbus Beacon Node`
 Module

---
 modules/default.nix             |   1 +
 modules/lib.nix                 |   2 +-
 modules/nimbus-eth2/args.nix    | 115 +++++++++++++++++++++++++
 modules/nimbus-eth2/default.nix | 143 ++++++++++++++++++++++++++++++++
 modules/nimbus-eth2/options.nix |  53 ++++++++++++
 5 files changed, 313 insertions(+), 1 deletion(-)
 create mode 100644 modules/nimbus-eth2/args.nix
 create mode 100644 modules/nimbus-eth2/default.nix
 create mode 100644 modules/nimbus-eth2/options.nix

diff --git a/modules/default.nix b/modules/default.nix
index ee5387e6..ef02322b 100644
--- a/modules/default.nix
+++ b/modules/default.nix
@@ -18,6 +18,7 @@
       ./prysm-beacon
       ./prysm-validator
       ./restore
+      ./nimbus-eth2
     ];
   };
 }
diff --git a/modules/lib.nix b/modules/lib.nix
index be7e96bc..c8d6c6f2 100644
--- a/modules/lib.nix
+++ b/modules/lib.nix
@@ -97,7 +97,7 @@ lib: let
   };
 in {
   inherit baseServiceConfig;
-  inherit mkArg mkArgs defaultPathReducer dotPathReducer;
+  inherit mkArg mkArgs defaultPathReducer defaultArgReducer defaultArgFormatter dotPathReducer;
 
   findEnabled = with lib;
     tree: let
diff --git a/modules/nimbus-eth2/args.nix b/modules/nimbus-eth2/args.nix
new file mode 100644
index 00000000..82eac1b6
--- /dev/null
+++ b/modules/nimbus-eth2/args.nix
@@ -0,0 +1,115 @@
+lib:
+with lib; {
+  network = mkOption {
+    type = types.nullOr (types.enum ["goerli" "prater" "ropsten" "sepolia"]);
+    default = null;
+    description = mdDoc "The network to connect to. Mainnet (null) is the default ethereum network.";
+  };
+
+  jwt-secret = mkOption {
+    type = types.path;
+    default = null;
+    example = "/var/run/nimbus/jwtsecret";
+    description = mdDoc ''
+      Path of file with 32 bytes long JWT secret for Auth RPC endpoint.
+      Can be generated using 'openssl rand -hex 32'.
+    '';
+  };
+
+  udp-port = mkOption {
+    type = types.port;
+    default = 12000;
+    description = mdDoc "The port used by discv5.";
+  };
+
+  tcp-port = mkOption {
+    type = types.port;
+    default = 13000;
+    description = mdDoc "The port used by libp2p.";
+  };
+
+  subscribe-all-subnets = mkOption {
+    type = types.bool;
+    default = false;
+    description = mdDoc "Subscribe to all attestation subnet topics.";
+  };
+
+  doppelganger-detection = mkOption {
+    type = types.bool;
+    default = true;
+    description = mdDoc ''
+      Protection against slashing due to double-voting.
+      Means you will miss two attestations when restarting.
+    '';
+  };
+
+  suggested-fee-recipient = mkOption {
+    type = types.nullOr types.str;
+    default = null;
+    description = mdDoc ''
+      Wallet address where transaction fee tips - priority fees,
+      unburnt portion of gas fees - will be sent.
+    '';
+  };
+
+  nat = mkOption {
+    type = types.str;
+    default = "any";
+    example = "extip:12.34.56.78";
+    description = mdDoc ''
+      Method for determining public address. (any, none, upnp, pmp, extip:IP)
+    '';
+  };
+
+  metrics = {
+    enable = lib.mkEnableOption (mdDoc "Nimbus beacon node metrics endpoint");
+    address = mkOption {
+      type = types.str;
+      default = "127.0.0.1";
+      description = mdDoc "Metrics address for beacon node.";
+    };
+    port = mkOption {
+      type = types.port;
+      default = 8008;
+      description = mdDoc "Metrics port for beacon node.";
+    };
+  };
+
+  rest = {
+    enable = lib.mkEnableOption (mdDoc "Nimbus beacon node REST API");
+    address = mkOption {
+      type = types.str;
+      default = "127.0.0.1";
+      description = mdDoc "Listening address of the REST API server.";
+    };
+
+    port = mkOption {
+      type = types.port;
+      default = 5052;
+      description = mdDoc "Port for the REST API server.";
+    };
+  };
+
+  log = {
+    level = mkOption {
+      type = types.enum ["trace" "debug" "info" "notice" "warn" "error" "fatal" "none"];
+      default = "info";
+      example = "debug";
+      description = mdDoc "Logging level.";
+    };
+
+    format = mkOption {
+      type = types.enum ["auto" "colors" "nocolors" "json"];
+      default = "auto";
+      example = "json";
+      description = mdDoc "Logging formatting.";
+    };
+  };
+
+  web3-urls = mkOption {
+    type = types.listOf types.str;
+    default = [];
+    example = ["http://localhost:8551/"];
+    description = mdDoc "Mandatory URL(s) for the Web3 RPC endpoints.";
+  };
+}
diff --git a/modules/nimbus-eth2/default.nix b/modules/nimbus-eth2/default.nix
new file mode 100644
index 00000000..196d2e75
--- /dev/null
+++ b/modules/nimbus-eth2/default.nix
@@ -0,0 +1,143 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  modulesLib = import ../lib.nix {inherit lib pkgs;};
+
+  inherit (lib.lists) findFirst sublist last;
+  inherit (lib.strings) hasPrefix;
+  inherit (lib.attrsets) zipAttrsWith;
+  inherit
+    (lib)
+    concatStringsSep
+    filterAttrs
+    flatten
+    mapAttrs'
+    mapAttrsToList
+    mkIf
+    mkMerge
+    nameValuePair
+    types
+    ;
+  inherit (modulesLib) mkArgs baseServiceConfig defaultArgReducer;
+
+  eachBeacon = config.services.ethereum.nimbus-eth2;
+in {
+  ###### interface
+  inherit (import ./options.nix {inherit lib pkgs;}) options;
+
+  ###### implementation
+
+  config = mkIf (eachBeacon != {}) {
+    # configure the firewall for each service
+    networking.firewall = let
+      openFirewall = filterAttrs (_: cfg: cfg.openFirewall) eachBeacon;
+      perService =
+        mapAttrsToList
+        (
+          _: cfg:
+            with cfg.args; {
+              allowedUDPPorts = [udp-port];
+              allowedTCPPorts = [tcp-port];
+            }
+        )
+        openFirewall;
+    in
+      zipAttrsWith (_name: flatten) perService;
+
+    systemd.services =
+      mapAttrs'
+      (
+        beaconName: let
+          serviceName = "nimbus-eth2";
+        in
+          cfg: let
+            scriptArgs = let
+              # generate args
+              args = let
+                opts = import ./args.nix lib;
+
+                pathReducer = path: let
+                  p =
+                    if (last path == "enable")
+                    then sublist 0 ((builtins.length path) - 1) path
+                    else path;
+                in "--${concatStringsSep "-" p}";
+
+                argFormatter = {
+                  opt,
+                  path,
+                  value,
+                  argReducer ? defaultArgReducer,
+                  pathReducer ? defaultArgReducer,
+                }: let
+                  arg = pathReducer path;
+                in
+                  if (opt.type == types.bool)
+                  then
+                    (
+                      if value
+                      then "${arg}"
+                      else ""
+                    )
+                  else "${arg}=${argReducer value}";
+              in
+                mkArgs {
+                  inherit opts;
+                  inherit (cfg) args;
+                  inherit argFormatter;
+                  inherit pathReducer;
+                };
+
+              # filter out certain args which need to be treated differently
+              specialArgs = ["--network" "--jwt-secret" "--web3-urls"];
+              isNormalArg = name: (findFirst (arg: hasPrefix arg name) null specialArgs) == null;
+              filteredArgs = builtins.filter isNormalArg args;
+
+              network =
+                if cfg.args.network != null
+                then "--network=${cfg.args.network}"
+                else "";
+
+              jwtSecret =
+                if cfg.args.jwt-secret != null
+                then ''--jwt-secret="%d/jwt-secret"''
+                else "";
+
+              web3Url =
+                if cfg.args.web3-urls != null
+                then ''--web3-url=${concatStringsSep " --web3-url=" cfg.args.web3-urls}''
+                else "";
+            in ''
+              ${network} ${jwtSecret} \
+              ${web3Url} \
+              --data-dir="%S/${serviceName}" \
+              ${concatStringsSep " \\\n" filteredArgs} \
+              ${lib.escapeShellArgs cfg.extraArgs}
+            '';
+          in
+            nameValuePair serviceName (mkIf cfg.enable {
+              after = ["network.target"];
+              wantedBy = ["multi-user.target"];
+              description = "Nimbus Beacon Node (${beaconName})";
+
+              # create service config by merging with the base config
+              serviceConfig = mkMerge [
+                baseServiceConfig
+                {
+                  User = serviceName;
+                  StateDirectory = serviceName;
+                  ExecStart = "${cfg.package}/bin/nimbus_beacon_node ${scriptArgs}";
+                  MemoryDenyWriteExecute = "false"; # causes a library loading error
+                }
+                (mkIf (cfg.args.jwt-secret != null) {
+                  LoadCredential = ["jwt-secret:${cfg.args.jwt-secret}"];
+                })
+              ];
+            })
+      )
+      eachBeacon;
+  };
+}
diff --git a/modules/nimbus-eth2/options.nix b/modules/nimbus-eth2/options.nix
new file mode 100644
index 00000000..23dd5e8f
--- /dev/null
+++ b/modules/nimbus-eth2/options.nix
@@ -0,0 +1,53 @@
+{
+  lib,
+  pkgs,
+  ...
+}: let
+  args = import ./args.nix lib;
+  nimbusOpts = with lib; {
+    options = {
+      enable = mkEnableOption (mdDoc "Nimbus Beacon Node service");
+
+      inherit args;
+
+      extraArgs = mkOption {
+        type = types.listOf types.str;
+        default = [];
+        example = ["--num-threads=1" "--graffiti=1337_h4x0r"];
+        description = mdDoc "Additional arguments passed to node.";
+      };
+
+      package = mkOption {
+        type = types.package;
+        default = pkgs.nimbus-eth2;
+        defaultText = literalExpression "pkgs.nimbus-eth2";
+        description = mdDoc "Package to use for Nimbus Beacon Node binary";
+      };
+
+      openFirewall = mkOption {
+        type = types.bool;
+        default = false;
+        description = lib.mdDoc "Open ports in the firewall for any enabled networking services";
+      };
+
+      # mixin backup options
+      backup = let
+        inherit (import ../backup/lib.nix lib) options;
+      in
+        options;
+
+      # mixin restore options
+      restore = let
+        inherit (import ../restore/lib.nix lib) options;
+      in
+        options;
+    };
+  };
+in {
+  options.services.ethereum.nimbus-eth2 = with lib;
+    mkOption {
+      type = types.attrsOf (types.submodule nimbusOpts);
+      default = {};
+      description = mdDoc "Specification of one or more Nimbus Beacon Node instances.";
+    };
+}

From a4fd378b823b09944701b26a7932ae95948afb7d Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Wed, 31 May 2023 17:07:11 +0300
Subject: [PATCH 03/38] feat(modules/nimbus-eth2): Add `trusted-node-url`
 argument

When `trusted-node-url` is used nimbus ExecStart will be different and will use `trustedNodeSync` parameter.
---
 modules/nimbus-eth2/args.nix    |  7 ++++
 modules/nimbus-eth2/default.nix | 63 ++++++++++++++++++++++-----------
 2 files changed, 50 insertions(+), 20 deletions(-)

diff --git a/modules/nimbus-eth2/args.nix b/modules/nimbus-eth2/args.nix
index 82eac1b6..43c456fe 100644
--- a/modules/nimbus-eth2/args.nix
+++ b/modules/nimbus-eth2/args.nix
@@ -112,4 +112,11 @@ with lib; {
     example = ["http://localhost:8551/"];
     description = mdDoc "Mandatory URL(s) for the Web3 RPC endpoints.";
   };
+
+  trusted-node-url = mkOption {
+    type = types.nullOr types.str;
+    default = null;
+    example = "http://localhost:5052/";
+    description = mdDoc "URL for Trusted Node Sync.";
+  };
 }
diff --git a/modules/nimbus-eth2/default.nix b/modules/nimbus-eth2/default.nix
index 196d2e75..f8516709 100644
--- a/modules/nimbus-eth2/default.nix
+++ b/modules/nimbus-eth2/default.nix
@@ -54,7 +54,29 @@ in {
           serviceName = "nimbus-eth2";
         in
           cfg: let
-            scriptArgs = let
+            network =
+              if cfg.args.network != null
+              then "--network=${cfg.args.network}"
+              else "";
+
+            jwtSecret =
+              if cfg.args.jwt-secret != null
+              then ''--jwt-secret="%d/jwt-secret"''
+              else "";
+
+            trustedNodeUrl =
+              if cfg.args.trusted-node-url != null
+              then ''--trusted-node-url="${cfg.args.trusted-node-url}"''
+              else "";
+
+            web3Url =
+              if cfg.args.web3-urls != null
+              then ''--web3-url=${concatStringsSep " --web3-url=" cfg.args.web3-urls}''
+              else "";
+
+            dataDir = ''--data-dir="%S/${serviceName}"'';
+
+            beaconNodeArgs = let
               # generate args
               args = let
                 opts = import ./args.nix lib;
@@ -90,33 +112,34 @@ in {
                   inherit argFormatter;
                   inherit pathReducer;
                 };
-
               # filter out certain args which need to be treated differently
-              specialArgs = ["--network" "--jwt-secret" "--web3-urls"];
+              specialArgs = ["--network" "--jwt-secret" "--web3-urls" "--trusted-node-url"];
               isNormalArg = name: (findFirst (arg: hasPrefix arg name) null specialArgs) == null;
               filteredArgs = builtins.filter isNormalArg args;
-
-              network =
-                if cfg.args.network != null
-                then "--network=${cfg.args.network}"
-                else "";
-
-              jwtSecret =
-                if cfg.args.jwt-secret != null
-                then ''--jwt-secret="%d/jwt-secret"''
-                else "";
-
-              web3Url =
-                if cfg.args.web3-urls != null
-                then ''--web3-url=${concatStringsSep " --web3-url=" cfg.args.web3-urls}''
-                else "";
             in ''
               ${network} ${jwtSecret} \
               ${web3Url} \
-              --data-dir="%S/${serviceName}" \
+              ${dataDir} \
               ${concatStringsSep " \\\n" filteredArgs} \
               ${lib.escapeShellArgs cfg.extraArgs}
             '';
+
+            nodeSyncArgs = ''
+              ${network} \
+              ${dataDir} \
+              ${trustedNodeUrl}
+            '';
+
+            entrypoint =
+              if cfg.args.trusted-node-url != null
+              then ''
+                ${cfg.package}/bin/nimbus_beacon_node trustedNodeSync ${nodeSyncArgs} \
+                && \
+                ${cfg.package}/bin/nimbus_beacon_node ${beaconNodeArgs}
+              ''
+              else ''
+                ${cfg.package}/bin/nimbus_beacon_node ${beaconNodeArgs}
+              '';
           in
             nameValuePair serviceName (mkIf cfg.enable {
               after = ["network.target"];
@@ -129,7 +152,7 @@ in {
                 {
                   User = serviceName;
                   StateDirectory = serviceName;
-                  ExecStart = "${cfg.package}/bin/nimbus_beacon_node ${scriptArgs}";
+                  ExecStart = entrypoint;
                   MemoryDenyWriteExecute = "false"; # causes a library loading error
                 }
                 (mkIf (cfg.args.jwt-secret != null) {

From 9f72eb0fba0b0c6d0897209bf6e0fd1db86a1c12 Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Wed, 31 May 2023 17:43:48 +0300
Subject: [PATCH 04/38] feat(modules/nimbus-eth2): Add `backfill` argument

---
 modules/nimbus-eth2/args.nix    |  6 ++++++
 modules/nimbus-eth2/default.nix | 10 ++++++++--
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/modules/nimbus-eth2/args.nix b/modules/nimbus-eth2/args.nix
index 43c456fe..1e6a6dbf 100644
--- a/modules/nimbus-eth2/args.nix
+++ b/modules/nimbus-eth2/args.nix
@@ -119,4 +119,10 @@ with lib; {
     example = "http://localhost:5052/";
     description = mdDoc "URL for Trusted Node Sync.";
   };
+
+  backfill = mkOption {
+    type = types.nullOr types.bool;
+    default = true;
+    description = mdDoc "History backfill.";
+  };
 }
diff --git a/modules/nimbus-eth2/default.nix b/modules/nimbus-eth2/default.nix
index f8516709..d4d0d46f 100644
--- a/modules/nimbus-eth2/default.nix
+++ b/modules/nimbus-eth2/default.nix
@@ -69,6 +69,11 @@ in {
               then ''--trusted-node-url="${cfg.args.trusted-node-url}"''
               else "";
 
+            backfilling =
+              if cfg.args.trusted-node-url != null
+              then ''--backfill=${lib.boolToString cfg.args.backfill}''
+              else "";
+
             web3Url =
               if cfg.args.web3-urls != null
               then ''--web3-url=${concatStringsSep " --web3-url=" cfg.args.web3-urls}''
@@ -113,7 +118,7 @@ in {
                   inherit pathReducer;
                 };
               # filter out certain args which need to be treated differently
-              specialArgs = ["--network" "--jwt-secret" "--web3-urls" "--trusted-node-url"];
+              specialArgs = ["--network" "--jwt-secret" "--web3-urls" "--trusted-node-url" "--backfill"];
               isNormalArg = name: (findFirst (arg: hasPrefix arg name) null specialArgs) == null;
               filteredArgs = builtins.filter isNormalArg args;
             in ''
@@ -127,7 +132,8 @@ in {
             nodeSyncArgs = ''
               ${network} \
               ${dataDir} \
-              ${trustedNodeUrl}
+              ${trustedNodeUrl} \
+              ${backfilling}
             '';
 
             entrypoint =

From a994a310a8b0cb6e6b00c7ca1fb697cd7d07cd8e Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Wed, 21 Jun 2023 14:34:43 +0300
Subject: [PATCH 05/38] update(packages/nimbus-eth2): Update `nimbus-eth2` to
 the newest version

Also got `nimbus-eth2` working with the changes from the `nix-community/ethereum.nix` repo
---
 modules/nimbus-eth2/default.nix                    | 2 +-
 packages/clients/consensus/nimbus-eth2/default.nix | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/modules/nimbus-eth2/default.nix b/modules/nimbus-eth2/default.nix
index d4d0d46f..ad6630da 100644
--- a/modules/nimbus-eth2/default.nix
+++ b/modules/nimbus-eth2/default.nix
@@ -4,7 +4,7 @@
   pkgs,
   ...
 }: let
-  modulesLib = import ../lib.nix {inherit lib pkgs;};
+  modulesLib = import ../lib.nix lib;
 
   inherit (lib.lists) findFirst sublist last;
   inherit (lib.strings) hasPrefix;
diff --git a/packages/clients/consensus/nimbus-eth2/default.nix b/packages/clients/consensus/nimbus-eth2/default.nix
index dc9bc28b..99139c79 100644
--- a/packages/clients/consensus/nimbus-eth2/default.nix
+++ b/packages/clients/consensus/nimbus-eth2/default.nix
@@ -23,14 +23,14 @@
 assert nim.version == "1.6.12";
   stdenv.mkDerivation rec {
     pname = "nimbus";
-    rev = "499b870a1a8e6688ff03b958709955075064b7e5";
-    version = "23.3.2.dev";
+    rev = "1bc9f3a67ac519ab4f889ca19abfd74f5e07c205";
+    version = "23.6.0";
 
     src = fetchFromGitHub {
       owner = "status-im";
       repo = "nimbus-eth2";
       inherit rev;
-      hash = "sha256-0w9XGXxCAhBAuMkQ42Wh67Lmetn7Ihbdoq3iBOSx71k=";
+      hash = "sha256-uAaKKLMlQRklUfTyYmdwI+27evmEEGVE2TFkKuCgAes=";
       fetchSubmodules = true;
     };
 

From cdefc2a2d3b567dce9968eceaca80e908b4c11df Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Thu, 22 Jun 2023 16:18:48 +0300
Subject: [PATCH 06/38] config(modules/nimbus-eth2): Fix problem with
 trustedNodeSync

---
 modules/nimbus-eth2/default.nix | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

diff --git a/modules/nimbus-eth2/default.nix b/modules/nimbus-eth2/default.nix
index ad6630da..03d2de52 100644
--- a/modules/nimbus-eth2/default.nix
+++ b/modules/nimbus-eth2/default.nix
@@ -133,19 +133,14 @@ in {
               ${network} \
               ${dataDir} \
               ${trustedNodeUrl} \
-              ${backfilling}
-            '';
+              ${backfilling}'';
 
-            entrypoint =
+            trustedNodeSync =
               if cfg.args.trusted-node-url != null
               then ''
-                ${cfg.package}/bin/nimbus_beacon_node trustedNodeSync ${nodeSyncArgs} \
-                && \
-                ${cfg.package}/bin/nimbus_beacon_node ${beaconNodeArgs}
+                ${cfg.package}/bin/nimbus_beacon_node trustedNodeSync ${nodeSyncArgs}
               ''
-              else ''
-                ${cfg.package}/bin/nimbus_beacon_node ${beaconNodeArgs}
-              '';
+              else null;
           in
             nameValuePair serviceName (mkIf cfg.enable {
               after = ["network.target"];
@@ -158,7 +153,8 @@ in {
                 {
                   User = serviceName;
                   StateDirectory = serviceName;
-                  ExecStart = entrypoint;
+                  ExecStartPre = trustedNodeSync;
+                  ExecStart = ''${cfg.package}/bin/nimbus_beacon_node ${beaconNodeArgs}'';
                   MemoryDenyWriteExecute = "false"; # causes a library loading error
                 }
                 (mkIf (cfg.args.jwt-secret != null) {

From 21aa6764b78e6b8382ff3812967f0fa04d6ca7bf Mon Sep 17 00:00:00 2001
From: Petar Kirov <petar.p.kirov@gmail.com>
Date: Mon, 26 Jun 2023 21:01:15 +0300
Subject: [PATCH 07/38] build(erigon-portable): Add variant that compiles BLST
 in portable mode

---
 modules/erigon/default.nix | 7 ++++++-
 modules/erigon/options.nix | 6 ++++++
 packages/default.nix       | 3 +++
 3 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/modules/erigon/default.nix b/modules/erigon/default.nix
index f843c765..00834635 100644
--- a/modules/erigon/default.nix
+++ b/modules/erigon/default.nix
@@ -91,6 +91,11 @@ in {
               ${concatStringsSep " \\\n" args} \
               ${lib.escapeShellArgs cfg.extraArgs}
             '';
+
+            package =
+              if cfg.blst-portable
+              then pkgs.erigon-blst-portable
+              else cfg.package;
           in
             nameValuePair serviceName (mkIf cfg.enable {
               description = "Erigon Ethereum node (${erigonName})";
@@ -106,7 +111,7 @@ in {
                   ExecStartPre = mkIf cfg.subVolume (mkBefore [
                     "+${scripts.setupSubVolume} /var/lib/private/${serviceName}"
                   ]);
-                  ExecStart = "${cfg.package}/bin/erigon ${scriptArgs}";
+                  ExecStart = "${package}/bin/erigon ${scriptArgs}";
                 }
               ];
             })
diff --git a/modules/erigon/options.nix b/modules/erigon/options.nix
index ee5eb74d..9a76b768 100644
--- a/modules/erigon/options.nix
+++ b/modules/erigon/options.nix
@@ -19,6 +19,12 @@
         default = [];
       };
 
+      blst-portable = mkOption {
+        type = types.bool;
+        default = false;
+        description = lib.mdDoc "Make blst library used by erigon build in portable mode. When this option is enabled, the package option is ignored.";
+      };
+
       package = mkOption {
         type = types.package;
         default = pkgs.erigon;
diff --git a/packages/default.nix b/packages/default.nix
index a842c1a9..808d5d4a 100644
--- a/packages/default.nix
+++ b/packages/default.nix
@@ -32,6 +32,9 @@
 
       # Execution Clients
       erigon = callPackage ./clients/execution/erigon {};
+      erigon-blst-portable = erigon.overrideAttrs (_finalAttrs: _previousAttrs: {
+        CGO_CFLAGS = "-O -D__BLST_PORTABLE__";
+      });
       besu = callPackage ./clients/execution/besu {};
       geth = callPackage ./clients/execution/geth {};
       geth-sealer = callPackage ./clients/execution/geth-sealer {};

From 059d0c7273b6c32c5da6e8cad25b3ff400aa0b6a Mon Sep 17 00:00:00 2001
From: Petar Kirov <petar.p.kirov@gmail.com>
Date: Mon, 10 Jul 2023 15:14:21 +0300
Subject: [PATCH 08/38] update(packages/nimbus-eth2): Update `nimbus-eth2` to
 v23.6.1

---
 .../clients/consensus/nimbus-eth2/default.nix | 20 ++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/packages/clients/consensus/nimbus-eth2/default.nix b/packages/clients/consensus/nimbus-eth2/default.nix
index 99139c79..bcc482d9 100644
--- a/packages/clients/consensus/nimbus-eth2/default.nix
+++ b/packages/clients/consensus/nimbus-eth2/default.nix
@@ -6,6 +6,7 @@
   nim,
   cmake,
   which,
+  fetchpatch,
   writeScriptBin,
   # Options: nimbus_light_client, nimbus_validator_client, nimbus_signing_node
   makeTargets ? ["all"],
@@ -19,21 +20,30 @@
     "x86_64-windows"
   ],
 }:
-# Version 1.6.12 is known to be stable and overriden in top-level.
-assert nim.version == "1.6.12";
+# Nim version(s) that are known to be stable
+assert nim.version == "1.6.12" || nim.version == "1.6.14";
   stdenv.mkDerivation rec {
     pname = "nimbus";
-    rev = "1bc9f3a67ac519ab4f889ca19abfd74f5e07c205";
-    version = "23.6.0";
+    rev = "187e1a06335e36bbc508fff38729833d154edbaa";
+    version = "23.6.1";
 
     src = fetchFromGitHub {
       owner = "status-im";
       repo = "nimbus-eth2";
       inherit rev;
-      hash = "sha256-uAaKKLMlQRklUfTyYmdwI+27evmEEGVE2TFkKuCgAes=";
+      hash = "sha256-O7jxRuJZkrdNZVZ3jMOPjTh/tWk3XgPwx5A0xgELvAU=";
       fetchSubmodules = true;
     };
 
+    patches = [
+      # Nim 1.6.14 support
+      (fetchpatch {
+        name = "nim-v1.6.14-support.patch";
+        url = "https://github.com/status-im/nimbus-eth2/commit/41b93ae57a7bb32758f453a09259ae44b37e3db9.patch";
+        hash = "sha256-yvXREhqc/C0Yo2ioTaOFFw7KAc0WgDkoM5SXXnaIjrQ=";
+      })
+    ];
+
     # Fix for Nim compiler calling 'git rev-parse' and 'lsb_release'.
     nativeBuildInputs = let
       fakeGit = writeScriptBin "git" "echo $commit";

From e0693d50b6851db1c56165c68e3ec06126db6091 Mon Sep 17 00:00:00 2001
From: MartinNikov <99672862+MartinNikov@users.noreply.github.com>
Date: Fri, 25 Aug 2023 09:27:08 +0000
Subject: [PATCH 09/38] (modules/{nimbus-eth2,erigon}): Use DynamicUser and
 LoadCredential for loading secrets

* config(modules/nimbus-eth2): Don't define custom user for the service, but rely on the DynamicUser
* config(modules/lib.nix): Add `ProcSubset` to baseServiceConfig
* config(modules/erigon): Refactor systemd config to use LoadCredential
---
 modules/erigon/default.nix      | 18 ++++++++++++++++--
 modules/lib.nix                 |  1 +
 modules/nimbus-eth2/default.nix |  1 -
 3 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/modules/erigon/default.nix b/modules/erigon/default.nix
index 00834635..7d44dd21 100644
--- a/modules/erigon/default.nix
+++ b/modules/erigon/default.nix
@@ -5,7 +5,8 @@
   pkgs,
   ...
 }: let
-  inherit (lib.lists) optionals;
+  inherit (lib.lists) findFirst optionals;
+  inherit (lib.strings) hasPrefix;
   inherit
     (lib)
     concatStringsSep
@@ -68,6 +69,11 @@ in {
           serviceName = "erigon-${erigonName}";
         in
           cfg: let
+            jwtsecret =
+              if cfg.args.authrpc.jwtsecret != null
+              then ''--authrpc.jwtsecret=''${CREDENTIALS_DIRECTORY}/jwtsecret''
+              else "";
+
             scriptArgs = let
               # replace enable flags like --http.enable with just --http
               pathReducer = path: let
@@ -86,9 +92,14 @@ in {
                 if cfg.args.datadir != null
                 then "--datadir ${cfg.args.datadir}"
                 else "--datadir %S/${serviceName}";
+
+              specialArgs = ["--authrpc.jwtsecret"];
+              isNormalArg = name: (findFirst (arg: hasPrefix arg name) null specialArgs) == null;
+              filteredArgs = builtins.filter isNormalArg args;
             in ''
               ${datadir} \
-              ${concatStringsSep " \\\n" args} \
+              ${jwtsecret} \
+              ${concatStringsSep " \\\n" filteredArgs} \
               ${lib.escapeShellArgs cfg.extraArgs}
             '';
 
@@ -113,6 +124,9 @@ in {
                   ]);
                   ExecStart = "${package}/bin/erigon ${scriptArgs}";
                 }
+                (mkIf (cfg.args.authrpc.jwtsecret != null) {
+                  LoadCredential = ["jwtsecret:${cfg.args.authrpc.jwtsecret}"];
+                })
               ];
             })
       )
diff --git a/modules/lib.nix b/modules/lib.nix
index c8d6c6f2..217bd673 100644
--- a/modules/lib.nix
+++ b/modules/lib.nix
@@ -81,6 +81,7 @@ lib: let
     #   * ProtectHome = "read-only"
     DynamicUser = mkDefault true;
 
+    ProcSubset = mkDefault "pid";
     ProtectClock = mkDefault true;
     ProtectProc = mkDefault "noaccess";
     ProtectKernelLogs = mkDefault true;
diff --git a/modules/nimbus-eth2/default.nix b/modules/nimbus-eth2/default.nix
index 03d2de52..d868ac92 100644
--- a/modules/nimbus-eth2/default.nix
+++ b/modules/nimbus-eth2/default.nix
@@ -151,7 +151,6 @@ in {
               serviceConfig = mkMerge [
                 baseServiceConfig
                 {
-                  User = serviceName;
                   StateDirectory = serviceName;
                   ExecStartPre = trustedNodeSync;
                   ExecStart = ''${cfg.package}/bin/nimbus_beacon_node ${beaconNodeArgs}'';

From 3203203262c7ee0c952ddab359b36ac5d9e798e3 Mon Sep 17 00:00:00 2001
From: MartinNikov <99672862+MartinNikov@users.noreply.github.com>
Date: Fri, 25 Aug 2023 10:19:56 +0000
Subject: [PATCH 10/38] config(modules/nimbus-eth2): Set (again) the systemd
 unit user name (#9)

---
 modules/nimbus-eth2/default.nix | 1 +
 1 file changed, 1 insertion(+)

diff --git a/modules/nimbus-eth2/default.nix b/modules/nimbus-eth2/default.nix
index d868ac92..03d2de52 100644
--- a/modules/nimbus-eth2/default.nix
+++ b/modules/nimbus-eth2/default.nix
@@ -151,6 +151,7 @@ in {
               serviceConfig = mkMerge [
                 baseServiceConfig
                 {
+                  User = serviceName;
                   StateDirectory = serviceName;
                   ExecStartPre = trustedNodeSync;
                   ExecStart = ''${cfg.package}/bin/nimbus_beacon_node ${beaconNodeArgs}'';

From 15243056200ad3e187fce57e7ec717b7a66f5626 Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Mon, 28 Aug 2023 12:17:05 +0300
Subject: [PATCH 11/38] update(packages/nimbus-eth2): Update `nimbus-eth2` to
 v23.8.0

---
 .../clients/consensus/nimbus-eth2/default.nix    | 16 +++-------------
 packages/default.nix                             |  2 +-
 2 files changed, 4 insertions(+), 14 deletions(-)

diff --git a/packages/clients/consensus/nimbus-eth2/default.nix b/packages/clients/consensus/nimbus-eth2/default.nix
index bcc482d9..83b008cd 100644
--- a/packages/clients/consensus/nimbus-eth2/default.nix
+++ b/packages/clients/consensus/nimbus-eth2/default.nix
@@ -6,7 +6,6 @@
   nim,
   cmake,
   which,
-  fetchpatch,
   writeScriptBin,
   # Options: nimbus_light_client, nimbus_validator_client, nimbus_signing_node
   makeTargets ? ["all"],
@@ -24,26 +23,17 @@
 assert nim.version == "1.6.12" || nim.version == "1.6.14";
   stdenv.mkDerivation rec {
     pname = "nimbus";
-    rev = "187e1a06335e36bbc508fff38729833d154edbaa";
-    version = "23.6.1";
+    rev = "d014d0a51cca1dda13d34e3de860aa4287afdb36";
+    version = "23.8.0";
 
     src = fetchFromGitHub {
       owner = "status-im";
       repo = "nimbus-eth2";
       inherit rev;
-      hash = "sha256-O7jxRuJZkrdNZVZ3jMOPjTh/tWk3XgPwx5A0xgELvAU=";
+      hash = "sha256-NfCXooS3vCrLzKYusl4MeMSVtc/ZQzRnq2E+QJUhNL8=";
       fetchSubmodules = true;
     };
 
-    patches = [
-      # Nim 1.6.14 support
-      (fetchpatch {
-        name = "nim-v1.6.14-support.patch";
-        url = "https://github.com/status-im/nimbus-eth2/commit/41b93ae57a7bb32758f453a09259ae44b37e3db9.patch";
-        hash = "sha256-yvXREhqc/C0Yo2ioTaOFFw7KAc0WgDkoM5SXXnaIjrQ=";
-      })
-    ];
-
     # Fix for Nim compiler calling 'git rev-parse' and 'lsb_release'.
     nativeBuildInputs = let
       fakeGit = writeScriptBin "git" "echo $commit";
diff --git a/packages/default.nix b/packages/default.nix
index 808d5d4a..ccfca9a3 100644
--- a/packages/default.nix
+++ b/packages/default.nix
@@ -28,7 +28,7 @@
       prysm = callPackage ./clients/consensus/prysm {inherit bls blst;};
       teku = callPackage ./clients/consensus/teku {};
       nimbus = callPackageUnstable ./clients/consensus/nimbus {};
-      nimbus-eth2 = callPackage ./clients/consensus/nimbus-eth2 {};
+      nimbus-eth2 = callPackageUnstable ./clients/consensus/nimbus-eth2 {};
 
       # Execution Clients
       erigon = callPackage ./clients/execution/erigon {};

From fc9d89b1061433f32a996df239e793825c4bedb5 Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Tue, 19 Sep 2023 18:04:15 +0300
Subject: [PATCH 12/38] config(modules/nimbus-eth2): Check if
 `/var/lib/private/nimbus-eth2/db/nbc.sqlite3` exists

Skip trustedNodeSync if it already exists.
---
 modules/nimbus-eth2/default.nix | 20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/modules/nimbus-eth2/default.nix b/modules/nimbus-eth2/default.nix
index 03d2de52..70e185eb 100644
--- a/modules/nimbus-eth2/default.nix
+++ b/modules/nimbus-eth2/default.nix
@@ -135,11 +135,25 @@ in {
               ${trustedNodeUrl} \
               ${backfilling}'';
 
+            # When running trustedNodeSync after passing once, it gives an error
+            # and doesn't continue to execute execStart. The problem occurs when
+            # the service is restarted and execStartPre runs again. So we check
+            # for the existence of a file in the folder, and that way we know if
+            # Nimbus is running for the first time or not.
+
             trustedNodeSync =
               if cfg.args.trusted-node-url != null
-              then ''
-                ${cfg.package}/bin/nimbus_beacon_node trustedNodeSync ${nodeSyncArgs}
-              ''
+              then
+                pkgs.writeShellScript "trustedNodeSync.sh" ''
+                  ls -lah /var/lib/private/
+                  if [ -f "/var/lib/private/nimbus-eth2/db/nbc.sqlite3" ]; then
+                    echo "skipping trustedNodeSync";
+                    exit 0
+                  else
+                    echo "starting trustedNodeSync";
+                    ${cfg.package}/bin/nimbus_beacon_node trustedNodeSync ${nodeSyncArgs}
+                  fi
+                ''
               else null;
           in
             nameValuePair serviceName (mkIf cfg.enable {

From c2d067eae9223378eaa348682216776ec3732af5 Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Wed, 25 Oct 2023 14:25:51 +0300
Subject: [PATCH 13/38] config(modules/geth): Add `ipcEnable` option

---
 modules/geth/args.nix    | 6 ++++++
 modules/geth/default.nix | 7 ++++++-
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/modules/geth/args.nix b/modules/geth/args.nix
index 4ec841a1..8d6ed0cd 100644
--- a/modules/geth/args.nix
+++ b/modules/geth/args.nix
@@ -179,4 +179,10 @@ with lib; {
     default = null;
     description = mdDoc "Data directory for Geth. Defaults to '%S/geth-\<name\>', which generally resolves to /var/lib/geth-\<name\>.";
   };
+
+  ipcEnable = mkOption {
+    type = types.bool;
+    default = false;
+    description = mdDoc "Enable the IPC-RPC server";
+  };
 }
diff --git a/modules/geth/default.nix b/modules/geth/default.nix
index e6ad580b..e20dc81b 100644
--- a/modules/geth/default.nix
+++ b/modules/geth/default.nix
@@ -100,9 +100,14 @@ in {
                 if cfg.args.datadir != null
                 then "--datadir ${cfg.args.datadir}"
                 else "--datadir %S/${serviceName}";
+
+              ipc =
+                if cfg.args.ipcEnable
+                then ""
+                else "--ipcdisable";
             in ''
+              ${ipc} ${network} ${jwtSecret} \
               ${datadir} \
-              --ipcdisable ${network} ${jwtSecret} \
               ${concatStringsSep " \\\n" filteredArgs} \
               ${lib.escapeShellArgs cfg.extraArgs}
             '';

From af139d5abf5e99cdd7734dd11f33de9af86a0472 Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Wed, 25 Oct 2023 14:26:21 +0300
Subject: [PATCH 14/38] update(packages/nimbus-eth2): Update `nimbus-eth2` to
 v23.10.0

---
 packages/clients/consensus/nimbus-eth2/default.nix | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/packages/clients/consensus/nimbus-eth2/default.nix b/packages/clients/consensus/nimbus-eth2/default.nix
index 83b008cd..a2f005dc 100644
--- a/packages/clients/consensus/nimbus-eth2/default.nix
+++ b/packages/clients/consensus/nimbus-eth2/default.nix
@@ -23,14 +23,14 @@
 assert nim.version == "1.6.12" || nim.version == "1.6.14";
   stdenv.mkDerivation rec {
     pname = "nimbus";
-    rev = "d014d0a51cca1dda13d34e3de860aa4287afdb36";
-    version = "23.8.0";
+    rev = "v23.10.0";
+    version = "23.10.0";
 
     src = fetchFromGitHub {
       owner = "status-im";
       repo = "nimbus-eth2";
       inherit rev;
-      hash = "sha256-NfCXooS3vCrLzKYusl4MeMSVtc/ZQzRnq2E+QJUhNL8=";
+      hash = "sha256-eXfHwexoWbrlsXwdNT2TQWlFl526aQfRNxxW6s/khHA=";
       fetchSubmodules = true;
     };
 

From 7dc3dab62165b67c6fe5e9d8bb22c1e1510b2568 Mon Sep 17 00:00:00 2001
From: Petar Kirov <petar.p.kirov@gmail.com>
Date: Thu, 26 Oct 2023 18:37:25 +0300
Subject: [PATCH 15/38] fix(modules/nimbus-eth2): Fix `ExecStartPre`
 command-line

---
 modules/nimbus-eth2/default.nix | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/modules/nimbus-eth2/default.nix b/modules/nimbus-eth2/default.nix
index 70e185eb..b9707d95 100644
--- a/modules/nimbus-eth2/default.nix
+++ b/modules/nimbus-eth2/default.nix
@@ -79,7 +79,8 @@ in {
               then ''--web3-url=${concatStringsSep " --web3-url=" cfg.args.web3-urls}''
               else "";
 
-            dataDir = ''--data-dir="%S/${serviceName}"'';
+            dataDirPath = "%S/${serviceName}";
+            dataDir = ''--data-dir="${dataDirPath}"'';
 
             beaconNodeArgs = let
               # generate args
@@ -131,7 +132,6 @@ in {
 
             nodeSyncArgs = ''
               ${network} \
-              ${dataDir} \
               ${trustedNodeUrl} \
               ${backfilling}'';
 
@@ -143,17 +143,20 @@ in {
 
             trustedNodeSync =
               if cfg.args.trusted-node-url != null
-              then
-                pkgs.writeShellScript "trustedNodeSync.sh" ''
-                  ls -lah /var/lib/private/
-                  if [ -f "/var/lib/private/nimbus-eth2/db/nbc.sqlite3" ]; then
+              then let
+                script = pkgs.writeShellScript "trustedNodeSync.sh" ''
+                  datadir="$1"
+                  shift
+                  if [ -f "$datadir/db/nbc.sqlite3" ]; then
                     echo "skipping trustedNodeSync";
                     exit 0
                   else
                     echo "starting trustedNodeSync";
-                    ${cfg.package}/bin/nimbus_beacon_node trustedNodeSync ${nodeSyncArgs}
+                    set -x
+                    ${cfg.package}/bin/nimbus_beacon_node trustedNodeSync "$@"
                   fi
-                ''
+                '';
+              in "${script} ${dataDirPath} ${dataDir} ${nodeSyncArgs}"
               else null;
           in
             nameValuePair serviceName (mkIf cfg.enable {

From 0a089f43129aa25fdde4fccc5359fa99b61f9730 Mon Sep 17 00:00:00 2001
From: Petar Kirov <petar.p.kirov@gmail.com>
Date: Thu, 26 Oct 2023 19:46:19 +0300
Subject: [PATCH 16/38] fix(modules/geth): Add `ipcEnable` to specialArgs

---
 modules/geth/default.nix | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/geth/default.nix b/modules/geth/default.nix
index e20dc81b..3ea7a85f 100644
--- a/modules/geth/default.nix
+++ b/modules/geth/default.nix
@@ -81,7 +81,7 @@ in {
                 };
 
               # filter out certain args which need to be treated differently
-              specialArgs = ["--network" "--authrpc.jwtsecret"];
+              specialArgs = ["--network" "--authrpc.jwtsecret" "--ipcEnable"];
               isNormalArg = name: (findFirst (arg: hasPrefix arg name) null specialArgs) == null;
 
               filteredArgs = builtins.filter isNormalArg args;

From fccdd06ac40697e1ef293fb7529e280aaf81b75a Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Fri, 27 Oct 2023 12:04:34 +0300
Subject: [PATCH 17/38] config(modules/nethermind): Set
 `MemoryDenyWriteExecute` to false

---
 modules/nethermind/default.nix | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/modules/nethermind/default.nix b/modules/nethermind/default.nix
index 060fb41b..999af403 100644
--- a/modules/nethermind/default.nix
+++ b/modules/nethermind/default.nix
@@ -137,6 +137,8 @@ in {
                   User = serviceName;
                   StateDirectory = serviceName;
                   ExecStart = "${cfg.package}/bin/Nethermind.Runner ${scriptArgs}";
+
+                  MemoryDenyWriteExecute = false;
                 }
                 (mkIf (cfg.args.modules.JsonRpc.JwtSecretFile != null) {
                   LoadCredential = ["jwtsecret:${cfg.args.modules.JsonRpc.JwtSecretFile}"];

From 020b1f67eecd6e980ea819bfd8248dd324c010c8 Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Mon, 30 Oct 2023 13:10:14 +0200
Subject: [PATCH 18/38] feat(modules/nimbus-eth2): Add `payload-builder` option

---
 modules/nimbus-eth2/args.nix    | 10 ++++++++++
 modules/nimbus-eth2/default.nix | 18 +++++++++++++++++-
 2 files changed, 27 insertions(+), 1 deletion(-)

diff --git a/modules/nimbus-eth2/args.nix b/modules/nimbus-eth2/args.nix
index 1e6a6dbf..75360b4b 100644
--- a/modules/nimbus-eth2/args.nix
+++ b/modules/nimbus-eth2/args.nix
@@ -125,4 +125,14 @@ with lib; {
     default = true;
     description = mdDoc "History backfill.";
   };
+
+  payload-builder = {
+    enable = lib.mkEnableOption (mdDoc "Enable external payload builder.");
+    url = mkOption {
+      type = types.nullOr types.str;
+      default = null;
+      example = "http://localhost:18550/";
+      description = mdDoc "Payload builder URL.";
+    };
+  };
 }
diff --git a/modules/nimbus-eth2/default.nix b/modules/nimbus-eth2/default.nix
index b9707d95..ed041287 100644
--- a/modules/nimbus-eth2/default.nix
+++ b/modules/nimbus-eth2/default.nix
@@ -31,6 +31,16 @@ in {
   ###### implementation
 
   config = mkIf (eachBeacon != {}) {
+    assertions =
+      mapAttrsToList
+      (
+        name: cfg: {
+          assertion = cfg.args.payload-builder.enable -> cfg.args.payload-builder.url != null;
+          message = "services.ethereum.nimbus-eth2.payload-builder must have `url` specified, if enabled";
+        }
+      )
+      eachBeacon;
+
     # configure the firewall for each service
     networking.firewall = let
       openFirewall = filterAttrs (_: cfg: cfg.openFirewall) eachBeacon;
@@ -79,6 +89,11 @@ in {
               then ''--web3-url=${concatStringsSep " --web3-url=" cfg.args.web3-urls}''
               else "";
 
+            payloadBuilder =
+              if cfg.args.payload-builder.enable
+              then "--payload-builder=true --payload-builder-url=${cfg.args.payload-builder.url}"
+              else "";
+
             dataDirPath = "%S/${serviceName}";
             dataDir = ''--data-dir="${dataDirPath}"'';
 
@@ -119,13 +134,14 @@ in {
                   inherit pathReducer;
                 };
               # filter out certain args which need to be treated differently
-              specialArgs = ["--network" "--jwt-secret" "--web3-urls" "--trusted-node-url" "--backfill"];
+              specialArgs = ["--network" "--jwt-secret" "--web3-urls" "--trusted-node-url" "--backfill" "--payload-builder"];
               isNormalArg = name: (findFirst (arg: hasPrefix arg name) null specialArgs) == null;
               filteredArgs = builtins.filter isNormalArg args;
             in ''
               ${network} ${jwtSecret} \
               ${web3Url} \
               ${dataDir} \
+              ${payloadBuilder} \
               ${concatStringsSep " \\\n" filteredArgs} \
               ${lib.escapeShellArgs cfg.extraArgs}
             '';

From 9375c8dd52be9814265c137a914c5b353412e263 Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Fri, 24 Nov 2023 15:10:15 +0200
Subject: [PATCH 19/38] feat(modules/geth): Add influxdb options

---
 modules/geth/args.nix | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/modules/geth/args.nix b/modules/geth/args.nix
index 8d6ed0cd..e6dcde38 100644
--- a/modules/geth/args.nix
+++ b/modules/geth/args.nix
@@ -116,6 +116,27 @@ with lib; {
       default = 6060;
       description = mdDoc "Port number of Go Ethereum metrics service.";
     };
+
+    influxdb = {
+      enable = mkEnableOption (mdDoc "Enable metrics export/push to an external InfluxDB database");
+      endpoint = mkOption {
+        type = types.str;
+        default = "http://127.0.0.1:8086";
+        description = mdDoc "InfluxDB API endpoint to report metrics to.";
+      };
+
+      username = mkOption {
+        type = types.str;
+        default = "geth";
+        description = mdDoc "Username to authorize access to the database.";
+      };
+
+      password = mkOption {
+        type = types.str;
+        default = "test";
+        description = mdDoc "Password to authorize access to the database.";
+      };
+    };
   };
 
   network = mkOption {

From 9be5c9cc99005ac1eac0d3e3463f76b6a316eb4b Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Wed, 29 Nov 2023 12:33:39 +0200
Subject: [PATCH 20/38] feat(modules): Add `holesky` network to `nimbus-eth`
 and `mev-boost`

---
 modules/mev-boost/args.nix   | 2 +-
 modules/nimbus-eth2/args.nix | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/modules/mev-boost/args.nix b/modules/mev-boost/args.nix
index 7b6b92c7..32724e51 100644
--- a/modules/mev-boost/args.nix
+++ b/modules/mev-boost/args.nix
@@ -1,7 +1,7 @@
 lib:
 with lib; {
   network = mkOption {
-    type = types.nullOr (types.enum ["mainnet" "goerli" "sepolia" "zhejiang"]);
+    type = types.nullOr (types.enum ["mainnet" "goerli" "sepolia" "zhejiang" "holesky"]);
     default = null;
     description = mdDoc "The network to connect to. Mainnet (null) is the default ethereum network.";
   };
diff --git a/modules/nimbus-eth2/args.nix b/modules/nimbus-eth2/args.nix
index 75360b4b..0a1b8ae9 100644
--- a/modules/nimbus-eth2/args.nix
+++ b/modules/nimbus-eth2/args.nix
@@ -1,7 +1,7 @@
 lib:
 with lib; {
   network = mkOption {
-    type = types.nullOr (types.enum ["goerli" "prater" "ropsten" "sepolia"]);
+    type = types.nullOr (types.enum ["goerli" "prater" "ropsten" "sepolia" "holesky"]);
     default = null;
     description = mdDoc "The network to connect to. Mainnet (null) is the default ethereum network.";
   };

From 919c877467d7e26e48c186fcb9890d046091f19e Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Wed, 29 Nov 2023 16:52:19 +0200
Subject: [PATCH 21/38] config(packages): Update `mev-boost` packages

---
 packages/mev/mev-boost-builder/default.nix | 2 +-
 packages/mev/mev-boost-relay/default.nix   | 4 ++--
 packages/mev/mev-boost/default.nix         | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/packages/mev/mev-boost-builder/default.nix b/packages/mev/mev-boost-builder/default.nix
index 8bae5423..d79e010e 100644
--- a/packages/mev/mev-boost-builder/default.nix
+++ b/packages/mev/mev-boost-builder/default.nix
@@ -11,7 +11,7 @@ buildGoModule rec {
     owner = "flashbots";
     repo = "${pname}";
     rev = "v${version}";
-    hash = "sha256-5c0a+/dl1/B1PdEMsrUGfjgCE/zZtm6mBNHKBFTyoGc=";
+    hash = "sha256-cP2Wi6vLNSyFvaWnKWPifw+PeABZthA/wjAECtX6OCw=";
   };
 
   vendorHash = "sha256-PwsJjcgPXQuOtXDr4NjF7IEk+nrhDBfEnQQyyBFFSjE=";
diff --git a/packages/mev/mev-boost-relay/default.nix b/packages/mev/mev-boost-relay/default.nix
index 9b2e7910..2869ba73 100644
--- a/packages/mev/mev-boost-relay/default.nix
+++ b/packages/mev/mev-boost-relay/default.nix
@@ -11,10 +11,10 @@ buildGoModule rec {
     owner = "flashbots";
     repo = "${pname}";
     rev = "v${version}";
-    hash = "sha256-SlKx2lsNcOSENl8cgk2nWMe5sFVSHQE5BpF5vYFOG/0=";
+    hash = "sha256-SZ1XMuggGmEe7PQ5K/t6nRSEbi3++kNmlgLHF1+dUqA=";
   };
 
-  vendorHash = "sha256-i9LLqybKHhKSfE39v04rgJ3kZUPscGN+QFXD8ftYO9o=";
+  vendorHash = "sha256-OpxWv5+srcSD/b6SaqQqkdZoRCyIEPIpNH6GUkT2M/Y=";
 
   buildInputs = [blst];
 
diff --git a/packages/mev/mev-boost/default.nix b/packages/mev/mev-boost/default.nix
index 5035c3b8..0a0a3993 100644
--- a/packages/mev/mev-boost/default.nix
+++ b/packages/mev/mev-boost/default.nix
@@ -11,10 +11,10 @@ buildGoModule rec {
     owner = "flashbots";
     repo = "${pname}";
     rev = "v${version}";
-    hash = "sha256-vzgX9irpI5i85bohppyL5KWQuf71SryRu1gkhWSCVKk=";
+    hash = "sha256-NmAOOwyWazJc2xJb9mfVLeuZubwdAIK7+NeFW+AHEEA=";
   };
 
-  vendorHash = "sha256-xw3xVbgKUIDXu4UQD5CGftON8E4o1u2FcrPo3n6APBE=";
+  vendorHash = "sha256-AIgFKav7D+MimRrhYv7EriQIKdml3nGu3sQ4j2fhEb4=";
 
   buildInputs = [blst];
 

From 0b41809efe925753b50e9b433ee3cb010aa91012 Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Wed, 29 Nov 2023 17:08:43 +0200
Subject: [PATCH 22/38] config(packages): Update `nimbus-eth2` package

---
 packages/clients/consensus/nimbus-eth2/default.nix | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/packages/clients/consensus/nimbus-eth2/default.nix b/packages/clients/consensus/nimbus-eth2/default.nix
index a2f005dc..0618c819 100644
--- a/packages/clients/consensus/nimbus-eth2/default.nix
+++ b/packages/clients/consensus/nimbus-eth2/default.nix
@@ -23,14 +23,14 @@
 assert nim.version == "1.6.12" || nim.version == "1.6.14";
   stdenv.mkDerivation rec {
     pname = "nimbus";
-    rev = "v23.10.0";
-    version = "23.10.0";
+    rev = "v23.10.1";
+    version = "23.10.1";
 
     src = fetchFromGitHub {
       owner = "status-im";
       repo = "nimbus-eth2";
       inherit rev;
-      hash = "sha256-eXfHwexoWbrlsXwdNT2TQWlFl526aQfRNxxW6s/khHA=";
+      hash = "sha256-+/AmkgXblg5Gf7VNbVz2uqAs+o2Bol9IIZS3i3t7r94=";
       fetchSubmodules = true;
     };
 

From 8e399316a2f1c5e84d7897ffa63ccb08e1db9e65 Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Thu, 30 Nov 2023 13:08:04 +0200
Subject: [PATCH 23/38] refactor(packages/clients/consensus/nimbus-eth2): Print
 nim version if not compatible

---
 packages/clients/consensus/nimbus-eth2/default.nix | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/packages/clients/consensus/nimbus-eth2/default.nix b/packages/clients/consensus/nimbus-eth2/default.nix
index 0618c819..def4df72 100644
--- a/packages/clients/consensus/nimbus-eth2/default.nix
+++ b/packages/clients/consensus/nimbus-eth2/default.nix
@@ -20,7 +20,11 @@
   ],
 }:
 # Nim version(s) that are known to be stable
-assert nim.version == "1.6.12" || nim.version == "1.6.14";
+assert (
+  lib.assertMsg
+  (nim.version == "1.6.12" || nim.version == "1.6.14")
+  "Unsupported Nim version: ${nim.version}"
+);
   stdenv.mkDerivation rec {
     pname = "nimbus";
     rev = "v23.10.1";

From c416ce55dedf495d630ff749309cbac4e2abfeaf Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Fri, 1 Dec 2023 02:14:05 +0200
Subject: [PATCH 24/38] feat(modules/nimbus-eth2): Add `keymanager` options

---
 modules/nimbus-eth2/args.nix    | 27 +++++++++++++++++++++++++++
 modules/nimbus-eth2/default.nix | 11 ++++++++++-
 2 files changed, 37 insertions(+), 1 deletion(-)

diff --git a/modules/nimbus-eth2/args.nix b/modules/nimbus-eth2/args.nix
index 0a1b8ae9..e1105837 100644
--- a/modules/nimbus-eth2/args.nix
+++ b/modules/nimbus-eth2/args.nix
@@ -135,4 +135,31 @@ with lib; {
       description = mdDoc "Payload builder URL.";
     };
   };
+
+  keymanager = {
+    enable = lib.mkEnableOption (mdDoc "Enable the REST keymanager API");
+    address = mkOption {
+      type = types.str;
+      default = "127.0.0.1";
+      description = mdDoc "Listening port for the REST keymanager API.";
+    };
+
+    port = mkOption {
+      type = types.port;
+      default = 5052;
+      description = mdDoc "Listening port for the REST keymanager API.";
+    };
+
+    allow-origin = mkOption {
+      type = types.nullOr types.str;
+      default = null;
+      description = mdDoc "Limit the access to the Keymanager API to a particular hostname (for CORS-enabled clients such as browsers).";
+    };
+
+    token-file = mkOption {
+      type = types.nullOr types.path;
+      default = null;
+      description = mdDoc "A file specifying the authorization token required for accessing the keymanager API.";
+    };
+  };
 }
diff --git a/modules/nimbus-eth2/default.nix b/modules/nimbus-eth2/default.nix
index ed041287..1805ba42 100644
--- a/modules/nimbus-eth2/default.nix
+++ b/modules/nimbus-eth2/default.nix
@@ -74,6 +74,11 @@ in {
               then ''--jwt-secret="%d/jwt-secret"''
               else "";
 
+            keymanagerTokenFile =
+              if cfg.args.keymanager.token-file != null
+              then ''--keymanager-token-file="%d/keymanager-token-file"''
+              else "";
+
             trustedNodeUrl =
               if cfg.args.trusted-node-url != null
               then ''--trusted-node-url="${cfg.args.trusted-node-url}"''
@@ -134,13 +139,14 @@ in {
                   inherit pathReducer;
                 };
               # filter out certain args which need to be treated differently
-              specialArgs = ["--network" "--jwt-secret" "--web3-urls" "--trusted-node-url" "--backfill" "--payload-builder"];
+              specialArgs = ["--network" "--jwt-secret" "--web3-urls" "--trusted-node-url" "--backfill" "--payload-builder" "--keymanager-token-file"];
               isNormalArg = name: (findFirst (arg: hasPrefix arg name) null specialArgs) == null;
               filteredArgs = builtins.filter isNormalArg args;
             in ''
               ${network} ${jwtSecret} \
               ${web3Url} \
               ${dataDir} \
+              ${keymanagerTokenFile} \
               ${payloadBuilder} \
               ${concatStringsSep " \\\n" filteredArgs} \
               ${lib.escapeShellArgs cfg.extraArgs}
@@ -193,6 +199,9 @@ in {
                 (mkIf (cfg.args.jwt-secret != null) {
                   LoadCredential = ["jwt-secret:${cfg.args.jwt-secret}"];
                 })
+                (mkIf (cfg.args.keymanager.token-file != null) {
+                  LoadCredential = ["keymanager-token-file:${cfg.args.keymanager.token-file}"];
+                })
               ];
             })
       )

From b4226c1baccd01636d2b4232d6570d79aab4b4e7 Mon Sep 17 00:00:00 2001
From: Petar Kirov <petar.p.kirov@gmail.com>
Date: Wed, 13 Dec 2023 12:21:31 +0200
Subject: [PATCH 25/38] build(packages/clients/consensus/nimbus-eth2): Ensure
 Nim 1.6 is used

In newer versions of `nixpkgs-unstable` the `nim` package points to
`2.0.0`. A new package `nim1` has been added for backwards
compatibility.

Since we can't be sure with what version of nixpkgs-unstable we will be
instantiated fallback to `nim` if `nim1` does not exist.
---
 packages/clients/consensus/nimbus-eth2/default.nix | 3 ++-
 packages/default.nix                               | 8 +++++++-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/packages/clients/consensus/nimbus-eth2/default.nix b/packages/clients/consensus/nimbus-eth2/default.nix
index def4df72..cf3de2f1 100644
--- a/packages/clients/consensus/nimbus-eth2/default.nix
+++ b/packages/clients/consensus/nimbus-eth2/default.nix
@@ -20,9 +20,10 @@
   ],
 }:
 # Nim version(s) that are known to be stable
+# See: https://github.com/status-im/nimbus-build-system/commits/master/vendor
 assert (
   lib.assertMsg
-  (nim.version == "1.6.12" || nim.version == "1.6.14")
+  (builtins.elem nim.version ["1.6.12" "1.6.14" "1.6.16" "1.6.18"])
   "Unsupported Nim version: ${nim.version}"
 );
   stdenv.mkDerivation rec {
diff --git a/packages/default.nix b/packages/default.nix
index ccfca9a3..df8990a2 100644
--- a/packages/default.nix
+++ b/packages/default.nix
@@ -28,7 +28,13 @@
       prysm = callPackage ./clients/consensus/prysm {inherit bls blst;};
       teku = callPackage ./clients/consensus/teku {};
       nimbus = callPackageUnstable ./clients/consensus/nimbus {};
-      nimbus-eth2 = callPackageUnstable ./clients/consensus/nimbus-eth2 {};
+      nimbus-eth2 = callPackageUnstable ./clients/consensus/nimbus-eth2 {
+        # For now the nimbus team prefers nim 1.6 over 2.0.
+        # In newer versions of `pkgsUnstable` `nim` points to v2.0.0 in older it is 1.6.
+        # In newer versions the `nim1` package exists but not in older.
+        # See: https://github.com/status-im/nimbus-build-system/commits/master/vendor
+        nim = pkgsUnstable.nim1 or pkgsUnstable.nim;
+      };
 
       # Execution Clients
       erigon = callPackage ./clients/execution/erigon {};

From 2539fd5c3d56cf167936349875b22c0a6d322585 Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Fri, 12 Jan 2024 14:28:10 +0200
Subject: [PATCH 26/38] update(packages/nimbus-eth2): Update `nimbus-eth2` to
 v24.1.1

---
 packages/clients/consensus/nimbus-eth2/default.nix | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/packages/clients/consensus/nimbus-eth2/default.nix b/packages/clients/consensus/nimbus-eth2/default.nix
index cf3de2f1..60f300e4 100644
--- a/packages/clients/consensus/nimbus-eth2/default.nix
+++ b/packages/clients/consensus/nimbus-eth2/default.nix
@@ -28,14 +28,14 @@ assert (
 );
   stdenv.mkDerivation rec {
     pname = "nimbus";
-    rev = "v23.10.1";
-    version = "23.10.1";
+    rev = "v24.1.1";
+    version = "24.1.1";
 
     src = fetchFromGitHub {
       owner = "status-im";
       repo = "nimbus-eth2";
       inherit rev;
-      hash = "sha256-+/AmkgXblg5Gf7VNbVz2uqAs+o2Bol9IIZS3i3t7r94=";
+      hash = "sha256-euKLjVw9f2AzdR9YF4UOIerpjWewTVTvaasXxNQgoq0=";
       fetchSubmodules = true;
     };
 

From 22e3a1b1724f754a3fdbdd2b7a02b909d861e1cc Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Fri, 12 Jan 2024 16:16:25 +0200
Subject: [PATCH 27/38] fix(packages/mev-boost): Hash mismatch

---
 packages/mev/mev-boost/default.nix | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/mev/mev-boost/default.nix b/packages/mev/mev-boost/default.nix
index 0a0a3993..5035c3b8 100644
--- a/packages/mev/mev-boost/default.nix
+++ b/packages/mev/mev-boost/default.nix
@@ -11,10 +11,10 @@ buildGoModule rec {
     owner = "flashbots";
     repo = "${pname}";
     rev = "v${version}";
-    hash = "sha256-NmAOOwyWazJc2xJb9mfVLeuZubwdAIK7+NeFW+AHEEA=";
+    hash = "sha256-vzgX9irpI5i85bohppyL5KWQuf71SryRu1gkhWSCVKk=";
   };
 
-  vendorHash = "sha256-AIgFKav7D+MimRrhYv7EriQIKdml3nGu3sQ4j2fhEb4=";
+  vendorHash = "sha256-xw3xVbgKUIDXu4UQD5CGftON8E4o1u2FcrPo3n6APBE=";
 
   buildInputs = [blst];
 

From 1a877865499e1dd4077350347c468ed2ccafee6b Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Fri, 12 Jan 2024 17:08:05 +0200
Subject: [PATCH 28/38] feat(modules/nimbus-eth2): Add `web3-signer-url` option

---
 modules/nimbus-eth2/args.nix | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/modules/nimbus-eth2/args.nix b/modules/nimbus-eth2/args.nix
index e1105837..a50097b0 100644
--- a/modules/nimbus-eth2/args.nix
+++ b/modules/nimbus-eth2/args.nix
@@ -106,6 +106,13 @@ with lib; {
     };
   };
 
+  web3-signer-url = mkOption {
+    type = types.nullOr types.str;
+    default = null;
+    example = "http://localhost:9000/";
+    description = mdDoc "Remote Web3Signer URL that will be used as a source of validators.";
+  };
+
   web3-urls = mkOption {
     type = types.listOf types.str;
     default = [];

From 9f497c49ead26787fdec44b858aff463bc31a5b5 Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Fri, 12 Jan 2024 18:02:49 +0200
Subject: [PATCH 29/38] config(modules/geth): Add `snapshot` option

---
 modules/geth/args.nix | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/modules/geth/args.nix b/modules/geth/args.nix
index e6dcde38..8737fcfe 100644
--- a/modules/geth/args.nix
+++ b/modules/geth/args.nix
@@ -206,4 +206,10 @@ with lib; {
     default = false;
     description = mdDoc "Enable the IPC-RPC server";
   };
+
+  snapshot = mkOption {
+    type = types.bool;
+    default = true;
+    description = mdDoc "Enables snapshot-database mode";
+  };
 }

From b7d60bbf88af10c09e00ab5599003403b018e9fd Mon Sep 17 00:00:00 2001
From: Zahary Karadjov <zahary@gmail.com>
Date: Sun, 14 Jan 2024 01:37:02 +0200
Subject: [PATCH 30/38] update(web3signer): version 24.1.0

---
 packages/signers/web3signer/default.nix | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/signers/web3signer/default.nix b/packages/signers/web3signer/default.nix
index 956d0a26..2de6eb18 100644
--- a/packages/signers/web3signer/default.nix
+++ b/packages/signers/web3signer/default.nix
@@ -7,11 +7,11 @@
 }:
 stdenv.mkDerivation rec {
   pname = "web3signer";
-  version = "23.9.1";
+  version = "24.1.0";
 
   src = fetchzip {
     url = "https://artifacts.consensys.net/public/${pname}/raw/names/${pname}.tar.gz/versions/${version}/${pname}-${version}.tar.gz";
-    hash = "sha256-2Dz8GFAjpI0mkikckXzrCVu/3XUTNh90F2hoa9FKhJQ=";
+    hash = "sha256-8xkALHtk2U4HpLwfpO0ecFBJsYDpqjuJsKzOWr6dGZY=";
   };
 
   nativeBuildInputs = [makeWrapper];

From b68b57fd9f3063f3c0950343c64ed9850825fcd6 Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Mon, 15 Jan 2024 17:38:05 +0200
Subject: [PATCH 31/38] config(modules/geth): Set `ProcSubset` to `all`

Pruning fails and errors are thrown in the most recent version (1.13.10) when `ProcSubset` is set to `pid`, as in lib.nix
---
 modules/geth/default.nix | 1 +
 1 file changed, 1 insertion(+)

diff --git a/modules/geth/default.nix b/modules/geth/default.nix
index 3ea7a85f..3748d1ac 100644
--- a/modules/geth/default.nix
+++ b/modules/geth/default.nix
@@ -126,6 +126,7 @@ in {
               serviceConfig = mkMerge [
                 baseServiceConfig
                 {
+                  ProcSubset = "all";
                   User = serviceName;
                   StateDirectory = serviceName;
                   ExecStart = "${cfg.package}/bin/geth ${scriptArgs}";

From bc188c8b1aef7910f287a289fcd6aa5d6081eb2e Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Tue, 16 Jan 2024 11:18:49 +0200
Subject: [PATCH 32/38] config(modules/geth): Change default influxdb settings
 value to `null`

---
 modules/geth/args.nix | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/modules/geth/args.nix b/modules/geth/args.nix
index 8737fcfe..b69d3d96 100644
--- a/modules/geth/args.nix
+++ b/modules/geth/args.nix
@@ -120,20 +120,20 @@ with lib; {
     influxdb = {
       enable = mkEnableOption (mdDoc "Enable metrics export/push to an external InfluxDB database");
       endpoint = mkOption {
-        type = types.str;
-        default = "http://127.0.0.1:8086";
+        type = types.nullOr types.str;
+        default = null;
         description = mdDoc "InfluxDB API endpoint to report metrics to.";
       };
 
       username = mkOption {
-        type = types.str;
-        default = "geth";
+        type = types.nullOr types.str;
+        default = null;
         description = mdDoc "Username to authorize access to the database.";
       };
 
       password = mkOption {
-        type = types.str;
-        default = "test";
+        type = types.nullOr types.str;
+        default = null;
         description = mdDoc "Password to authorize access to the database.";
       };
     };

From be8233ece8dee54e262ec3bde1d0f30c880025d8 Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Wed, 17 Jan 2024 16:01:03 +0200
Subject: [PATCH 33/38] feat(modules/geth): Add `discovery.port` option

---
 modules/geth/args.nix | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/modules/geth/args.nix b/modules/geth/args.nix
index b69d3d96..0c72a36d 100644
--- a/modules/geth/args.nix
+++ b/modules/geth/args.nix
@@ -212,4 +212,12 @@ with lib; {
     default = true;
     description = mdDoc "Enables snapshot-database mode";
   };
+
+  discovery = {
+    port = mkOption {
+      type = types.port;
+      default = 30303;
+      description = mdDoc "Use a custom UDP port for P2P discovery.";
+    };
+  };
 }

From c80fc15bd48310fd0cf825742e3fcf68df3ce366 Mon Sep 17 00:00:00 2001
From: Petar Kirov <petar.p.kirov@gmail.com>
Date: Thu, 18 Jan 2024 16:36:53 +0200
Subject: [PATCH 34/38] build(pkgs/geth): Enable on `x86_64-darwin` and
 `aarch64-darwin` platforms

---
 packages/clients/execution/geth/default.nix | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/clients/execution/geth/default.nix b/packages/clients/execution/geth/default.nix
index f582f624..a48111f7 100644
--- a/packages/clients/execution/geth/default.nix
+++ b/packages/clients/execution/geth/default.nix
@@ -64,6 +64,6 @@ in
       homepage = "https://geth.ethereum.org/";
       license = with licenses; [lgpl3Plus gpl3Plus];
       mainProgram = "geth";
-      platforms = ["x86_64-linux" "aarch64-linux"];
+      platforms = ["x86_64-linux" "aarch64-linux" "x86_64-darwin" "aarch64-darwin"];
     };
   }

From cc458b501c923e8ffd534d415915e6e2fe0e00b4 Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Thu, 18 Jan 2024 20:11:49 +0200
Subject: [PATCH 35/38] config(modules/baseServiceConfig): Revert
 ProcSubset=pid (default is all)

`ProcSubset=pid` causes various problems for both nimbus and geth
(and possibly other services), so it's better to revert that change.
---
 modules/geth/default.nix | 1 -
 modules/lib.nix          | 1 -
 2 files changed, 2 deletions(-)

diff --git a/modules/geth/default.nix b/modules/geth/default.nix
index 3748d1ac..3ea7a85f 100644
--- a/modules/geth/default.nix
+++ b/modules/geth/default.nix
@@ -126,7 +126,6 @@ in {
               serviceConfig = mkMerge [
                 baseServiceConfig
                 {
-                  ProcSubset = "all";
                   User = serviceName;
                   StateDirectory = serviceName;
                   ExecStart = "${cfg.package}/bin/geth ${scriptArgs}";
diff --git a/modules/lib.nix b/modules/lib.nix
index 217bd673..c8d6c6f2 100644
--- a/modules/lib.nix
+++ b/modules/lib.nix
@@ -81,7 +81,6 @@ lib: let
     #   * ProtectHome = "read-only"
     DynamicUser = mkDefault true;
 
-    ProcSubset = mkDefault "pid";
     ProtectClock = mkDefault true;
     ProtectProc = mkDefault "noaccess";
     ProtectKernelLogs = mkDefault true;

From cab50ad236e94393345646ff537debbc4941dd40 Mon Sep 17 00:00:00 2001
From: monyarm <monyarm@gmail.com>
Date: Mon, 22 Jan 2024 12:57:26 +0200
Subject: [PATCH 36/38] update(nethermind): 1.19.3 -> 1.25.1

---
 .../clients/execution/nethermind/default.nix  |   17 +-
 .../execution/nethermind/nuget-deps.nix       | 2831 +++--------------
 packages/default.nix                          |    2 +-
 3 files changed, 476 insertions(+), 2374 deletions(-)

diff --git a/packages/clients/execution/nethermind/default.nix b/packages/clients/execution/nethermind/default.nix
index a0afa576..c497c806 100644
--- a/packages/clients/execution/nethermind/default.nix
+++ b/packages/clients/execution/nethermind/default.nix
@@ -12,13 +12,13 @@
 }: let
   self = buildDotnetModule rec {
     pname = "nethermind";
-    version = "1.19.3";
+    version = "1.25.1";
 
     src = fetchFromGitHub {
       owner = "NethermindEth";
       repo = pname;
       rev = version;
-      hash = "sha256-vqcgBT7kSyrgRl2hLehbCjsQ/AC4+a3LMOdAcmcNOFo=";
+      hash = "sha256-h46+cM20e5ztBSdimOR39tcNcG9/RU1NY/lS8Rwm9Xs=";
       fetchSubmodules = true;
     };
 
@@ -29,6 +29,9 @@
       zstd
     ];
 
+    fakeGit = writeShellScriptBin "git" "echo ${version}";
+    nativeBuildInputs = [fakeGit];
+
     runtimeDeps = [
       rocksdb
       snappy
@@ -42,12 +45,12 @@
     nugetDeps = ./nuget-deps.nix;
 
     executables = [
-      "Nethermind.Cli"
-      "Nethermind.Runner"
+      "nethermind-cli"
+      "nethermind"
     ];
 
-    dotnet-sdk = dotnetCorePackages.sdk_7_0;
-    dotnet-runtime = dotnetCorePackages.aspnetcore_7_0;
+    dotnet-sdk = dotnetCorePackages.sdk_8_0;
+    dotnet-runtime = dotnetCorePackages.aspnetcore_8_0;
 
     passthru = rec {
       # buildDotnetModule's `fetch-deps` uses `writeShellScript` instead of writeShellScriptBin making nix run .#nethermind.fetch-deps command to fail
@@ -60,7 +63,7 @@
       description = "Our flagship Ethereum client for Linux, Windows, and macOS—full and actively developed";
       homepage = "https://nethermind.io/nethermind-client";
       license = lib.licenses.gpl3;
-      mainProgram = "Nethermind.Runner";
+      mainProgram = "nethermind";
       platforms = ["x86_64-linux"];
     };
   };
diff --git a/packages/clients/execution/nethermind/nuget-deps.nix b/packages/clients/execution/nethermind/nuget-deps.nix
index 3436daa0..cde2a0d7 100644
--- a/packages/clients/execution/nethermind/nuget-deps.nix
+++ b/packages/clients/execution/nethermind/nuget-deps.nix
@@ -1,2369 +1,468 @@
 # This file was automatically generated by passthru.fetch-deps.
 # Please dont edit it manually, your changes might get overwritten!
-{fetchNuGet}: [
-  (fetchNuGet {
-    pname = "Antlr4.Runtime.Standard";
-    version = "4.11.1";
-    sha256 = "0mp0ydgdqnf1g8v5ll9ifay4xc2hv9grky1qlzrmkfi7wscpas5a";
-  })
-  (fetchNuGet {
-    pname = "AspNetCore.HealthChecks.UI";
-    version = "6.0.5";
-    sha256 = "0b3bgmfa6y6qrygn3ml3hnwycx6r09kv4h0wrwk2jxr9a8daw7vf";
-  })
-  (fetchNuGet {
-    pname = "AspNetCore.HealthChecks.UI.Client";
-    version = "6.0.5";
-    sha256 = "09s5z1m501jmki7983laid5dgkrm1qgdx4ljawv52dn1npgh8vzm";
-  })
-  (fetchNuGet {
-    pname = "AspNetCore.HealthChecks.UI.Core";
-    version = "6.0.5";
-    sha256 = "07hkiw81kw8281rgnvwqm0202pmk1mxgy7n2dzh5fx5fn10vdy2a";
-  })
-  (fetchNuGet {
-    pname = "AspNetCore.HealthChecks.UI.InMemory.Storage";
-    version = "6.0.5";
-    sha256 = "04djdw7mhch2j9ahxd26fgzn3c3lxyhnyrvsjqvsmgm1dkqwimcs";
-  })
-  (fetchNuGet {
-    pname = "AutoMapper";
-    version = "9.0.0";
-    sha256 = "1dv0p7h470nb733yqjjqf0ng3axzrl4vshr2npqkzwp2mfv90lsb";
-  })
-  (fetchNuGet {
-    pname = "Castle.Core";
-    version = "5.0.0";
-    sha256 = "1f6qd0zy4s3dvi4f3sp9f3fx25rj16sib9hcha456z8i5nrlnix3";
-  })
-  (fetchNuGet {
-    pname = "Ckzg.Bindings";
-    version = "0.1.2.402";
-    sha256 = "02l53ha8sim50y8hrlz0vnfmg6h7lwcya14s8pagj6jihcwsqpzd";
-  })
-  (fetchNuGet {
-    pname = "Colorful.Console";
-    version = "1.2.15";
-    sha256 = "03g8367lchh42jn6iidj10dnlibr8wlbdarsx7zanp3f4z7lf4rw";
-  })
-  (fetchNuGet {
-    pname = "ConcurrentHashSet";
-    version = "1.3.0";
-    sha256 = "04jydfpzv1pwn60m23fl3qgdsvmcd2nrnn68rviixc031j7bhgp6";
-  })
-  (fetchNuGet {
-    pname = "coverlet.collector";
-    version = "3.2.0";
-    sha256 = "1qxpv8v10p5wn162lzdm193gdl6c5f81zadj8h889dprlnj3g8yr";
-  })
-  (fetchNuGet {
-    pname = "coverlet.msbuild";
-    version = "3.2.0";
-    sha256 = "0lyw70xgri3jqxzd06s077p8wymislljsyrsyn081pb0xc20vd00";
-  })
-  (fetchNuGet {
-    pname = "Crc32.NET";
-    version = "1.2.0";
-    sha256 = "0qaj3192k1vfji87zf50rhydn5mrzyzybrs2k4v7ap29k8i0vi5h";
-  })
-  (fetchNuGet {
-    pname = "DiffEngine";
-    version = "10.0.0";
-    sha256 = "1ra8kj3ax6phmz5312zpasw6zwvrm1fw34fsyah2bx0anmhiqhrf";
-  })
-  (fetchNuGet {
-    pname = "DnsClient";
-    version = "1.7.0";
-    sha256 = "0q6sl7nrwks1xl23z0r097g7b95d0j59r08c21dpbf13fyai9mw5";
-  })
-  (fetchNuGet {
-    pname = "dotnet-xunit";
-    version = "2.3.1";
-    sha256 = "0w1zslkig6qk6rhw6ckfy331rnbfbnxr0gdy2pxgnc8rz2fj2s54";
-  })
-  (fetchNuGet {
-    pname = "EmptyFiles";
-    version = "2.8.0";
-    sha256 = "0lxx4qxhf41c1yjz0pn73n0xd536zi1cx5d5j6bmgg6jlz8646sj";
-  })
-  (fetchNuGet {
-    pname = "FastEnum";
-    version = "1.8.0";
-    sha256 = "0czqiqq7v02977wy0mr33z06xlfnw805s3051sqqvacil1n4adcv";
-  })
-  (fetchNuGet {
-    pname = "FluentAssertions";
-    version = "6.0.0";
-    sha256 = "1p5m89rbaqbrn8vr3bs79j8fcdhasn6n3bcxhajp2f5p4mpzv83f";
-  })
-  (fetchNuGet {
-    pname = "FluentAssertions";
-    version = "6.10.0";
-    sha256 = "0agw9snp59hzsdy8plwj6byiy20xd5l3zx5627yn44m4lh8md17q";
-  })
-  (fetchNuGet {
-    pname = "FluentAssertions.Json";
-    version = "6.1.0";
-    sha256 = "0mski8r35y4kp0r2q66v5zjck476xccqvaky77kcpjyf8vmbc5d6";
-  })
-  (fetchNuGet {
-    pname = "Fractions";
-    version = "4.0.1";
-    sha256 = "0mdfpxqxh5ldiv8pfizs5pd4in0lqcpc4mnqqpx6fi7vmkcnl04p";
-  })
-  (fetchNuGet {
-    pname = "FSharp.Core";
-    version = "6.0.2";
-    sha256 = "0q4z31i6vw38b6anwjfzxy3ncdazymddi1xyfskkb0s4744ilpi5";
-  })
-  (fetchNuGet {
-    pname = "Google.Protobuf";
-    version = "3.22.0";
-    sha256 = "1wjxxlqdrjjb0f3py8sbgsivqms8d22m7xk1zx68gfmyih671in7";
-  })
-  (fetchNuGet {
-    pname = "Google.Protobuf.Tools";
-    version = "3.22.0";
-    sha256 = "19sq1zxfv05vx0lrnbnfzg3r1s4j4kcig8z0bnw2jjhcqna3ia60";
-  })
-  (fetchNuGet {
-    pname = "Grpc";
-    version = "2.46.6";
-    sha256 = "1zj2j7h97qdns14z3ilfgqx3kir9p5a05kwsvyz3hpnx2z6j3ysj";
-  })
-  (fetchNuGet {
-    pname = "Grpc.Core";
-    version = "2.46.6";
-    sha256 = "1lyy2l8xxjnfvrf9jxdffms70qqjlz41s0k3y53w637n5qif7hgz";
-  })
-  (fetchNuGet {
-    pname = "Grpc.Core.Api";
-    version = "2.46.6";
-    sha256 = "1c5h83h2snvwvdzyiinqcls01jx87n7jgma3mvhhv01j2q8qqfhy";
-  })
-  (fetchNuGet {
-    pname = "Grpc.Tools";
-    version = "2.51.0";
-    sha256 = "016rs4gz85hnbz6bzymgy7mra08782v3j3lz8b6jq60w0543ngx9";
-  })
-  (fetchNuGet {
-    pname = "Humanizer.Core";
-    version = "2.8.26";
-    sha256 = "1v8xd12yms4qq1md4vh6faxicmqrvahqdd7sdkyzrphab9v44nsm";
-  })
-  (fetchNuGet {
-    pname = "IdentityModel";
-    version = "4.1.0";
-    sha256 = "1mpidh18f780g9hrmr7qfzfv2navh7kl0pn107vs74bcl0h1d6x4";
-  })
-  (fetchNuGet {
-    pname = "IdentityModel.OidcClient";
-    version = "3.1.2";
-    sha256 = "008h1k9lyxg3a96ixz4k348z2d9sc7f0r2f64maw3j96mkimp2yc";
-  })
-  (fetchNuGet {
-    pname = "Jint";
-    version = "2.11.58";
-    sha256 = "1nw3mbr1sl198lkwl6bsnfajd3rgw83p63vgi1dackfvx6haywnv";
-  })
-  (fetchNuGet {
-    pname = "KubernetesClient";
-    version = "4.0.26";
-    sha256 = "16sk8vya2238yxsbz99dsi74vfvdri51n03k589b0z80738r4mvj";
-  })
-  (fetchNuGet {
-    pname = "Libuv";
-    version = "1.9.0";
-    sha256 = "0ag6l9h1h4knf3hy1fjfrqm6mavr9zw35i0qrnnm8la4mdbcnd0f";
-  })
-  (fetchNuGet {
-    pname = "MathNet.Numerics";
-    version = "5.0.0";
-    sha256 = "0nlrl0rp7h665nafx0g42rqfxmm0pyvk3ydr2y4spilfrra44wj4";
-  })
-  (fetchNuGet {
-    pname = "MathNet.Numerics.FSharp";
-    version = "5.0.0";
-    sha256 = "06x8ppnzlzmb1gswvygqp8n7x0p1jpx76f7g29h30ck6jzqf3xm4";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.AspNetCore.Cryptography.Internal";
-    version = "7.0.3";
-    sha256 = "04vxj2m5crxmh9q8k1x0yc1bx85yqicdsj6q4q6fq6jgx0rkk3pi";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.AspNetCore.DataProtection";
-    version = "7.0.3";
-    sha256 = "02z4v4xwidwlp24gmlphnlh7wibzd622frgmpjcsz2j9xpk3ga5y";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.AspNetCore.DataProtection.Abstractions";
-    version = "7.0.3";
-    sha256 = "1r8csi3zslv1xl7rpnjh97zf88lf653qsai6njsa3jw3icyxbqln";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.AspNetCore.DataProtection.Extensions";
-    version = "7.0.3";
-    sha256 = "0wf97vbm4y78zd4zhwx8gj6jq7mp0ri1ddjwj2icfa3jn9m7cwwd";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.AspNetCore.Http.Abstractions";
-    version = "2.2.0";
-    sha256 = "13s8cm6jdpydxmr0rgmzrmnp1v2r7i3rs7v9fhabk5spixdgfy6b";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.AspNetCore.Http.Extensions";
-    version = "2.2.0";
-    sha256 = "118gp1mfb8ymcvw87fzgjqwlc1d1b0l0sbfki291ydg414cz3dfn";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.AspNetCore.Http.Features";
-    version = "2.2.0";
-    sha256 = "0xrlq8i61vzhzzy25n80m7wh2kn593rfaii3aqnxdsxsg6sfgnx1";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.AspNetCore.WebSockets";
-    version = "2.2.1";
-    sha256 = "0gzikr1z2fdz8nzy1m969jsrk2h97ld1hzgmbc6f036qmhiq26hr";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Bcl.AsyncInterfaces";
-    version = "6.0.0";
-    sha256 = "15gqy2m14fdlvy1g59207h5kisznm355kbw010gy19vh47z8gpz3";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.CodeAnalysis.Analyzers";
-    version = "1.1.0";
-    sha256 = "08r667hj2259wbim1p3al5qxkshydykmb7nd9ygbjlg4mmydkapc";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.CodeAnalysis.Common";
-    version = "1.3.0";
-    sha256 = "097qi36jhyllpqj313nxzwc64a4f65p014gaj6fz4z5jcphkkk15";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.CodeAnalysis.CSharp";
-    version = "1.3.0";
-    sha256 = "0vpslncd5lk88ijb42qbp88dfrd0fg4kri44w6jpmxb3fcqazais";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.CodeAnalysis.VisualBasic";
-    version = "1.3.0";
-    sha256 = "186chky80rryhzh5dh8j318ghyvn1a7r2876rlyadxdrs7aqv0ll";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.CodeCoverage";
-    version = "17.4.1";
-    sha256 = "0bf68gq6mc6kzri4zi8ydc0xrazqwqg38bhbpjpj90zmqc28kari";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.CSharp";
-    version = "4.0.1";
-    sha256 = "0zxc0apx1gcx361jlq8smc9pfdgmyjh6hpka8dypc9w23nlsh6yj";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.CSharp";
-    version = "4.3.0";
-    sha256 = "0gw297dgkh0al1zxvgvncqs0j15lsna9l1wpqas4rflmys440xvb";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.CSharp";
-    version = "4.5.0";
-    sha256 = "01i28nvzccxbqmiz217fxs6hnjwmd5fafs37rd49a6qp53y6623l";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.CSharp";
-    version = "4.7.0";
-    sha256 = "0gd67zlw554j098kabg887b5a6pq9kzavpa3jjy5w53ccjzjfy8j";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Data.Sqlite.Core";
-    version = "2.0.0-preview1-final";
-    sha256 = "0zxd5xy2qfbjgwx0q7xgagmxsacgfwqk5y0rah0dirv7fngpjbq1";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Data.Sqlite.Core";
-    version = "6.0.7";
-    sha256 = "0r5njqyl10dv0akwl5y32ik0rpzs9lwj151j6ayz358pn4x26akk";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.EntityFrameworkCore";
-    version = "6.0.7";
-    sha256 = "1wcjjn70v8cyy5flga0nlnhg973s6pzb3rpnzv905ix3g70zdp4k";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.EntityFrameworkCore.Abstractions";
-    version = "6.0.7";
-    sha256 = "0xhkh9k3xpgjdsizg1wdncwz4rdjvffq3x0sfcarscmg2j5fa4yj";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.EntityFrameworkCore.Analyzers";
-    version = "6.0.7";
-    sha256 = "0fdh0w5c51kkpvh1p5f0dn90kikh3zdyc1k4hjvv1z8kr603nd1b";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.EntityFrameworkCore.Design";
-    version = "6.0.7";
-    sha256 = "0mdb2gqmb94sw38cpqm972vdhh88n7q81xhq4gq771hp2wspn5ap";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.EntityFrameworkCore.InMemory";
-    version = "6.0.7";
-    sha256 = "1bjgb8yzpl0qlkz172n3v5ihqjmy8hlirf0ffc05g3i0nlx1cl2j";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.EntityFrameworkCore.Relational";
-    version = "2.0.0-preview1-final";
-    sha256 = "040pmi5qxqrjaxkqxivsxxly2vxxidbyqsjp4b6lgzwv442ybxvs";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.EntityFrameworkCore.Relational";
-    version = "6.0.7";
-    sha256 = "1kx0ac7jgf8nmp5nra4cd6h2xbwvb3zkyzx7cds60y1j9nm7lx1g";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.EntityFrameworkCore.Relational.Design";
-    version = "2.0.0-preview1-final";
-    sha256 = "0fk2nvkayx7n2c9ch8jby63a11x5hmzxria6waxgx88kg16x8748";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.EntityFrameworkCore.Sqlite";
-    version = "6.0.7";
-    sha256 = "1mam4qg6yq6qnlkx3i45gs3nwgd7njfm9r5gjs1p9wm6bm953dad";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.EntityFrameworkCore.Sqlite.Core";
-    version = "2.0.0-preview1-final";
-    sha256 = "1dfqs2w1m3lsxn6cyqpfbsianafig19wf4ra16vd4aflzck8bq3l";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.EntityFrameworkCore.Sqlite.Core";
-    version = "6.0.7";
-    sha256 = "15l36dgq6rzvgx7i9g9jm3298p9g1pdahwa2dxblmm0gzsp65wpl";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.EntityFrameworkCore.Sqlite.Design";
-    version = "2.0.0-preview1-final";
-    sha256 = "1cn9gqvq0p5rin9dzly3h2s2z0vadbw3yp7wlsga9ql2na4slc8a";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Caching.Abstractions";
-    version = "6.0.0";
-    sha256 = "0qn30d3pg4rx1x2k525jj4x5g1fxm2v5m0ksz2dmk1gmqalpask8";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Caching.Memory";
-    version = "6.0.1";
-    sha256 = "0ra0ldbg09r40jzvfqhpb3h42h80nafvka9hg51dja32k3mxn5gk";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.CommandLineUtils";
-    version = "1.1.1";
-    sha256 = "0g61kphvdira64g543qlf610sia02scdmki1566d5kr6v390qvbq";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Configuration";
-    version = "2.1.0";
-    sha256 = "04rjl38wlr1jjjpbzgf64jp0ql6sbzbil0brwq9mgr3hdgwd7vx2";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Configuration";
-    version = "3.1.0";
-    sha256 = "1rszgz0rd5kvib5fscz6ss3pkxyjwqy0xpd4f2ypgzf5z5g5d398";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Configuration";
-    version = "7.0.0";
-    sha256 = "0n1grglxql9llmrsbbnlz5chx8mxrb5cpvjngm0hfyrkgzcwz90d";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Configuration.Abstractions";
-    version = "2.1.0";
-    sha256 = "03gzlr3z9j1xnr1k6y91zgxpz3pj27i3zsvjwj7i8jqnlqmk7pxd";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Configuration.Abstractions";
-    version = "3.1.0";
-    sha256 = "1f7h52kamljglx5k08ccryilvk6d6cvr9c26lcb6b2c091znzk0q";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Configuration.Abstractions";
-    version = "6.0.0";
-    sha256 = "0w6wwxv12nbc3sghvr68847wc9skkdgsicrz3fx4chgng1i3xy0j";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Configuration.Abstractions";
-    version = "7.0.0";
-    sha256 = "1as8cygz0pagg17w22nsf6mb49lr2mcl1x8i3ad1wi8lyzygy1a3";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Configuration.Binder";
-    version = "2.1.0";
-    sha256 = "0x1888w5ypavvszfmpja9krgc64527prs75vm8xbf9fv3rgsplql";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Configuration.Binder";
-    version = "3.1.0";
-    sha256 = "13jj7jxihiswmhmql7r5jydbca4x5qj6h7zq10z17gagys6dc7pw";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Configuration.Binder";
-    version = "7.0.0";
-    sha256 = "1qifb1pv7s76lih8wnjk418wdk4qwn87q2n6dx54knfvxai410bl";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.DependencyInjection";
-    version = "3.1.0";
-    sha256 = "1xc61dy07bn2q73mx1z3ylrw80xpa682qjby13gklnqq636a3gab";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.DependencyInjection";
-    version = "5.0.0";
-    sha256 = "15sdwcyzz0qlybwbdq854bn3jk6kx7awx28gs864c4shhbqkppj4";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.DependencyInjection";
-    version = "6.0.0";
-    sha256 = "1wlhb2vygzfdjbdzy7waxblmrx0q3pdcqvpapnpmq9fcx5m8r6w1";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.DependencyInjection";
-    version = "7.0.0";
-    sha256 = "121zs4jp8iimgbpzm3wsglhjwkc06irg1pxy8c1zcdlsg34cfq1p";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.DependencyInjection.Abstractions";
-    version = "2.1.0";
-    sha256 = "0c0cx8r5xkjpxmcfp51959jnp55qjvq28d9vaslk08avvi1by12s";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.DependencyInjection.Abstractions";
-    version = "2.2.0";
-    sha256 = "1jyzfdr9651h3x6pxwhpfbb9mysfh8f8z1jvy4g117h9790r9zx5";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.DependencyInjection.Abstractions";
-    version = "3.1.0";
-    sha256 = "1pvms778xkyv1a3gfwrxnh8ja769cxi416n7pcidn9wvg15ifvbh";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.DependencyInjection.Abstractions";
-    version = "5.0.0";
-    sha256 = "17cz6s80va0ch0a6nqa1wbbbp3p8sqxb96lj4qcw67ivkp2yxiyj";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.DependencyInjection.Abstractions";
-    version = "6.0.0";
-    sha256 = "1vi67fw7q99gj7jd64gnnfr4d2c0ijpva7g9prps48ja6g91x6a9";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.DependencyInjection.Abstractions";
-    version = "7.0.0";
-    sha256 = "181d7mp9307fs17lyy42f8cxnjwysddmpsalky4m0pqxcimnr6g7";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.DependencyModel";
-    version = "6.0.0";
-    sha256 = "08c4fh1n8vsish1vh7h73mva34g0as4ph29s4lvps7kmjb4z64nl";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Diagnostics.HealthChecks";
-    version = "6.0.7";
-    sha256 = "14jqhm15gg03smjx74vfcqmviw42yb9lqfdy0h8824mls350cb73";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Diagnostics.HealthChecks.Abstractions";
-    version = "6.0.7";
-    sha256 = "1bv9p3yw4icz602pn95hk8640s16ysqgp2c2lj2znrz7iay2jg4m";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.FileProviders.Abstractions";
-    version = "2.2.0";
-    sha256 = "1f83ffb4xjwljg8dgzdsa3pa0582q6b4zm0si467fgkybqzk3c54";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.FileProviders.Abstractions";
-    version = "6.0.0";
-    sha256 = "1fbqmfapxdz77drcv1ndyj2ybvd2rv4c9i9pgiykcpl4fa6dc65q";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.FileProviders.Abstractions";
-    version = "7.0.0";
-    sha256 = "0ff20yklyjgyjzdyv7sybczgqhgd557m05dbwxzjznr0x41b180d";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Hosting.Abstractions";
-    version = "6.0.0";
-    sha256 = "1mwjx6li4a82nb589763whpnhf5hfy1bpv1dzqqvczb1lhxhzhlj";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Hosting.Abstractions";
-    version = "7.0.0";
-    sha256 = "1h5szfsr1dalsvdj9c18y6362853chisfns0hfpsq44hz0pr8j9q";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Http";
-    version = "3.1.0";
-    sha256 = "02ipxf75rqzsbmmy5ka44hh8krmxgky9mdxmh8f7fkbclpg2s6cy";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Http";
-    version = "6.0.0";
-    sha256 = "1wxsqvfy2arbwk0nhambjprazim6ynrb23r1hr5vk4gv10i26m95";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Logging";
-    version = "2.1.0";
-    sha256 = "0dii8i7s6libfnspz2xb96ayagb4rwqj2kmr162vndivr9rmbm06";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Logging";
-    version = "3.1.0";
-    sha256 = "1d3yhqj1rav7vswm747j7w8fh8paybji4rz941hhlq4b12mfqfh4";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Logging";
-    version = "5.0.0";
-    sha256 = "1qa1l18q2jh9azya8gv1p8anzcdirjzd9dxxisb4911i9m1648i3";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Logging";
-    version = "6.0.0";
-    sha256 = "0fd9jii3y3irfcwlsiww1y9npjgabzarh33rn566wpcz24lijszi";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Logging";
-    version = "7.0.0";
-    sha256 = "1bqd3pqn5dacgnkq0grc17cgb2i0w8z1raw12nwm3p3zhrfcvgxf";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Logging.Abstractions";
-    version = "2.1.0";
-    sha256 = "1gvgif1wcx4k6pv7gc00qv1hid945jdywy1s50s33q0hfd91hbnj";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Logging.Abstractions";
-    version = "2.2.0";
-    sha256 = "02w7hp6jicr7cl5p456k2cmrjvvhm6spg5kxnlncw3b72358m5wl";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Logging.Abstractions";
-    version = "3.1.0";
-    sha256 = "1zyalrcksszmn9r5xjnirfh7847axncgzxkk3k5srbvlcch8fw8g";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Logging.Abstractions";
-    version = "5.0.0";
-    sha256 = "1yza38675dbv1qqnnhqm23alv2bbaqxp0pb7zinjmw8j2mr5r6wc";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Logging.Abstractions";
-    version = "6.0.0";
-    sha256 = "0b75fmins171zi6bfdcq1kcvyrirs8n91mknjnxy4c3ygi1rrnj0";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Logging.Abstractions";
-    version = "6.0.1";
-    sha256 = "17w4x7iakwpn7crg4yk5qkkv5gkx0lfl6anwwhb1554pwak5cwdz";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Logging.Abstractions";
-    version = "7.0.0";
-    sha256 = "1gn7d18i1wfy13vrwhmdv1rmsb4vrk26kqdld4cgvh77yigj90xs";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Logging.Configuration";
-    version = "7.0.0";
-    sha256 = "1f5fhpvzwyrwxh3g1ry027s4skmklf6mbm2w0p13h0x6fbmxcb24";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Logging.Console";
-    version = "7.0.0";
-    sha256 = "1m8ri2m3vlv9vzk0068jkrx0vkk4sqmk1kxmn8pc3wys38d38qaf";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.ObjectPool";
-    version = "7.0.0";
-    sha256 = "15lz0qk2gr2q52i05ip51dzm9p4hzqlrammkc0hv2ng6g0z72697";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.ObjectPool";
-    version = "7.0.3";
-    sha256 = "1dzcmxcjw2z4czv16x56jnjh6gcrzcahqrpzkkfzcvrzhak0x6p6";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Options";
-    version = "2.1.0";
-    sha256 = "0w9644sryd1c6r3n4lq2cgd5pn6jl3k5m38a05m7vjffa4m2spd2";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Options";
-    version = "2.2.0";
-    sha256 = "1b20yh03fg4nmmi3vlf6gf13vrdkmklshfzl3ijygcs4c2hly6v0";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Options";
-    version = "3.1.0";
-    sha256 = "0akccwhpn93a4qrssyb3rszdsp3j4p9hlxbsb7yhqb78xydaqhyh";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Options";
-    version = "5.0.0";
-    sha256 = "1rdmgpg770x8qwaaa6ryc27zh93p697fcyvn5vkxp0wimlhqkbay";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Options";
-    version = "6.0.0";
-    sha256 = "008pnk2p50i594ahz308v81a41mbjz9mwcarqhmrjpl2d20c868g";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Options";
-    version = "7.0.0";
-    sha256 = "0b90zkrsk5dw3wr749rbynhpxlg4bgqdnd7d5vdlw2g9c7zlhgx6";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Options";
-    version = "7.0.1";
-    sha256 = "0ghz4y4gxnf2vw8yvhz9nkw21p6q2qqwh19phkk1xwxywyilr3mq";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Options.ConfigurationExtensions";
-    version = "7.0.0";
-    sha256 = "1liyprh0zha2vgmqh92n8kkjz61zwhr7g16f0gmr297z2rg1j5pj";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Primitives";
-    version = "2.1.0";
-    sha256 = "1r9gzwdfmb8ysnc4nzmyz5cyar1lw0qmizsvrsh252nhlyg06nmb";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Primitives";
-    version = "2.2.0";
-    sha256 = "0znah6arbcqari49ymigg3wiy2hgdifz8zsq8vdc3ynnf45r7h0c";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Primitives";
-    version = "3.1.0";
-    sha256 = "1w1y22njywwysi8qjnj4m83qhbq0jr4mmjib0hfawz6cwamh7xrb";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Primitives";
-    version = "5.0.0";
-    sha256 = "0swqcknyh87ns82w539z1mvy804pfwhgzs97cr3nwqk6g5s42gd6";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Primitives";
-    version = "6.0.0";
-    sha256 = "1kjiw6s4yfz9gm7mx3wkhp06ghnbs95icj9hi505shz9rjrg42q2";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Extensions.Primitives";
-    version = "7.0.0";
-    sha256 = "1b4km9fszid9vp2zb3gya5ni9fn8bq62bzaas2ck2r7gs0sdys80";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.IdentityModel.Abstractions";
-    version = "6.27.0";
-    sha256 = "053c1pkx9bnb9440f5rkzbdv99wgcaw95xnqjp09ncd2crh8kakp";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.IdentityModel.JsonWebTokens";
-    version = "5.6.0";
-    sha256 = "0wfzns7w8rwlz815yw07apxc9qhcmwbaz53l2rwwcrgh1r6fgchz";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.IdentityModel.JsonWebTokens";
-    version = "6.27.0";
-    sha256 = "103qvpahmn1x8yxj0kc920s27xbyjr15z8lf5ikrsrikalb5yjx9";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.IdentityModel.Logging";
-    version = "5.6.0";
-    sha256 = "0sp2r8sgjz2jqnr203scyxr2zjzygi4f0hhjyrilwbjp8szvb24v";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.IdentityModel.Logging";
-    version = "6.27.0";
-    sha256 = "1c3b0bkmxa24bvzi16jc7lc1nifqcq4jg7ild973bb8mivicagzv";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.IdentityModel.Tokens";
-    version = "5.6.0";
-    sha256 = "12warwfv4wpp33i9mg8dmw60i57sfc736sa6sw200w9g4j5rgh0w";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.IdentityModel.Tokens";
-    version = "6.27.0";
-    sha256 = "0h51vdcz6pkv4ky2ygba4vks56rskripqb3fjz95ym0l0xg20s1a";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Net.Http.Headers";
-    version = "2.2.0";
-    sha256 = "0w6lrk9z67bcirq2cj2ldfhnizc6id77ba6i30hjzgqjlyhh1gx5";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.NET.Test.Sdk";
-    version = "17.4.1";
-    sha256 = "02p1j9fncd4fb2hyp51kw49d0dz30vvazhzk24c9f5ccc00ijpra";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.NETCore.App";
-    version = "1.0.0";
-    sha256 = "0i09cs7a7hxn9n1nx49382csvc7560j4hbxr2c8bwa69nhf2rrjp";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.NETCore.DotNetHost";
-    version = "1.0.1";
-    sha256 = "1qr4gnzlpwzv8jr7ijmdg13x2s9m35g4ma0bh18kci4ml7h9jb6a";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.NETCore.DotNetHostPolicy";
-    version = "1.0.1";
-    sha256 = "0vbqww1bmlkz7xq05zxykv27xdrkl6nrjhs1iiszaa9ivf7nklz1";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.NETCore.DotNetHostResolver";
-    version = "1.0.1";
-    sha256 = "109zs3bqhzh6mhbf2rfpwxmpb8fq57jr7wriyylynirsqh1lnql4";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.NETCore.Jit";
-    version = "1.0.2";
-    sha256 = "0jaan2wmg80lr0mhgfy70kb5cqjwv1a2ikmxgd0glpcxp7wr7pag";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.NETCore.Platforms";
-    version = "1.0.1";
-    sha256 = "01al6cfxp68dscl15z7rxfw9zvhm64dncsw09a1vmdkacsa2v6lr";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.NETCore.Platforms";
-    version = "1.1.0";
-    sha256 = "08vh1r12g6ykjygq5d3vq09zylgb84l63k49jc4v8faw9g93iqqm";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.NETCore.Platforms";
-    version = "1.1.1";
-    sha256 = "164wycgng4mi9zqi2pnsf1pq6gccbqvw6ib916mqizgjmd8f44pj";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.NETCore.Platforms";
-    version = "5.0.0";
-    sha256 = "0mwpwdflidzgzfx2dlpkvvnkgkr2ayaf0s80737h4wa35gaj11rc";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.NETCore.Runtime.CoreCLR";
-    version = "1.0.2";
-    sha256 = "1hxgsjyzh7hdgd34xwpn5s2myy1b1y9ms7xhvs6mkb75wap49bpc";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.NETCore.Targets";
-    version = "1.0.1";
-    sha256 = "0ppdkwy6s9p7x9jix3v4402wb171cdiibq7js7i13nxpdky7074p";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.NETCore.Targets";
-    version = "1.1.0";
-    sha256 = "193xwf33fbm0ni3idxzbr5fdq3i2dlfgihsac9jj7whj0gd902nh";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.NETCore.Windows.ApiSets";
-    version = "1.0.1";
-    sha256 = "16k8chghkr25jf49banhzl839vs8n3vbfpg4wn4idi0hzjipix78";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Packaging.Tools";
-    version = "1.0.0-preview1-25301-01";
-    sha256 = "06ljw8qh5sizpximmzi55d34vlc40ng9v5kwzk73jaxi6ysnjkic";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Rest.ClientRuntime";
-    version = "2.3.10";
-    sha256 = "0r7mkm9p35zbvfs93rpl78v1fgi5pnjc1lkyj72mls1q9z40cgnw";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.TestPlatform.ObjectModel";
-    version = "17.4.1";
-    sha256 = "0s68wf9yphm4hni9p6kwfk0mjld85f4hkrs93qbk5lzf6vv3kba1";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.TestPlatform.TestHost";
-    version = "17.4.1";
-    sha256 = "1n9ilq8n5rhyxcri06njkxb0h2818dbmzddwd2rrvav91647m2s4";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.VisualBasic";
-    version = "10.0.1";
-    sha256 = "0q6vv9qfkbwn7gz8qf1gfcn33r87m260hsxdsk838mcbqmjz6wgc";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.VisualStudio.Azure.Containers.Tools.Targets";
-    version = "1.17.0";
-    sha256 = "1p2sy9br5n1i0l82mizal1igvy1r19ln0m93l3xdf6p4q9m8ahym";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Win32.Primitives";
-    version = "4.0.1";
-    sha256 = "1n8ap0cmljbqskxpf8fjzn7kh1vvlndsa75k01qig26mbw97k2q7";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Win32.Primitives";
-    version = "4.3.0";
-    sha256 = "0j0c1wj4ndj21zsgivsc24whiya605603kxrbiw6wkfdync464wq";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Win32.Registry";
-    version = "4.0.0";
-    sha256 = "1spf4m9pikkc19544p29a47qnhcd885klncahz133hbnyqbkmz9k";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Win32.Registry";
-    version = "5.0.0";
-    sha256 = "102hvhq2gmlcbq8y2cb7hdr2dnmjzfp2k3asr1ycwrfacwyaak7n";
-  })
-  (fetchNuGet {
-    pname = "Microsoft.Win32.SystemEvents";
-    version = "7.0.0";
-    sha256 = "1bh77misznh19m1swqm3dsbji499b8xh9gk6w74sgbkarf6ni8lb";
-  })
-  (fetchNuGet {
-    pname = "Nethermind.Crypto.Pairings";
-    version = "1.0.1";
-    sha256 = "1d8n97snf30iymdzjn6528655cw0skpb3jb2kywbh5hj9f2nl7mp";
-  })
-  (fetchNuGet {
-    pname = "Nethermind.Crypto.SecP256k1";
-    version = "1.0.1";
-    sha256 = "0vmkv5zmr15lakcbi4ilicrk671igfw2n4nk1b6bbxdhy7vga3yw";
-  })
-  (fetchNuGet {
-    pname = "Nethermind.DotNetty.Buffers";
-    version = "1.0.0";
-    sha256 = "13v83qn5lhziq10imsjmdsw5p7irkdmfgraphxfcqrq2ndv55pxr";
-  })
-  (fetchNuGet {
-    pname = "Nethermind.DotNetty.Codecs";
-    version = "1.0.0";
-    sha256 = "0rzyh9xmp143nq69l5pfkxcxw27ph3f682vvyxxkxwby0p2b17df";
-  })
-  (fetchNuGet {
-    pname = "Nethermind.DotNetty.Common";
-    version = "1.0.0";
-    sha256 = "1wz1mg2aawk80w42a6z6vanrp57p6sqx1r97rwms0v9lhhaijfwf";
-  })
-  (fetchNuGet {
-    pname = "Nethermind.DotNetty.Handlers";
-    version = "1.0.0";
-    sha256 = "1262xi70bd37s13c8x7lpzgh0h989rzbir4fn2sfhygx7vm6lyfz";
-  })
-  (fetchNuGet {
-    pname = "Nethermind.DotNetty.Transport";
-    version = "1.0.0";
-    sha256 = "1n64ay4qqjpzfq4kd2ph328v14y3d4z9qqfrkjrl8h1pnm52wfjw";
-  })
-  (fetchNuGet {
-    pname = "Nethermind.Gmp";
-    version = "1.0.1";
-    sha256 = "1x9in44pvg2jjiqrf8q9l4qyqilcbx6hr2ywgk42gjxri27agnih";
-  })
-  (fetchNuGet {
-    pname = "Nethermind.Numerics.Int256";
-    version = "1.1.0";
-    sha256 = "0zhbld37lv0lx51dr5w8gc711r5kvf18ab5fqf0nj3ahva48z965";
-  })
-  (fetchNuGet {
-    pname = "NETStandard.Library";
-    version = "1.6.0";
-    sha256 = "0nmmv4yw7gw04ik8ialj3ak0j6pxa9spih67hnn1h2c38ba8h58k";
-  })
-  (fetchNuGet {
-    pname = "NETStandard.Library";
-    version = "1.6.1";
-    sha256 = "1z70wvsx2d847a2cjfii7b83pjfs34q05gb037fdjikv5kbagml8";
-  })
-  (fetchNuGet {
-    pname = "NETStandard.Library";
-    version = "2.0.0";
-    sha256 = "1bc4ba8ahgk15m8k4nd7x406nhi0kwqzbgjk2dmw52ss553xz7iy";
-  })
-  (fetchNuGet {
-    pname = "NETStandard.Library";
-    version = "2.0.0-preview1-25301-01";
-    sha256 = "1d7rpl16sf0c4b069cs1vpzq8838v1ag2ww7qsyna8jvip7ks2zz";
-  })
-  (fetchNuGet {
-    pname = "Newtonsoft.Json";
-    version = "13.0.1";
-    sha256 = "0fijg0w6iwap8gvzyjnndds0q4b8anwxxvik7y8vgq97dram4srb";
-  })
-  (fetchNuGet {
-    pname = "Newtonsoft.Json";
-    version = "13.0.2";
-    sha256 = "1p9splg1min274dpz7xdfgzrwkyfd3xlkygwpr1xgjvvyjvs6b0i";
-  })
-  (fetchNuGet {
-    pname = "Nito.Collections.Deque";
-    version = "1.1.1";
-    sha256 = "152564q3s0n5swfv5p5rx0ghn2sm0g2xsnbd7gv8vb9yfklv7yg8";
-  })
-  (fetchNuGet {
-    pname = "NLog";
-    version = "5.1.2";
-    sha256 = "1hgb5lqx9c10kw6rjldrkldd70lmkzij4ssgg6msybgz7vpsyhkk";
-  })
-  (fetchNuGet {
-    pname = "NLog.Targets.Seq";
-    version = "2.1.0";
-    sha256 = "03d0z6sv04bmn75y3aaihbswrk5gcj21nqq30l8r0cm385x1r9mb";
-  })
-  (fetchNuGet {
-    pname = "NSubstitute";
-    version = "5.0.0";
-    sha256 = "1iacc39nz8pzxay5fs9mzrflmr9mvwjd3lrn61yc7kmamqs87rqk";
-  })
-  (fetchNuGet {
-    pname = "NuGet.Frameworks";
-    version = "5.11.0";
-    sha256 = "0wv26gq39hfqw9md32amr5771s73f5zn1z9vs4y77cgynxr73s4z";
-  })
-  (fetchNuGet {
-    pname = "NUnit";
-    version = "3.13.3";
-    sha256 = "0wdzfkygqnr73s6lpxg5b1pwaqz9f414fxpvpdmf72bvh4jaqzv6";
-  })
-  (fetchNuGet {
-    pname = "NUnit.Analyzers";
-    version = "3.6.1";
-    sha256 = "16dw5375k2wyhiw9x387y7pjgq6zms30y036qb8z7idx4lxw9yi9";
-  })
-  (fetchNuGet {
-    pname = "NUnit3TestAdapter";
-    version = "4.3.1";
-    sha256 = "1j80cfrg0fflgw7wxi76mxj1wllwzcg4ck957knmjpghw5cw7lvv";
-  })
-  (fetchNuGet {
-    pname = "Open.NAT.Core";
-    version = "2.1.0.5";
-    sha256 = "0f6c7m1x1kssicbi6q60jys3fnbj6zs69v37wdsmvbqgc0pvk89f";
-  })
-  (fetchNuGet {
-    pname = "Polly";
-    version = "7.2.3";
-    sha256 = "1iws4jd5iqj5nlfp16fg9p5vfqqas1si0cgh8xcj64y433a933cv";
-  })
-  (fetchNuGet {
-    pname = "Portable.BouncyCastle";
-    version = "1.8.1.3";
-    sha256 = "1lv1ljaz8df835jgmp3ny1xgqqjf1s9f25baw7bf8d24qlf25i2g";
-  })
-  (fetchNuGet {
-    pname = "Portable.BouncyCastle";
-    version = "1.9.0";
-    sha256 = "0kphjwz4hk2nki3b4f9z096xzd520nrpvi3cjib8fkjk6zhwrr8q";
-  })
-  (fetchNuGet {
-    pname = "prometheus-net";
-    version = "4.1.1";
-    sha256 = "0n016rxlz00xrw1jrikwr6h221rrw96h13d0823mfb5375rdi8rx";
-  })
-  (fetchNuGet {
-    pname = "prometheus-net";
-    version = "8.0.0";
-    sha256 = "1ac527simsknkbanzdvjkw0gqhp52m1d44f3nfhzsdxhc8yp963r";
-  })
-  (fetchNuGet {
-    pname = "prometheus-net.AspNetCore";
-    version = "8.0.0";
-    sha256 = "1knkcjr9izxjnpn3f0prhk3b78jjdlfs6mfxlwigz2yzw83x4zm8";
-  })
-  (fetchNuGet {
-    pname = "ReadLine";
-    version = "2.0.1";
-    sha256 = "1bc7aiyh99kkf4indrqzlf3y6517xhxh02nizybkp4hbxga1caih";
-  })
-  (fetchNuGet {
-    pname = "RichardSzalay.MockHttp";
-    version = "6.0.0";
-    sha256 = "1bmsd8ivwk86mar047jal98s2cmxx69pxpw9q2b59a4lmkp9vn2m";
-  })
-  (fetchNuGet {
-    pname = "RocksDB";
-    version = "8.0.0.37452";
-    sha256 = "04lk153rps6a5s1xy74ahvdiwx8m53r39nfn927q85cki66f9f73";
-  })
-  (fetchNuGet {
-    pname = "runtime.any.System.Collections";
-    version = "4.3.0";
-    sha256 = "0bv5qgm6vr47ynxqbnkc7i797fdi8gbjjxii173syrx14nmrkwg0";
-  })
-  (fetchNuGet {
-    pname = "runtime.any.System.Diagnostics.Tools";
-    version = "4.3.0";
-    sha256 = "1wl76vk12zhdh66vmagni66h5xbhgqq7zkdpgw21jhxhvlbcl8pk";
-  })
-  (fetchNuGet {
-    pname = "runtime.any.System.Diagnostics.Tracing";
-    version = "4.3.0";
-    sha256 = "00j6nv2xgmd3bi347k00m7wr542wjlig53rmj28pmw7ddcn97jbn";
-  })
-  (fetchNuGet {
-    pname = "runtime.any.System.Globalization";
-    version = "4.3.0";
-    sha256 = "1daqf33hssad94lamzg01y49xwndy2q97i2lrb7mgn28656qia1x";
-  })
-  (fetchNuGet {
-    pname = "runtime.any.System.Globalization.Calendars";
-    version = "4.3.0";
-    sha256 = "1ghhhk5psqxcg6w88sxkqrc35bxcz27zbqm2y5p5298pv3v7g201";
-  })
-  (fetchNuGet {
-    pname = "runtime.any.System.IO";
-    version = "4.3.0";
-    sha256 = "0l8xz8zn46w4d10bcn3l4yyn4vhb3lrj2zw8llvz7jk14k4zps5x";
-  })
-  (fetchNuGet {
-    pname = "runtime.any.System.Reflection";
-    version = "4.3.0";
-    sha256 = "02c9h3y35pylc0zfq3wcsvc5nqci95nrkq0mszifc0sjx7xrzkly";
-  })
-  (fetchNuGet {
-    pname = "runtime.any.System.Reflection.Extensions";
-    version = "4.3.0";
-    sha256 = "0zyri97dfc5vyaz9ba65hjj1zbcrzaffhsdlpxc9bh09wy22fq33";
-  })
-  (fetchNuGet {
-    pname = "runtime.any.System.Reflection.Primitives";
-    version = "4.3.0";
-    sha256 = "0x1mm8c6iy8rlxm8w9vqw7gb7s1ljadrn049fmf70cyh42vdfhrf";
-  })
-  (fetchNuGet {
-    pname = "runtime.any.System.Resources.ResourceManager";
-    version = "4.3.0";
-    sha256 = "03kickal0iiby82wa5flar18kyv82s9s6d4xhk5h4bi5kfcyfjzl";
-  })
-  (fetchNuGet {
-    pname = "runtime.any.System.Runtime";
-    version = "4.3.0";
-    sha256 = "1cqh1sv3h5j7ixyb7axxbdkqx6cxy00p4np4j91kpm492rf4s25b";
-  })
-  (fetchNuGet {
-    pname = "runtime.any.System.Runtime.Handles";
-    version = "4.3.0";
-    sha256 = "0bh5bi25nk9w9xi8z23ws45q5yia6k7dg3i4axhfqlnj145l011x";
-  })
-  (fetchNuGet {
-    pname = "runtime.any.System.Runtime.InteropServices";
-    version = "4.3.0";
-    sha256 = "0c3g3g3jmhlhw4klrc86ka9fjbl7i59ds1fadsb2l8nqf8z3kb19";
-  })
-  (fetchNuGet {
-    pname = "runtime.any.System.Text.Encoding";
-    version = "4.3.0";
-    sha256 = "0aqqi1v4wx51h51mk956y783wzags13wa7mgqyclacmsmpv02ps3";
-  })
-  (fetchNuGet {
-    pname = "runtime.any.System.Text.Encoding.Extensions";
-    version = "4.3.0";
-    sha256 = "0lqhgqi0i8194ryqq6v2gqx0fb86db2gqknbm0aq31wb378j7ip8";
-  })
-  (fetchNuGet {
-    pname = "runtime.any.System.Threading.Tasks";
-    version = "4.3.0";
-    sha256 = "03mnvkhskbzxddz4hm113zsch1jyzh2cs450dk3rgfjp8crlw1va";
-  })
-  (fetchNuGet {
-    pname = "runtime.any.System.Threading.Timer";
-    version = "4.3.0";
-    sha256 = "0aw4phrhwqz9m61r79vyfl5la64bjxj8l34qnrcwb28v49fg2086";
-  })
-  (fetchNuGet {
-    pname = "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl";
-    version = "4.3.0";
-    sha256 = "16rnxzpk5dpbbl1x354yrlsbvwylrq456xzpsha1n9y3glnhyx9d";
-  })
-  (fetchNuGet {
-    pname = "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl";
-    version = "4.3.2";
-    sha256 = "0rwpqngkqiapqc5c2cpkj7idhngrgss5qpnqg0yh40mbyflcxf8i";
-  })
-  (fetchNuGet {
-    pname = "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl";
-    version = "4.3.0";
-    sha256 = "0hkg03sgm2wyq8nqk6dbm9jh5vcq57ry42lkqdmfklrw89lsmr59";
-  })
-  (fetchNuGet {
-    pname = "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl";
-    version = "4.3.2";
-    sha256 = "1n06gxwlinhs0w7s8a94r1q3lwqzvynxwd3mp10ws9bg6gck8n4r";
-  })
-  (fetchNuGet {
-    pname = "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl";
-    version = "4.3.0";
-    sha256 = "0c2p354hjx58xhhz7wv6div8xpi90sc6ibdm40qin21bvi7ymcaa";
-  })
-  (fetchNuGet {
-    pname = "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl";
-    version = "4.3.2";
-    sha256 = "0404wqrc7f2yc0wxv71y3nnybvqx8v4j9d47hlscxy759a525mc3";
-  })
-  (fetchNuGet {
-    pname = "runtime.native.System";
-    version = "4.0.0";
-    sha256 = "1ppk69xk59ggacj9n7g6fyxvzmk1g5p4fkijm0d7xqfkig98qrkf";
-  })
-  (fetchNuGet {
-    pname = "runtime.native.System";
-    version = "4.3.0";
-    sha256 = "15hgf6zaq9b8br2wi1i3x0zvmk410nlmsmva9p0bbg73v6hml5k4";
-  })
-  (fetchNuGet {
-    pname = "runtime.native.System.IO.Compression";
-    version = "4.1.0";
-    sha256 = "0d720z4lzyfcabmmnvh0bnj76ll7djhji2hmfh3h44sdkjnlkknk";
-  })
-  (fetchNuGet {
-    pname = "runtime.native.System.IO.Compression";
-    version = "4.3.0";
-    sha256 = "1vvivbqsk6y4hzcid27pqpm5bsi6sc50hvqwbcx8aap5ifrxfs8d";
-  })
-  (fetchNuGet {
-    pname = "runtime.native.System.Net.Http";
-    version = "4.0.1";
-    sha256 = "1hgv2bmbaskx77v8glh7waxws973jn4ah35zysnkxmf0196sfxg6";
-  })
-  (fetchNuGet {
-    pname = "runtime.native.System.Net.Http";
-    version = "4.3.0";
-    sha256 = "1n6rgz5132lcibbch1qlf0g9jk60r0kqv087hxc0lisy50zpm7kk";
-  })
-  (fetchNuGet {
-    pname = "runtime.native.System.Net.Security";
-    version = "4.0.1";
-    sha256 = "1nk4pf8vbrgf73p0skhwmzhgz1hax3j123ilhwdncr47l3x1dbhk";
-  })
-  (fetchNuGet {
-    pname = "runtime.native.System.Security.Cryptography";
-    version = "4.0.0";
-    sha256 = "0k57aa2c3b10wl3hfqbgrl7xq7g8hh3a3ir44b31dn5p61iiw3z9";
-  })
-  (fetchNuGet {
-    pname = "runtime.native.System.Security.Cryptography.Apple";
-    version = "4.3.0";
-    sha256 = "1b61p6gw1m02cc1ry996fl49liiwky6181dzr873g9ds92zl326q";
-  })
-  (fetchNuGet {
-    pname = "runtime.native.System.Security.Cryptography.OpenSsl";
-    version = "4.3.0";
-    sha256 = "18pzfdlwsg2nb1jjjjzyb5qlgy6xjxzmhnfaijq5s2jw3cm3ab97";
-  })
-  (fetchNuGet {
-    pname = "runtime.native.System.Security.Cryptography.OpenSsl";
-    version = "4.3.2";
-    sha256 = "0zy5r25jppz48i2bkg8b9lfig24xixg6nm3xyr1379zdnqnpm8f6";
-  })
-  (fetchNuGet {
-    pname = "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl";
-    version = "4.3.0";
-    sha256 = "0qyynf9nz5i7pc26cwhgi8j62ps27sqmf78ijcfgzab50z9g8ay3";
-  })
-  (fetchNuGet {
-    pname = "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl";
-    version = "4.3.2";
-    sha256 = "096ch4n4s8k82xga80lfmpimpzahd2ip1mgwdqgar0ywbbl6x438";
-  })
-  (fetchNuGet {
-    pname = "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl";
-    version = "4.3.0";
-    sha256 = "1klrs545awhayryma6l7g2pvnp9xy4z0r1i40r80zb45q3i9nbyf";
-  })
-  (fetchNuGet {
-    pname = "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl";
-    version = "4.3.2";
-    sha256 = "1dm8fifl7rf1gy7lnwln78ch4rw54g0pl5g1c189vawavll7p6rj";
-  })
-  (fetchNuGet {
-    pname = "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.Apple";
-    version = "4.3.0";
-    sha256 = "10yc8jdrwgcl44b4g93f1ds76b176bajd3zqi2faf5rvh1vy9smi";
-  })
-  (fetchNuGet {
-    pname = "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl";
-    version = "4.3.0";
-    sha256 = "0zcxjv5pckplvkg0r6mw3asggm7aqzbdjimhvsasb0cgm59x09l3";
-  })
-  (fetchNuGet {
-    pname = "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl";
-    version = "4.3.2";
-    sha256 = "1m9z1k9kzva9n9kwinqxl97x2vgl79qhqjlv17k9s2ymcyv2bwr6";
-  })
-  (fetchNuGet {
-    pname = "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl";
-    version = "4.3.0";
-    sha256 = "0vhynn79ih7hw7cwjazn87rm9z9fj0rvxgzlab36jybgcpcgphsn";
-  })
-  (fetchNuGet {
-    pname = "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl";
-    version = "4.3.2";
-    sha256 = "1cpx56mcfxz7cpn57wvj18sjisvzq8b5vd9rw16ihd2i6mcp3wa1";
-  })
-  (fetchNuGet {
-    pname = "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl";
-    version = "4.3.0";
-    sha256 = "160p68l2c7cqmyqjwxydcvgw7lvl1cr0znkw8fp24d1by9mqc8p3";
-  })
-  (fetchNuGet {
-    pname = "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl";
-    version = "4.3.2";
-    sha256 = "15gsm1a8jdmgmf8j5v1slfz8ks124nfdhk2vxs2rw3asrxalg8hi";
-  })
-  (fetchNuGet {
-    pname = "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl";
-    version = "4.3.0";
-    sha256 = "15zrc8fgd8zx28hdghcj5f5i34wf3l6bq5177075m2bc2j34jrqy";
-  })
-  (fetchNuGet {
-    pname = "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl";
-    version = "4.3.2";
-    sha256 = "0q0n5q1r1wnqmr5i5idsrd9ywl33k0js4pngkwq9p368mbxp8x1w";
-  })
-  (fetchNuGet {
-    pname = "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl";
-    version = "4.3.0";
-    sha256 = "1p4dgxax6p7rlgj4q73k73rslcnz4wdcv8q2flg1s8ygwcm58ld5";
-  })
-  (fetchNuGet {
-    pname = "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl";
-    version = "4.3.2";
-    sha256 = "1x0g58pbpjrmj2x2qw17rdwwnrcl0wvim2hdwz48lixvwvp22n9c";
-  })
-  (fetchNuGet {
-    pname = "runtime.unix.Microsoft.Win32.Primitives";
-    version = "4.3.0";
-    sha256 = "0y61k9zbxhdi0glg154v30kkq7f8646nif8lnnxbvkjpakggd5id";
-  })
-  (fetchNuGet {
-    pname = "runtime.unix.System.Console";
-    version = "4.3.0";
-    sha256 = "1pfpkvc6x2if8zbdzg9rnc5fx51yllprl8zkm5npni2k50lisy80";
-  })
-  (fetchNuGet {
-    pname = "runtime.unix.System.Diagnostics.Debug";
-    version = "4.3.0";
-    sha256 = "1lps7fbnw34bnh3lm31gs5c0g0dh7548wfmb8zz62v0zqz71msj5";
-  })
-  (fetchNuGet {
-    pname = "runtime.unix.System.IO.FileSystem";
-    version = "4.3.0";
-    sha256 = "14nbkhvs7sji5r1saj2x8daz82rnf9kx28d3v2qss34qbr32dzix";
-  })
-  (fetchNuGet {
-    pname = "runtime.unix.System.Net.Primitives";
-    version = "4.3.0";
-    sha256 = "0bdnglg59pzx9394sy4ic66kmxhqp8q8bvmykdxcbs5mm0ipwwm4";
-  })
-  (fetchNuGet {
-    pname = "runtime.unix.System.Net.Sockets";
-    version = "4.3.0";
-    sha256 = "03npdxzy8gfv035bv1b9rz7c7hv0rxl5904wjz51if491mw0xy12";
-  })
-  (fetchNuGet {
-    pname = "runtime.unix.System.Private.Uri";
-    version = "4.3.0";
-    sha256 = "1jx02q6kiwlvfksq1q9qr17fj78y5v6mwsszav4qcz9z25d5g6vk";
-  })
-  (fetchNuGet {
-    pname = "runtime.unix.System.Runtime.Extensions";
-    version = "4.3.0";
-    sha256 = "0pnxxmm8whx38dp6yvwgmh22smknxmqs5n513fc7m4wxvs1bvi4p";
-  })
-  (fetchNuGet {
-    pname = "SCrypt";
-    version = "2.0.0.2";
-    sha256 = "03ira8iv45zcsv613bic0ak31v9am13x29dsj3j17xzhx65rg926";
-  })
-  (fetchNuGet {
-    pname = "Seq.Api";
-    version = "2023.1.0";
-    sha256 = "1liwvn83hzqdpayigrir0y49l31d7sncnbxmz2m8m66r3ksdk8k1";
-  })
-  (fetchNuGet {
-    pname = "Shouldly";
-    version = "4.1.0";
-    sha256 = "1mgw1nack5781qqq3kfw972bzp8xpsrlyb74k94yqcwpkfqn9iva";
-  })
-  (fetchNuGet {
-    pname = "Snappy.Standard";
-    version = "0.2.0";
-    sha256 = "1dbrp35r1k6gdpqx576kcrplxbdxs32223pl4ds9hwhpf1fjac65";
-  })
-  (fetchNuGet {
-    pname = "SQLitePCLRaw.bundle_e_sqlite3";
-    version = "2.0.6";
-    sha256 = "1ip0a653dx5cqybxg27zyz5ps31f2yz50g3jvz3vx39isx79gax3";
-  })
-  (fetchNuGet {
-    pname = "SQLitePCLRaw.core";
-    version = "1.1.5";
-    sha256 = "1944ni5nzazhr5n4g2md9q1prr9hx2nvifhgfpvn1cp1r2iy52nj";
-  })
-  (fetchNuGet {
-    pname = "SQLitePCLRaw.core";
-    version = "2.0.6";
-    sha256 = "1w4iyg0v1v1z2m7akq7rv8lsgixp2m08732vr14vgpqs918bsy1i";
-  })
-  (fetchNuGet {
-    pname = "SQLitePCLRaw.lib.e_sqlite3";
-    version = "2.0.6";
-    sha256 = "16378rh1lcqxynf5qj0kh8mrsb0jp37qqwg4285kqc5pknvh1bx3";
-  })
-  (fetchNuGet {
-    pname = "SQLitePCLRaw.provider.e_sqlite3";
-    version = "2.0.6";
-    sha256 = "0chgrqyycb1kqnaxnhhfg0850b94blhzni8zn79c7ggb3pd2ykyz";
-  })
-  (fetchNuGet {
-    pname = "System.AppContext";
-    version = "4.1.0";
-    sha256 = "0fv3cma1jp4vgj7a8hqc9n7hr1f1kjp541s6z0q1r6nazb4iz9mz";
-  })
-  (fetchNuGet {
-    pname = "System.AppContext";
-    version = "4.3.0";
-    sha256 = "1649qvy3dar900z3g817h17nl8jp4ka5vcfmsr05kh0fshn7j3ya";
-  })
-  (fetchNuGet {
-    pname = "System.Buffers";
-    version = "4.0.0";
-    sha256 = "13s659bcmg9nwb6z78971z1lr6bmh2wghxi1ayqyzl4jijd351gr";
-  })
-  (fetchNuGet {
-    pname = "System.Buffers";
-    version = "4.3.0";
-    sha256 = "0fgns20ispwrfqll4q1zc1waqcmylb3zc50ys9x8zlwxh9pmd9jy";
-  })
-  (fetchNuGet {
-    pname = "System.Buffers";
-    version = "4.5.0";
-    sha256 = "1ywfqn4md6g3iilpxjn5dsr0f5lx6z0yvhqp4pgjcamygg73cz2c";
-  })
-  (fetchNuGet {
-    pname = "System.Buffers";
-    version = "4.5.1";
-    sha256 = "04kb1mdrlcixj9zh1xdi5as0k0qi8byr5mi3p3jcxx72qz93s2y3";
-  })
-  (fetchNuGet {
-    pname = "System.CodeDom";
-    version = "5.0.0";
-    sha256 = "14zs2wqkmdlxzj8ikx19n321lsbarx5vl2a8wrachymxn8zb5njh";
-  })
-  (fetchNuGet {
-    pname = "System.Collections";
-    version = "4.0.11";
-    sha256 = "1ga40f5lrwldiyw6vy67d0sg7jd7ww6kgwbksm19wrvq9hr0bsm6";
-  })
-  (fetchNuGet {
-    pname = "System.Collections";
-    version = "4.3.0";
-    sha256 = "19r4y64dqyrq6k4706dnyhhw7fs24kpp3awak7whzss39dakpxk9";
-  })
-  (fetchNuGet {
-    pname = "System.Collections.Concurrent";
-    version = "4.0.12";
-    sha256 = "07y08kvrzpak873pmyxs129g1ch8l27zmg51pcyj2jvq03n0r0fc";
-  })
-  (fetchNuGet {
-    pname = "System.Collections.Concurrent";
-    version = "4.3.0";
-    sha256 = "0wi10md9aq33jrkh2c24wr2n9hrpyamsdhsxdcnf43b7y86kkii8";
-  })
-  (fetchNuGet {
-    pname = "System.Collections.Immutable";
-    version = "1.2.0";
-    sha256 = "1jm4pc666yiy7af1mcf7766v710gp0h40p228ghj6bavx7xfa38m";
-  })
-  (fetchNuGet {
-    pname = "System.Collections.Immutable";
-    version = "1.5.0";
-    sha256 = "1d5gjn5afnrf461jlxzawcvihz195gayqpcfbv6dd7pxa9ialn06";
-  })
-  (fetchNuGet {
-    pname = "System.Collections.Immutable";
-    version = "6.0.0";
-    sha256 = "1js98kmjn47ivcvkjqdmyipzknb9xbndssczm8gq224pbaj1p88c";
-  })
-  (fetchNuGet {
-    pname = "System.Collections.NonGeneric";
-    version = "4.3.0";
-    sha256 = "07q3k0hf3mrcjzwj8fwk6gv3n51cb513w4mgkfxzm3i37sc9kz7k";
-  })
-  (fetchNuGet {
-    pname = "System.Collections.Specialized";
-    version = "4.3.0";
-    sha256 = "1sdwkma4f6j85m3dpb53v9vcgd0zyc9jb33f8g63byvijcj39n20";
-  })
-  (fetchNuGet {
-    pname = "System.ComponentModel";
-    version = "4.0.1";
-    sha256 = "0v4qpmqlzyfad2kswxxj2frnaqqhz9201c3yn8fmmarx5vlzg52z";
-  })
-  (fetchNuGet {
-    pname = "System.ComponentModel";
-    version = "4.3.0";
-    sha256 = "0986b10ww3nshy30x9sjyzm0jx339dkjxjj3401r3q0f6fx2wkcb";
-  })
-  (fetchNuGet {
-    pname = "System.ComponentModel.Annotations";
-    version = "4.1.0";
-    sha256 = "0l6m3z6h2qjjam1rp1fzk7zz5czjjazmw78rbh72x25y6kmyn6wf";
-  })
-  (fetchNuGet {
-    pname = "System.ComponentModel.Annotations";
-    version = "4.5.0";
-    sha256 = "1jj6f6g87k0iwsgmg3xmnn67a14mq88np0l1ys5zkxhkvbc8976p";
-  })
-  (fetchNuGet {
-    pname = "System.ComponentModel.Primitives";
-    version = "4.3.0";
-    sha256 = "1svfmcmgs0w0z9xdw2f2ps05rdxmkxxhf0l17xk9l1l8xfahkqr0";
-  })
-  (fetchNuGet {
-    pname = "System.ComponentModel.TypeConverter";
-    version = "4.3.0";
-    sha256 = "17ng0p7v3nbrg3kycz10aqrrlw4lz9hzhws09pfh8gkwicyy481x";
-  })
-  (fetchNuGet {
-    pname = "System.Configuration.ConfigurationManager";
-    version = "4.4.0";
-    sha256 = "1hjgmz47v5229cbzd2pwz2h0dkq78lb2wp9grx8qr72pb5i0dk7v";
-  })
-  (fetchNuGet {
-    pname = "System.Configuration.ConfigurationManager";
-    version = "7.0.0";
-    sha256 = "149d9kmakzkbw69cip1ny0wjlgcvnhrr7vz5pavpsip36k2mw02a";
-  })
-  (fetchNuGet {
-    pname = "System.Console";
-    version = "4.0.0";
-    sha256 = "0ynxqbc3z1nwbrc11hkkpw9skw116z4y9wjzn7id49p9yi7mzmlf";
-  })
-  (fetchNuGet {
-    pname = "System.Console";
-    version = "4.3.0";
-    sha256 = "1flr7a9x920mr5cjsqmsy9wgnv3lvd0h1g521pdr1lkb2qycy7ay";
-  })
-  (fetchNuGet {
-    pname = "System.Data.Common";
-    version = "4.3.0";
-    sha256 = "12cl7vy3him9lmal10cyxifasf75x4h5b239wawpx3vzgim23xq3";
-  })
-  (fetchNuGet {
-    pname = "System.Diagnostics.Debug";
-    version = "4.0.11";
-    sha256 = "0gmjghrqmlgzxivd2xl50ncbglb7ljzb66rlx8ws6dv8jm0d5siz";
-  })
-  (fetchNuGet {
-    pname = "System.Diagnostics.Debug";
-    version = "4.3.0";
-    sha256 = "00yjlf19wjydyr6cfviaph3vsjzg3d5nvnya26i2fvfg53sknh3y";
-  })
-  (fetchNuGet {
-    pname = "System.Diagnostics.DiagnosticSource";
-    version = "4.0.0";
-    sha256 = "1n6c3fbz7v8d3pn77h4v5wvsfrfg7v1c57lg3nff3cjyh597v23m";
-  })
-  (fetchNuGet {
-    pname = "System.Diagnostics.DiagnosticSource";
-    version = "4.3.0";
-    sha256 = "0z6m3pbiy0qw6rn3n209rrzf9x1k4002zh90vwcrsym09ipm2liq";
-  })
-  (fetchNuGet {
-    pname = "System.Diagnostics.DiagnosticSource";
-    version = "6.0.0";
-    sha256 = "0rrihs9lnb1h6x4h0hn6kgfnh58qq7hx8qq99gh6fayx4dcnx3s5";
-  })
-  (fetchNuGet {
-    pname = "System.Diagnostics.EventLog";
-    version = "6.0.0";
-    sha256 = "08y1x2d5w2hnhkh9r1998pjc7r4qp0rmzax062abha85s11chifd";
-  })
-  (fetchNuGet {
-    pname = "System.Diagnostics.EventLog";
-    version = "7.0.0";
-    sha256 = "16p8z975dnzmncfifa9gw9n3k9ycpr2qvz7lglpghsvx0fava8k9";
-  })
-  (fetchNuGet {
-    pname = "System.Diagnostics.FileVersionInfo";
-    version = "4.0.0";
-    sha256 = "1s5vxhy7i09bmw51kxqaiz9zaj9am8wsjyz13j85sp23z267hbv3";
-  })
-  (fetchNuGet {
-    pname = "System.Diagnostics.Process";
-    version = "4.1.0";
-    sha256 = "061lrcs7xribrmq7kab908lww6kn2xn1w3rdc41q189y0jibl19s";
-  })
-  (fetchNuGet {
-    pname = "System.Diagnostics.StackTrace";
-    version = "4.0.1";
-    sha256 = "0q29axqklpl36vvyni5h1cyb02lfvvkqprb9wfvcdca3181q5al2";
-  })
-  (fetchNuGet {
-    pname = "System.Diagnostics.Tools";
-    version = "4.0.1";
-    sha256 = "19cknvg07yhakcvpxg3cxa0bwadplin6kyxd8mpjjpwnp56nl85x";
-  })
-  (fetchNuGet {
-    pname = "System.Diagnostics.Tools";
-    version = "4.3.0";
-    sha256 = "0in3pic3s2ddyibi8cvgl102zmvp9r9mchh82ns9f0ms4basylw1";
-  })
-  (fetchNuGet {
-    pname = "System.Diagnostics.Tracing";
-    version = "4.1.0";
-    sha256 = "1d2r76v1x610x61ahfpigda89gd13qydz6vbwzhpqlyvq8jj6394";
-  })
-  (fetchNuGet {
-    pname = "System.Diagnostics.Tracing";
-    version = "4.3.0";
-    sha256 = "1m3bx6c2s958qligl67q7grkwfz3w53hpy7nc97mh6f7j5k168c4";
-  })
-  (fetchNuGet {
-    pname = "System.Drawing.Common";
-    version = "7.0.0";
-    sha256 = "0jwyv5zjxzr4bm4vhmz394gsxqa02q6pxdqd2hwy1f116f0l30dp";
-  })
-  (fetchNuGet {
-    pname = "System.Dynamic.Runtime";
-    version = "4.0.11";
-    sha256 = "1pla2dx8gkidf7xkciig6nifdsb494axjvzvann8g2lp3dbqasm9";
-  })
-  (fetchNuGet {
-    pname = "System.Dynamic.Runtime";
-    version = "4.3.0";
-    sha256 = "1d951hrvrpndk7insiag80qxjbf2y0y39y8h5hnq9612ws661glk";
-  })
-  (fetchNuGet {
-    pname = "System.Formats.Asn1";
-    version = "7.0.0";
-    sha256 = "1a14kgpqz4k7jhi7bs2gpgf67ym5wpj99203zxgwjypj7x47xhbq";
-  })
-  (fetchNuGet {
-    pname = "System.Globalization";
-    version = "4.0.11";
-    sha256 = "070c5jbas2v7smm660zaf1gh0489xanjqymkvafcs4f8cdrs1d5d";
-  })
-  (fetchNuGet {
-    pname = "System.Globalization";
-    version = "4.3.0";
-    sha256 = "1cp68vv683n6ic2zqh2s1fn4c2sd87g5hpp6l4d4nj4536jz98ki";
-  })
-  (fetchNuGet {
-    pname = "System.Globalization.Calendars";
-    version = "4.0.1";
-    sha256 = "0bv0alrm2ck2zk3rz25lfyk9h42f3ywq77mx1syl6vvyncnpg4qh";
-  })
-  (fetchNuGet {
-    pname = "System.Globalization.Calendars";
-    version = "4.3.0";
-    sha256 = "1xwl230bkakzzkrggy1l1lxmm3xlhk4bq2pkv790j5lm8g887lxq";
-  })
-  (fetchNuGet {
-    pname = "System.Globalization.Extensions";
-    version = "4.0.1";
-    sha256 = "0hjhdb5ri8z9l93bw04s7ynwrjrhx2n0p34sf33a9hl9phz69fyc";
-  })
-  (fetchNuGet {
-    pname = "System.Globalization.Extensions";
-    version = "4.3.0";
-    sha256 = "02a5zfxavhv3jd437bsncbhd2fp1zv4gxzakp1an9l6kdq1mcqls";
-  })
-  (fetchNuGet {
-    pname = "System.IdentityModel.Tokens.Jwt";
-    version = "5.6.0";
-    sha256 = "146avzhn87ik22zww3dcs0a5qdk8kzcwzv4qby8g9h6blh3sp72h";
-  })
-  (fetchNuGet {
-    pname = "System.IdentityModel.Tokens.Jwt";
-    version = "6.27.0";
-    sha256 = "0fihix48dk0jrkawby62fs163dv5hsh63vdhdyp7hfz6nabsqs2j";
-  })
-  (fetchNuGet {
-    pname = "System.IO";
-    version = "4.1.0";
-    sha256 = "1g0yb8p11vfd0kbkyzlfsbsp5z44lwsvyc0h3dpw6vqnbi035ajp";
-  })
-  (fetchNuGet {
-    pname = "System.IO";
-    version = "4.3.0";
-    sha256 = "05l9qdrzhm4s5dixmx68kxwif4l99ll5gqmh7rqgw554fx0agv5f";
-  })
-  (fetchNuGet {
-    pname = "System.IO.Compression";
-    version = "4.1.0";
-    sha256 = "0iym7s3jkl8n0vzm3jd6xqg9zjjjqni05x45dwxyjr2dy88hlgji";
-  })
-  (fetchNuGet {
-    pname = "System.IO.Compression";
-    version = "4.3.0";
-    sha256 = "084zc82yi6yllgda0zkgl2ys48sypiswbiwrv7irb3r0ai1fp4vz";
-  })
-  (fetchNuGet {
-    pname = "System.IO.Compression.ZipFile";
-    version = "4.0.1";
-    sha256 = "0h72znbagmgvswzr46mihn7xm7chfk2fhrp5krzkjf29pz0i6z82";
-  })
-  (fetchNuGet {
-    pname = "System.IO.Compression.ZipFile";
-    version = "4.3.0";
-    sha256 = "1yxy5pq4dnsm9hlkg9ysh5f6bf3fahqqb6p8668ndy5c0lk7w2ar";
-  })
-  (fetchNuGet {
-    pname = "System.IO.FileSystem";
-    version = "4.0.1";
-    sha256 = "0kgfpw6w4djqra3w5crrg8xivbanh1w9dh3qapb28q060wb9flp1";
-  })
-  (fetchNuGet {
-    pname = "System.IO.FileSystem";
-    version = "4.3.0";
-    sha256 = "0z2dfrbra9i6y16mm9v1v6k47f0fm617vlb7s5iybjjsz6g1ilmw";
-  })
-  (fetchNuGet {
-    pname = "System.IO.FileSystem.Primitives";
-    version = "4.0.1";
-    sha256 = "1s0mniajj3lvbyf7vfb5shp4ink5yibsx945k6lvxa96r8la1612";
-  })
-  (fetchNuGet {
-    pname = "System.IO.FileSystem.Primitives";
-    version = "4.3.0";
-    sha256 = "0j6ndgglcf4brg2lz4wzsh1av1gh8xrzdsn9f0yznskhqn1xzj9c";
-  })
-  (fetchNuGet {
-    pname = "System.IO.FileSystem.Watcher";
-    version = "4.0.0";
-    sha256 = "0rgfjiqz8dqy8hmbfsls4sa46ss6p9vh86cvn1vqx7zg45pf3hir";
-  })
-  (fetchNuGet {
-    pname = "System.IO.MemoryMappedFiles";
-    version = "4.0.0";
-    sha256 = "1ahp27llf76ngc0fngl8zy4y1sgflzrkmxddilnd0l0cbbq1lm6m";
-  })
-  (fetchNuGet {
-    pname = "System.IO.UnmanagedMemoryStream";
-    version = "4.0.1";
-    sha256 = "012g8nwbfv94rhblsb3pxn1bazfpgjiy3kmy00679gg3651b87jb";
-  })
-  (fetchNuGet {
-    pname = "System.Linq";
-    version = "4.1.0";
-    sha256 = "1ppg83svb39hj4hpp5k7kcryzrf3sfnm08vxd5sm2drrijsla2k5";
-  })
-  (fetchNuGet {
-    pname = "System.Linq";
-    version = "4.3.0";
-    sha256 = "1w0gmba695rbr80l1k2h4mrwzbzsyfl2z4klmpbsvsg5pm4a56s7";
-  })
-  (fetchNuGet {
-    pname = "System.Linq.Async";
-    version = "6.0.1";
-    sha256 = "10ira8hmv0i54yp9ggrrdm1c06j538sijfjpn1kmnh9j2xk5yzmq";
-  })
-  (fetchNuGet {
-    pname = "System.Linq.Expressions";
-    version = "4.1.0";
-    sha256 = "1gpdxl6ip06cnab7n3zlcg6mqp7kknf73s8wjinzi4p0apw82fpg";
-  })
-  (fetchNuGet {
-    pname = "System.Linq.Expressions";
-    version = "4.3.0";
-    sha256 = "0ky2nrcvh70rqq88m9a5yqabsl4fyd17bpr63iy2mbivjs2nyypv";
-  })
-  (fetchNuGet {
-    pname = "System.Linq.Parallel";
-    version = "4.0.1";
-    sha256 = "0i33x9f4h3yq26yvv6xnq4b0v51rl5z8v1bm7vk972h5lvf4apad";
-  })
-  (fetchNuGet {
-    pname = "System.Linq.Queryable";
-    version = "4.0.1";
-    sha256 = "11jn9k34g245yyf260gr3ldzvaqa9477w2c5nhb1p8vjx4xm3qaw";
-  })
-  (fetchNuGet {
-    pname = "System.Management";
-    version = "5.0.0";
-    sha256 = "09hyv3p0zd549577clydlb2szl84m4gvdjnsry73n8b12ja7d75s";
-  })
-  (fetchNuGet {
-    pname = "System.Memory";
-    version = "4.5.0";
-    sha256 = "1layqpcx1q4l805fdnj2dfqp6ncx2z42ca06rgsr6ikq4jjgbv30";
-  })
-  (fetchNuGet {
-    pname = "System.Memory";
-    version = "4.5.1";
-    sha256 = "0f07d7hny38lq9w69wx4lxkn4wszrqf9m9js6fh9is645csm167c";
-  })
-  (fetchNuGet {
-    pname = "System.Memory";
-    version = "4.5.3";
-    sha256 = "0naqahm3wljxb5a911d37mwjqjdxv9l0b49p5dmfyijvni2ppy8a";
-  })
-  (fetchNuGet {
-    pname = "System.Memory";
-    version = "4.5.4";
-    sha256 = "14gbbs22mcxwggn0fcfs1b062521azb9fbb7c113x0mq6dzq9h6y";
-  })
-  (fetchNuGet {
-    pname = "System.Net.Http";
-    version = "4.1.0";
-    sha256 = "1i5rqij1icg05j8rrkw4gd4pgia1978mqhjzhsjg69lvwcdfg8yb";
-  })
-  (fetchNuGet {
-    pname = "System.Net.Http";
-    version = "4.3.0";
-    sha256 = "1i4gc757xqrzflbk7kc5ksn20kwwfjhw9w7pgdkn19y3cgnl302j";
-  })
-  (fetchNuGet {
-    pname = "System.Net.Http";
-    version = "4.3.4";
-    sha256 = "0kdp31b8819v88l719j6my0yas6myv9d1viql3qz5577mv819jhl";
-  })
-  (fetchNuGet {
-    pname = "System.Net.NameResolution";
-    version = "4.0.0";
-    sha256 = "0dj3pvpv069nyia28gkl4a0fb7q33hbxz2dg25qvpah3l7pbl0qh";
-  })
-  (fetchNuGet {
-    pname = "System.Net.NameResolution";
-    version = "4.3.0";
-    sha256 = "15r75pwc0rm3vvwsn8rvm2krf929mjfwliv0mpicjnii24470rkq";
-  })
-  (fetchNuGet {
-    pname = "System.Net.Primitives";
-    version = "4.0.11";
-    sha256 = "10xzzaynkzkakp7jai1ik3r805zrqjxiz7vcagchyxs2v26a516r";
-  })
-  (fetchNuGet {
-    pname = "System.Net.Primitives";
-    version = "4.3.0";
-    sha256 = "0c87k50rmdgmxx7df2khd9qj7q35j9rzdmm2572cc55dygmdk3ii";
-  })
-  (fetchNuGet {
-    pname = "System.Net.Requests";
-    version = "4.0.11";
-    sha256 = "13mka55sa6dg6nw4zdrih44gnp8hnj5azynz47ljsh2791lz3d9h";
-  })
-  (fetchNuGet {
-    pname = "System.Net.Security";
-    version = "4.0.0";
-    sha256 = "0ybyfssnm0cri37byhxnkfrzprz77nizbfj553x7s1vry2pnm5gb";
-  })
-  (fetchNuGet {
-    pname = "System.Net.Sockets";
-    version = "4.1.0";
-    sha256 = "1385fvh8h29da5hh58jm1v78fzi9fi5vj93vhlm2kvqpfahvpqls";
-  })
-  (fetchNuGet {
-    pname = "System.Net.Sockets";
-    version = "4.3.0";
-    sha256 = "1ssa65k6chcgi6mfmzrznvqaxk8jp0gvl77xhf1hbzakjnpxspla";
-  })
-  (fetchNuGet {
-    pname = "System.Net.WebHeaderCollection";
-    version = "4.0.1";
-    sha256 = "10bxpxj80c4z00z3ksrfswspq9qqsw8jwxcbzvymzycb97m9b55q";
-  })
-  (fetchNuGet {
-    pname = "System.Net.WebSockets.WebSocketProtocol";
-    version = "4.5.3";
-    sha256 = "0z9ccndkkq6gpsh35q3pjm4zya47p6vakcyj8nc352g4wiizqc8c";
-  })
-  (fetchNuGet {
-    pname = "System.Numerics.Vectors";
-    version = "4.1.1";
-    sha256 = "1xkzrpl700pp0l6dc9fx7cj318i596w0i0qixsbrz5v65fnhbzia";
-  })
-  (fetchNuGet {
-    pname = "System.ObjectModel";
-    version = "4.0.12";
-    sha256 = "1sybkfi60a4588xn34nd9a58png36i0xr4y4v4kqpg8wlvy5krrj";
-  })
-  (fetchNuGet {
-    pname = "System.ObjectModel";
-    version = "4.3.0";
-    sha256 = "191p63zy5rpqx7dnrb3h7prvgixmk168fhvvkkvhlazncf8r3nc2";
-  })
-  (fetchNuGet {
-    pname = "System.Private.Uri";
-    version = "4.3.0";
-    sha256 = "04r1lkdnsznin0fj4ya1zikxiqr0h6r6a1ww2dsm60gqhdrf0mvx";
-  })
-  (fetchNuGet {
-    pname = "System.Reactive";
-    version = "4.3.2";
-    sha256 = "1ibfp7g9sy32rx08dlz9kqgs5a3c22y40nm5sb4f66i5yd3v3sks";
-  })
-  (fetchNuGet {
-    pname = "System.Reflection";
-    version = "4.1.0";
-    sha256 = "1js89429pfw79mxvbzp8p3q93il6rdff332hddhzi5wqglc4gml9";
-  })
-  (fetchNuGet {
-    pname = "System.Reflection";
-    version = "4.3.0";
-    sha256 = "0xl55k0mw8cd8ra6dxzh974nxif58s3k1rjv1vbd7gjbjr39j11m";
-  })
-  (fetchNuGet {
-    pname = "System.Reflection.DispatchProxy";
-    version = "4.0.1";
-    sha256 = "1maglcnvm3h8bfmx3rvwg4wjda7527iqp38cg1r6vh9japrw1n0r";
-  })
-  (fetchNuGet {
-    pname = "System.Reflection.Emit";
-    version = "4.0.1";
-    sha256 = "0ydqcsvh6smi41gyaakglnv252625hf29f7kywy2c70nhii2ylqp";
-  })
-  (fetchNuGet {
-    pname = "System.Reflection.Emit";
-    version = "4.3.0";
-    sha256 = "11f8y3qfysfcrscjpjym9msk7lsfxkk4fmz9qq95kn3jd0769f74";
-  })
-  (fetchNuGet {
-    pname = "System.Reflection.Emit";
-    version = "4.7.0";
-    sha256 = "121l1z2ypwg02yz84dy6gr82phpys0njk7yask3sihgy214w43qp";
-  })
-  (fetchNuGet {
-    pname = "System.Reflection.Emit.ILGeneration";
-    version = "4.0.1";
-    sha256 = "1pcd2ig6bg144y10w7yxgc9d22r7c7ww7qn1frdfwgxr24j9wvv0";
-  })
-  (fetchNuGet {
-    pname = "System.Reflection.Emit.ILGeneration";
-    version = "4.3.0";
-    sha256 = "0w1n67glpv8241vnpz1kl14sy7zlnw414aqwj4hcx5nd86f6994q";
-  })
-  (fetchNuGet {
-    pname = "System.Reflection.Emit.Lightweight";
-    version = "4.0.1";
-    sha256 = "1s4b043zdbx9k39lfhvsk68msv1nxbidhkq6nbm27q7sf8xcsnxr";
-  })
-  (fetchNuGet {
-    pname = "System.Reflection.Emit.Lightweight";
-    version = "4.3.0";
-    sha256 = "0ql7lcakycrvzgi9kxz1b3lljd990az1x6c4jsiwcacrvimpib5c";
-  })
-  (fetchNuGet {
-    pname = "System.Reflection.Extensions";
-    version = "4.0.1";
-    sha256 = "0m7wqwq0zqq9gbpiqvgk3sr92cbrw7cp3xn53xvw7zj6rz6fdirn";
-  })
-  (fetchNuGet {
-    pname = "System.Reflection.Extensions";
-    version = "4.3.0";
-    sha256 = "02bly8bdc98gs22lqsfx9xicblszr2yan7v2mmw3g7hy6miq5hwq";
-  })
-  (fetchNuGet {
-    pname = "System.Reflection.Metadata";
-    version = "1.3.0";
-    sha256 = "1y5m6kryhjpqqm2g3h3b6bzig13wkiw954x3b7icqjm6xypm1x3b";
-  })
-  (fetchNuGet {
-    pname = "System.Reflection.Metadata";
-    version = "1.6.0";
-    sha256 = "1wdbavrrkajy7qbdblpbpbalbdl48q3h34cchz24gvdgyrlf15r4";
-  })
-  (fetchNuGet {
-    pname = "System.Reflection.Primitives";
-    version = "4.0.1";
-    sha256 = "1bangaabhsl4k9fg8khn83wm6yial8ik1sza7401621jc6jrym28";
-  })
-  (fetchNuGet {
-    pname = "System.Reflection.Primitives";
-    version = "4.3.0";
-    sha256 = "04xqa33bld78yv5r93a8n76shvc8wwcdgr1qvvjh959g3rc31276";
-  })
-  (fetchNuGet {
-    pname = "System.Reflection.TypeExtensions";
-    version = "4.1.0";
-    sha256 = "1bjli8a7sc7jlxqgcagl9nh8axzfl11f4ld3rjqsyxc516iijij7";
-  })
-  (fetchNuGet {
-    pname = "System.Reflection.TypeExtensions";
-    version = "4.3.0";
-    sha256 = "0y2ssg08d817p0vdag98vn238gyrrynjdj4181hdg780sif3ykp1";
-  })
-  (fetchNuGet {
-    pname = "System.Resources.Reader";
-    version = "4.0.0";
-    sha256 = "1jafi73dcf1lalrir46manq3iy6xnxk2z7gpdpwg4wqql7dv3ril";
-  })
-  (fetchNuGet {
-    pname = "System.Resources.ResourceManager";
-    version = "4.0.1";
-    sha256 = "0b4i7mncaf8cnai85jv3wnw6hps140cxz8vylv2bik6wyzgvz7bi";
-  })
-  (fetchNuGet {
-    pname = "System.Resources.ResourceManager";
-    version = "4.3.0";
-    sha256 = "0sjqlzsryb0mg4y4xzf35xi523s4is4hz9q4qgdvlvgivl7qxn49";
-  })
-  (fetchNuGet {
-    pname = "System.Runtime";
-    version = "4.1.0";
-    sha256 = "02hdkgk13rvsd6r9yafbwzss8kr55wnj8d5c7xjnp8gqrwc8sn0m";
-  })
-  (fetchNuGet {
-    pname = "System.Runtime";
-    version = "4.3.0";
-    sha256 = "066ixvgbf2c929kgknshcxqj6539ax7b9m570cp8n179cpfkapz7";
-  })
-  (fetchNuGet {
-    pname = "System.Runtime.Caching";
-    version = "7.0.0";
-    sha256 = "12k47lvi12x9idn18bq2hls2zcwx9qfag05scbm0ji5akzplwlyq";
-  })
-  (fetchNuGet {
-    pname = "System.Runtime.CompilerServices.Unsafe";
-    version = "4.5.0";
-    sha256 = "17labczwqk3jng3kkky73m0jhi8wc21vbl7cz5c0hj2p1dswin43";
-  })
-  (fetchNuGet {
-    pname = "System.Runtime.CompilerServices.Unsafe";
-    version = "4.5.1";
-    sha256 = "1xcrjx5fwg284qdnxyi2d0lzdm5q4frlpkp0nf6vvkx1kdz2prrf";
-  })
-  (fetchNuGet {
-    pname = "System.Runtime.CompilerServices.Unsafe";
-    version = "5.0.0";
-    sha256 = "02k25ivn50dmqx5jn8hawwmz24yf0454fjd823qk6lygj9513q4x";
-  })
-  (fetchNuGet {
-    pname = "System.Runtime.CompilerServices.Unsafe";
-    version = "6.0.0";
-    sha256 = "0qm741kh4rh57wky16sq4m0v05fxmkjjr87krycf5vp9f0zbahbc";
-  })
-  (fetchNuGet {
-    pname = "System.Runtime.Extensions";
-    version = "4.1.0";
-    sha256 = "0rw4rm4vsm3h3szxp9iijc3ksyviwsv6f63dng3vhqyg4vjdkc2z";
-  })
-  (fetchNuGet {
-    pname = "System.Runtime.Extensions";
-    version = "4.3.0";
-    sha256 = "1ykp3dnhwvm48nap8q23893hagf665k0kn3cbgsqpwzbijdcgc60";
-  })
-  (fetchNuGet {
-    pname = "System.Runtime.Handles";
-    version = "4.0.1";
-    sha256 = "1g0zrdi5508v49pfm3iii2hn6nm00bgvfpjq1zxknfjrxxa20r4g";
-  })
-  (fetchNuGet {
-    pname = "System.Runtime.Handles";
-    version = "4.3.0";
-    sha256 = "0sw2gfj2xr7sw9qjn0j3l9yw07x73lcs97p8xfc9w1x9h5g5m7i8";
-  })
-  (fetchNuGet {
-    pname = "System.Runtime.InteropServices";
-    version = "4.1.0";
-    sha256 = "01kxqppx3dr3b6b286xafqilv4s2n0gqvfgzfd4z943ga9i81is1";
-  })
-  (fetchNuGet {
-    pname = "System.Runtime.InteropServices";
-    version = "4.3.0";
-    sha256 = "00hywrn4g7hva1b2qri2s6rabzwgxnbpw9zfxmz28z09cpwwgh7j";
-  })
-  (fetchNuGet {
-    pname = "System.Runtime.InteropServices.RuntimeInformation";
-    version = "4.0.0";
-    sha256 = "0glmvarf3jz5xh22iy3w9v3wyragcm4hfdr17v90vs7vcrm7fgp6";
-  })
-  (fetchNuGet {
-    pname = "System.Runtime.InteropServices.RuntimeInformation";
-    version = "4.3.0";
-    sha256 = "0q18r1sh4vn7bvqgd6dmqlw5v28flbpj349mkdish2vjyvmnb2ii";
-  })
-  (fetchNuGet {
-    pname = "System.Runtime.Loader";
-    version = "4.0.0";
-    sha256 = "0lpfi3psqcp6zxsjk2qyahal7zaawviimc8lhrlswhip2mx7ykl0";
-  })
-  (fetchNuGet {
-    pname = "System.Runtime.Numerics";
-    version = "4.0.1";
-    sha256 = "1y308zfvy0l5nrn46mqqr4wb4z1xk758pkk8svbz8b5ij7jnv4nn";
-  })
-  (fetchNuGet {
-    pname = "System.Runtime.Numerics";
-    version = "4.3.0";
-    sha256 = "19rav39sr5dky7afygh309qamqqmi9kcwvz3i0c5700v0c5cg61z";
-  })
-  (fetchNuGet {
-    pname = "System.Security.AccessControl";
-    version = "5.0.0";
-    sha256 = "17n3lrrl6vahkqmhlpn3w20afgz09n7i6rv0r3qypngwi7wqdr5r";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Claims";
-    version = "4.0.1";
-    sha256 = "03dw0ls49bvsrffgwycyifjgz0qzr9r85skqhdyhfd51fqf398n6";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Claims";
-    version = "4.3.0";
-    sha256 = "0jvfn7j22l3mm28qjy3rcw287y9h65ha4m940waaxah07jnbzrhn";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Cryptography.Algorithms";
-    version = "4.2.0";
-    sha256 = "148s9g5dgm33ri7dnh19s4lgnlxbpwvrw2jnzllq2kijj4i4vs85";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Cryptography.Algorithms";
-    version = "4.3.0";
-    sha256 = "03sq183pfl5kp7gkvq77myv7kbpdnq3y0xj7vi4q1kaw54sny0ml";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Cryptography.Cng";
-    version = "4.2.0";
-    sha256 = "118jijz446kix20blxip0f0q8mhsh9bz118mwc2ch1p6g7facpzc";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Cryptography.Cng";
-    version = "4.3.0";
-    sha256 = "1k468aswafdgf56ab6yrn7649kfqx2wm9aslywjam1hdmk5yypmv";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Cryptography.Cng";
-    version = "4.5.0";
-    sha256 = "1pm4ykbcz48f1hdmwpia432ha6qbb9kbrxrrp7cg3m8q8xn52ngn";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Cryptography.Csp";
-    version = "4.0.0";
-    sha256 = "1cwv8lqj8r15q81d2pz2jwzzbaji0l28xfrpw29kdpsaypm92z2q";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Cryptography.Csp";
-    version = "4.3.0";
-    sha256 = "1x5wcrddf2s3hb8j78cry7yalca4lb5vfnkrysagbn6r9x6xvrx1";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Cryptography.Encoding";
-    version = "4.0.0";
-    sha256 = "0a8y1a5wkmpawc787gfmnrnbzdgxmx1a14ax43jf3rj9gxmy3vk4";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Cryptography.Encoding";
-    version = "4.3.0";
-    sha256 = "1jr6w70igqn07k5zs1ph6xja97hxnb3mqbspdrff6cvssgrixs32";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Cryptography.OpenSsl";
-    version = "4.0.0";
-    sha256 = "16sx3cig3d0ilvzl8xxgffmxbiqx87zdi8fc73i3i7zjih1a7f4q";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Cryptography.OpenSsl";
-    version = "4.3.0";
-    sha256 = "0givpvvj8yc7gv4lhb6s1prq6p2c4147204a0wib89inqzd87gqc";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Cryptography.Pkcs";
-    version = "7.0.0";
-    sha256 = "0834gh4k84xbv73mk6s9djkksq3bd6m2k1ixincjnaawv0pyz7fw";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Cryptography.Primitives";
-    version = "4.0.0";
-    sha256 = "0i7cfnwph9a10bm26m538h5xcr8b36jscp9sy1zhgifksxz4yixh";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Cryptography.Primitives";
-    version = "4.3.0";
-    sha256 = "0pyzncsv48zwly3lw4f2dayqswcfvdwq2nz0dgwmi7fj3pn64wby";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Cryptography.ProtectedData";
-    version = "4.4.0";
-    sha256 = "1q8ljvqhasyynp94a1d7jknk946m20lkwy2c3wa8zw2pc517fbj6";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Cryptography.ProtectedData";
-    version = "7.0.0";
-    sha256 = "15s9s6hsj9bz0nzw41mxbqdjgjd71w2djqbv0aj413gfi9amybk9";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Cryptography.ProtectedData";
-    version = "7.0.1";
-    sha256 = "1nq9ngkqha70rv41692c79zq09cx6m85wkp3xj9yc31s62afyl5i";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Cryptography.X509Certificates";
-    version = "4.1.0";
-    sha256 = "0clg1bv55mfv5dq00m19cp634zx6inm31kf8ppbq1jgyjf2185dh";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Cryptography.X509Certificates";
-    version = "4.3.0";
-    sha256 = "0valjcz5wksbvijylxijjxb1mp38mdhv03r533vnx1q3ikzdav9h";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Cryptography.Xml";
-    version = "7.0.1";
-    sha256 = "0p6kx6ag0il7rxxcvm84w141phvr7fafjzxybf920bxwa0jkwzq8";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Permissions";
-    version = "7.0.0";
-    sha256 = "0wkm6bj4abknzj41ygkziifx8mzhj4bix92wjvj6lihaw1gniq8c";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Principal";
-    version = "4.0.1";
-    sha256 = "1nbzdfqvzzbgsfdd5qsh94d7dbg2v4sw0yx6himyn52zf8z6007p";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Principal";
-    version = "4.3.0";
-    sha256 = "12cm2zws06z4lfc4dn31iqv7072zyi4m910d4r6wm8yx85arsfxf";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Principal.Windows";
-    version = "4.0.0";
-    sha256 = "1d3vc8i0zss9z8p4qprls4gbh7q4218l9845kclx7wvw41809k6z";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Principal.Windows";
-    version = "4.3.0";
-    sha256 = "00a0a7c40i3v4cb20s2cmh9csb5jv2l0frvnlzyfxh848xalpdwr";
-  })
-  (fetchNuGet {
-    pname = "System.Security.Principal.Windows";
-    version = "5.0.0";
-    sha256 = "1mpk7xj76lxgz97a5yg93wi8lj0l8p157a5d50mmjy3gbz1904q8";
-  })
-  (fetchNuGet {
-    pname = "System.Text.Encoding";
-    version = "4.0.11";
-    sha256 = "1dyqv0hijg265dwxg6l7aiv74102d6xjiwplh2ar1ly6xfaa4iiw";
-  })
-  (fetchNuGet {
-    pname = "System.Text.Encoding";
-    version = "4.3.0";
-    sha256 = "1f04lkir4iladpp51sdgmis9dj4y8v08cka0mbmsy0frc9a4gjqr";
-  })
-  (fetchNuGet {
-    pname = "System.Text.Encoding.CodePages";
-    version = "4.0.1";
-    sha256 = "00wpm3b9y0k996rm9whxprngm8l500ajmzgy2ip9pgwk0icp06y3";
-  })
-  (fetchNuGet {
-    pname = "System.Text.Encoding.Extensions";
-    version = "4.0.11";
-    sha256 = "08nsfrpiwsg9x5ml4xyl3zyvjfdi4mvbqf93kjdh11j4fwkznizs";
-  })
-  (fetchNuGet {
-    pname = "System.Text.Encoding.Extensions";
-    version = "4.3.0";
-    sha256 = "11q1y8hh5hrp5a3kw25cb6l00v5l5dvirkz8jr3sq00h1xgcgrxy";
-  })
-  (fetchNuGet {
-    pname = "System.Text.Encodings.Web";
-    version = "4.5.0";
-    sha256 = "0srd5bva52n92i90wd88pzrqjsxnfgka3ilybwh7s6sf469y5s53";
-  })
-  (fetchNuGet {
-    pname = "System.Text.Encodings.Web";
-    version = "4.7.2";
-    sha256 = "0ap286ykazrl42if59bxhzv81safdfrrmfqr3112siwyajx4wih9";
-  })
-  (fetchNuGet {
-    pname = "System.Text.Encodings.Web";
-    version = "6.0.0";
-    sha256 = "06n9ql3fmhpjl32g3492sj181zjml5dlcc5l76xq2h38c4f87sai";
-  })
-  (fetchNuGet {
-    pname = "System.Text.Encodings.Web";
-    version = "7.0.0";
-    sha256 = "1151hbyrcf8kyg1jz8k9awpbic98lwz9x129rg7zk1wrs6vjlpxl";
-  })
-  (fetchNuGet {
-    pname = "System.Text.Json";
-    version = "4.7.2";
-    sha256 = "10xj1pw2dgd42anikvj9qm23ccssrcp7dpznpj4j7xjp1ikhy3y4";
-  })
-  (fetchNuGet {
-    pname = "System.Text.Json";
-    version = "6.0.0";
-    sha256 = "1si2my1g0q0qv1hiqnji4xh9wd05qavxnzj9dwgs23iqvgjky0gl";
-  })
-  (fetchNuGet {
-    pname = "System.Text.Json";
-    version = "6.0.5";
-    sha256 = "12fg196sdq3gcjcz365kypfkkmdrprpcw2fvjnww9jqa4yn8v99l";
-  })
-  (fetchNuGet {
-    pname = "System.Text.Json";
-    version = "7.0.0";
-    sha256 = "0scb0lp7wbgcinaa4kqiqs7b8i5nx4ppfad81138jiwd1sl37pyp";
-  })
-  (fetchNuGet {
-    pname = "System.Text.RegularExpressions";
-    version = "4.1.0";
-    sha256 = "1mw7vfkkyd04yn2fbhm38msk7dz2xwvib14ygjsb8dq2lcvr18y7";
-  })
-  (fetchNuGet {
-    pname = "System.Text.RegularExpressions";
-    version = "4.3.0";
-    sha256 = "1bgq51k7fwld0njylfn7qc5fmwrk2137gdq7djqdsw347paa9c2l";
-  })
-  (fetchNuGet {
-    pname = "System.Threading";
-    version = "4.0.11";
-    sha256 = "19x946h926bzvbsgj28csn46gak2crv2skpwsx80hbgazmkgb1ls";
-  })
-  (fetchNuGet {
-    pname = "System.Threading";
-    version = "4.3.0";
-    sha256 = "0rw9wfamvhayp5zh3j7p1yfmx9b5khbf4q50d8k5rk993rskfd34";
-  })
-  (fetchNuGet {
-    pname = "System.Threading.Channels";
-    version = "4.7.0";
-    sha256 = "1cb9arib2xzf8kc8nzgla8lyhs8qzddjx5n4hwbp5vrm81ihhsi1";
-  })
-  (fetchNuGet {
-    pname = "System.Threading.Overlapped";
-    version = "4.0.1";
-    sha256 = "0fi79az3vmqdp9mv3wh2phblfjls89zlj6p9nc3i9f6wmfarj188";
-  })
-  (fetchNuGet {
-    pname = "System.Threading.Tasks";
-    version = "4.0.11";
-    sha256 = "0nr1r41rak82qfa5m0lhk9mp0k93bvfd7bbd9sdzwx9mb36g28p5";
-  })
-  (fetchNuGet {
-    pname = "System.Threading.Tasks";
-    version = "4.3.0";
-    sha256 = "134z3v9abw3a6jsw17xl3f6hqjpak5l682k2vz39spj4kmydg6k7";
-  })
-  (fetchNuGet {
-    pname = "System.Threading.Tasks.Dataflow";
-    version = "4.6.0";
-    sha256 = "0a1davr71wssyn4z1hr75lk82wqa0daz0vfwkmg1fm3kckfd72k1";
-  })
-  (fetchNuGet {
-    pname = "System.Threading.Tasks.Extensions";
-    version = "4.0.0";
-    sha256 = "1cb51z062mvc2i8blpzmpn9d9mm4y307xrwi65di8ri18cz5r1zr";
-  })
-  (fetchNuGet {
-    pname = "System.Threading.Tasks.Extensions";
-    version = "4.3.0";
-    sha256 = "1xxcx2xh8jin360yjwm4x4cf5y3a2bwpn2ygkfkwkicz7zk50s2z";
-  })
-  (fetchNuGet {
-    pname = "System.Threading.Tasks.Parallel";
-    version = "4.0.1";
-    sha256 = "114wdg32hr46dfsnns3pgs67kcha5jn47p5gg0mhxfn5vrkr2p75";
-  })
-  (fetchNuGet {
-    pname = "System.Threading.Thread";
-    version = "4.0.0";
-    sha256 = "1gxxm5fl36pjjpnx1k688dcw8m9l7nmf802nxis6swdaw8k54jzc";
-  })
-  (fetchNuGet {
-    pname = "System.Threading.ThreadPool";
-    version = "4.0.10";
-    sha256 = "0fdr61yjcxh5imvyf93n2m3n5g9pp54bnw2l1d2rdl9z6dd31ypx";
-  })
-  (fetchNuGet {
-    pname = "System.Threading.ThreadPool";
-    version = "4.3.0";
-    sha256 = "027s1f4sbx0y1xqw2irqn6x161lzj8qwvnh2gn78ciiczdv10vf1";
-  })
-  (fetchNuGet {
-    pname = "System.Threading.Timer";
-    version = "4.0.1";
-    sha256 = "15n54f1f8nn3mjcjrlzdg6q3520571y012mx7v991x2fvp73lmg6";
-  })
-  (fetchNuGet {
-    pname = "System.Threading.Timer";
-    version = "4.3.0";
-    sha256 = "1nx773nsx6z5whv8kaa1wjh037id2f1cxhb69pvgv12hd2b6qs56";
-  })
-  (fetchNuGet {
-    pname = "System.ValueTuple";
-    version = "4.3.0";
-    sha256 = "1227k7fxbxapq7dms4lvwwjdf3pr1jcsmhy2nzzhj6g6hs530hxn";
-  })
-  (fetchNuGet {
-    pname = "System.Windows.Extensions";
-    version = "7.0.0";
-    sha256 = "11r9f0v7qp365bdpq5ax023yra4qvygljz18dlqs650d44iay669";
-  })
-  (fetchNuGet {
-    pname = "System.Xml.ReaderWriter";
-    version = "4.0.11";
-    sha256 = "0c6ky1jk5ada9m94wcadih98l6k1fvf6vi7vhn1msjixaha419l5";
-  })
-  (fetchNuGet {
-    pname = "System.Xml.ReaderWriter";
-    version = "4.3.0";
-    sha256 = "0c47yllxifzmh8gq6rq6l36zzvw4kjvlszkqa9wq3fr59n0hl3s1";
-  })
-  (fetchNuGet {
-    pname = "System.Xml.XDocument";
-    version = "4.0.11";
-    sha256 = "0n4lvpqzy9kc7qy1a4acwwd7b7pnvygv895az5640idl2y9zbz18";
-  })
-  (fetchNuGet {
-    pname = "System.Xml.XDocument";
-    version = "4.3.0";
-    sha256 = "08h8fm4l77n0nd4i4fk2386y809bfbwqb7ih9d7564ifcxr5ssxd";
-  })
-  (fetchNuGet {
-    pname = "System.Xml.XmlDocument";
-    version = "4.0.1";
-    sha256 = "0ihsnkvyc76r4dcky7v3ansnbyqjzkbyyia0ir5zvqirzan0bnl1";
-  })
-  (fetchNuGet {
-    pname = "System.Xml.XPath";
-    version = "4.0.1";
-    sha256 = "0fjqgb6y66d72d5n8qq1h213d9nv2vi8mpv8p28j3m9rccmsh04m";
-  })
-  (fetchNuGet {
-    pname = "System.Xml.XPath.XDocument";
-    version = "4.0.1";
-    sha256 = "1fndc70lbjvh8kxs71c7cidfm8plznd61bg4fwpiyq3mq0qg5z0z";
-  })
-  (fetchNuGet {
-    pname = "Tavis.UriTemplates";
-    version = "2.0.0";
-    sha256 = "089xzz4pcqx1zf8b0crmh1ac6s4bmdr75m1n63hja5j6kqgxbpa5";
-  })
-  (fetchNuGet {
-    pname = "TestableIO.System.IO.Abstractions";
-    version = "19.2.18";
-    sha256 = "1hc3cb2d9138bddpflz6mr2dj38ysfllbggfxidq6aijczwixq0p";
-  })
-  (fetchNuGet {
-    pname = "TestableIO.System.IO.Abstractions.Wrappers";
-    version = "19.2.18";
-    sha256 = "0pl9xjk2jglrhzbvk26b6nrdpzkvp0pwizd5d186w229zhfvmypb";
-  })
-  (fetchNuGet {
-    pname = "Websocket.Client";
-    version = "4.5.2";
-    sha256 = "1gy2q831byip0p2p3a6zzh3j2p9dl2vz84c5kwl8ksal0h685qvh";
-  })
-  (fetchNuGet {
-    pname = "YamlDotNet";
-    version = "13.0.1";
-    sha256 = "07shrvmc4ks6l8zsjjgmabyg5j6smqqlh3lvz9111d8wf3gfdcxy";
-  })
-  (fetchNuGet {
-    pname = "YamlDotNet";
-    version = "8.1.2";
-    sha256 = "1lmi5mdw4067a8yk8gv9kilv1hljflkc45pr5vvz8n09af6gn78b";
-  })
+
+{ fetchNuGet }: [
+  (fetchNuGet { pname = "Antlr4.Runtime.Standard"; version = "4.13.1"; sha256 = "14f9qhqagw0l3x0f1jfv001dp313mp1b9d0jirk99q6qwis93yln"; })
+  (fetchNuGet { pname = "AspNetCore.HealthChecks.UI"; version = "8.0.0"; sha256 = "1pw34cmcqd9c6agd6vd5lqfz1m47fsckzd9yv878chsh9c0x6sip"; })
+  (fetchNuGet { pname = "AspNetCore.HealthChecks.UI.Client"; version = "8.0.0"; sha256 = "17ixaz1nkgmwhfiyn3gwkrk2ffw088c8ifq07v67idgz7pzhnjxi"; })
+  (fetchNuGet { pname = "AspNetCore.HealthChecks.UI.Core"; version = "8.0.0"; sha256 = "1qhihaj1gl4sg31xjw8pwh0lz9m028jrchz3sbp6qafykmrs1m9c"; })
+  (fetchNuGet { pname = "AspNetCore.HealthChecks.UI.Data"; version = "8.0.0"; sha256 = "1xy80hg97i9h5np2whkkqyr55rgg368b1vl69qdj6v0qfqc4ayc3"; })
+  (fetchNuGet { pname = "AspNetCore.HealthChecks.UI.InMemory.Storage"; version = "8.0.0"; sha256 = "19mfj7330hag45ajj1yfl9sp7ddvf95zw5f3s37i3jx4y6v1bf6b"; })
+  (fetchNuGet { pname = "Castle.Core"; version = "5.1.1"; sha256 = "1caf4878nvjid3cw3rw18p9cn53brfs5x8dkvf82xvcdwc3i0nd1"; })
+  (fetchNuGet { pname = "Ckzg.Bindings"; version = "0.4.0.696"; sha256 = "0szzn4s617a6m10vh6rq15fvdnxlfb0id1k7zqsxd4sy9gbj6xbj"; })
+  (fetchNuGet { pname = "Colorful.Console"; version = "1.2.15"; sha256 = "03g8367lchh42jn6iidj10dnlibr8wlbdarsx7zanp3f4z7lf4rw"; })
+  (fetchNuGet { pname = "ConcurrentHashSet"; version = "1.3.0"; sha256 = "04jydfpzv1pwn60m23fl3qgdsvmcd2nrnn68rviixc031j7bhgp6"; })
+  (fetchNuGet { pname = "coverlet.collector"; version = "6.0.0"; sha256 = "12j34vrkmph8lspbafnqmfnj2qvysz1jcrks2khw798s6dwv0j90"; })
+  (fetchNuGet { pname = "coverlet.msbuild"; version = "6.0.0"; sha256 = "18qgg6d0ybrr70g69yqamgn5qvpyizlii1123cnj65amd0w2rxjl"; })
+  (fetchNuGet { pname = "Crc32.NET"; version = "1.2.0"; sha256 = "0qaj3192k1vfji87zf50rhydn5mrzyzybrs2k4v7ap29k8i0vi5h"; })
+  (fetchNuGet { pname = "DiffEngine"; version = "11.3.0"; sha256 = "0pg96189mw221g5ca6ls7g321v34vl6hsxmi7v5ddjjf1dmwp5k9"; })
+  (fetchNuGet { pname = "DnsClient"; version = "1.7.0"; sha256 = "0q6sl7nrwks1xl23z0r097g7b95d0j59r08c21dpbf13fyai9mw5"; })
+  (fetchNuGet { pname = "dotnet-xunit"; version = "2.3.1"; sha256 = "0w1zslkig6qk6rhw6ckfy331rnbfbnxr0gdy2pxgnc8rz2fj2s54"; })
+  (fetchNuGet { pname = "EmptyFiles"; version = "4.4.0"; sha256 = "01i3gdnnsryzimr5nkgkgk40r0wcmwbd38f9zjrs9z5bhijzms6r"; })
+  (fetchNuGet { pname = "FastEnum"; version = "1.8.0"; sha256 = "0czqiqq7v02977wy0mr33z06xlfnw805s3051sqqvacil1n4adcv"; })
+  (fetchNuGet { pname = "FluentAssertions"; version = "6.0.0"; sha256 = "1p5m89rbaqbrn8vr3bs79j8fcdhasn6n3bcxhajp2f5p4mpzv83f"; })
+  (fetchNuGet { pname = "FluentAssertions"; version = "6.12.0"; sha256 = "04fhn67930zv3i0d8xbrbw5vwz99c83bbvgdwqiir55vw5xlys9c"; })
+  (fetchNuGet { pname = "FluentAssertions.Json"; version = "6.1.0"; sha256 = "0mski8r35y4kp0r2q66v5zjck476xccqvaky77kcpjyf8vmbc5d6"; })
+  (fetchNuGet { pname = "Fractions"; version = "7.2.1"; sha256 = "0fmvymy9xwippc9zzxks0hqzjzcl4vyxfddyp6yrrid9v5bd9ysq"; })
+  (fetchNuGet { pname = "FSharp.Core"; version = "6.0.2"; sha256 = "0q4z31i6vw38b6anwjfzxy3ncdazymddi1xyfskkb0s4744ilpi5"; })
+  (fetchNuGet { pname = "Google.Protobuf"; version = "3.25.1"; sha256 = "0zcw9vmv2bdai3zaip86s37lj3r5z4zvcs9mf5a9nih0hy4gzwsi"; })
+  (fetchNuGet { pname = "Google.Protobuf.Tools"; version = "3.25.1"; sha256 = "07n74zkf0lfs6hkrdra0fkymw40h947j5j22c6mzygav3snzj6f2"; })
+  (fetchNuGet { pname = "Grpc"; version = "2.46.6"; sha256 = "1zj2j7h97qdns14z3ilfgqx3kir9p5a05kwsvyz3hpnx2z6j3ysj"; })
+  (fetchNuGet { pname = "Grpc.Core"; version = "2.46.6"; sha256 = "1lyy2l8xxjnfvrf9jxdffms70qqjlz41s0k3y53w637n5qif7hgz"; })
+  (fetchNuGet { pname = "Grpc.Core.Api"; version = "2.46.6"; sha256 = "1c5h83h2snvwvdzyiinqcls01jx87n7jgma3mvhhv01j2q8qqfhy"; })
+  (fetchNuGet { pname = "Grpc.Tools"; version = "2.60.0"; sha256 = "0fb2g5wzsdbjv42f79s1k0s1y07aikdjac8ryn2y40syamjpz0ih"; })
+  (fetchNuGet { pname = "Humanizer.Core"; version = "2.14.1"; sha256 = "1ai7hgr0qwd7xlqfd92immddyi41j3ag91h3594yzfsgsy6yhyqi"; })
+  (fetchNuGet { pname = "IdentityModel"; version = "5.2.0"; sha256 = "1ynvlj2s3q7v5q8fpnql5f8ga0b84jqwgwgadsyqgpllsik5x2mc"; })
+  (fetchNuGet { pname = "IdentityModel.OidcClient"; version = "5.2.1"; sha256 = "10572h3hd5yxm49axjl8xpsh1ni9ikix0xygxap7x4d2kkz5azd9"; })
+  (fetchNuGet { pname = "Jint"; version = "2.11.58"; sha256 = "1nw3mbr1sl198lkwl6bsnfajd3rgw83p63vgi1dackfvx6haywnv"; })
+  (fetchNuGet { pname = "KubernetesClient"; version = "12.1.1"; sha256 = "1awv6zg0p54nnjwfxmba54qmlpgxr9ywv5hccaq48dsv6vk2ygp1"; })
+  (fetchNuGet { pname = "Libuv"; version = "1.9.0"; sha256 = "0ag6l9h1h4knf3hy1fjfrqm6mavr9zw35i0qrnnm8la4mdbcnd0f"; })
+  (fetchNuGet { pname = "MathNet.Numerics"; version = "5.0.0"; sha256 = "0nlrl0rp7h665nafx0g42rqfxmm0pyvk3ydr2y4spilfrra44wj4"; })
+  (fetchNuGet { pname = "MathNet.Numerics.FSharp"; version = "5.0.0"; sha256 = "06x8ppnzlzmb1gswvygqp8n7x0p1jpx76f7g29h30ck6jzqf3xm4"; })
+  (fetchNuGet { pname = "Microsoft.AspNetCore.Cryptography.Internal"; version = "8.0.0"; sha256 = "05qb9r6kz1x32v019za7psjyc7bx7hb7543ngavhmqdd7wz2ni0s"; })
+  (fetchNuGet { pname = "Microsoft.AspNetCore.DataProtection"; version = "8.0.0"; sha256 = "1al0d59q7anw2z66d2wkazk6vp4rfa55p42hp2ja8mz9mwa3047j"; })
+  (fetchNuGet { pname = "Microsoft.AspNetCore.DataProtection.Abstractions"; version = "8.0.0"; sha256 = "18a225dxawbhaawz6pf5d6867kdk5lccwdl7an804ms10kyzh9x5"; })
+  (fetchNuGet { pname = "Microsoft.AspNetCore.DataProtection.Extensions"; version = "8.0.0"; sha256 = "1nfl57pbh9x8x9ry49p5ninkzlmkp4y1mkw89hhyszgpqazr532n"; })
+  (fetchNuGet { pname = "Microsoft.AspNetCore.Http.Abstractions"; version = "2.2.0"; sha256 = "13s8cm6jdpydxmr0rgmzrmnp1v2r7i3rs7v9fhabk5spixdgfy6b"; })
+  (fetchNuGet { pname = "Microsoft.AspNetCore.Http.Extensions"; version = "2.2.0"; sha256 = "118gp1mfb8ymcvw87fzgjqwlc1d1b0l0sbfki291ydg414cz3dfn"; })
+  (fetchNuGet { pname = "Microsoft.AspNetCore.Http.Features"; version = "2.2.0"; sha256 = "0xrlq8i61vzhzzy25n80m7wh2kn593rfaii3aqnxdsxsg6sfgnx1"; })
+  (fetchNuGet { pname = "Microsoft.AspNetCore.WebSockets"; version = "2.2.1"; sha256 = "0gzikr1z2fdz8nzy1m969jsrk2h97ld1hzgmbc6f036qmhiq26hr"; })
+  (fetchNuGet { pname = "Microsoft.Bcl.AsyncInterfaces"; version = "6.0.0"; sha256 = "15gqy2m14fdlvy1g59207h5kisznm355kbw010gy19vh47z8gpz3"; })
+  (fetchNuGet { pname = "Microsoft.ClearScript.Core"; version = "7.4.4"; sha256 = "1i4sxv8v4sq1s7vkis3xc8rllwgwi40fz12890mlvf4xbzggk4ii"; })
+  (fetchNuGet { pname = "Microsoft.ClearScript.V8"; version = "7.4.4"; sha256 = "1a7cc4a1lrpx9y2v75y9s4cj814akm1vj6lar2qxj5hhf8rnxk4m"; })
+  (fetchNuGet { pname = "Microsoft.ClearScript.V8.ICUData"; version = "7.4.4"; sha256 = "0rwy35kb61bvm4ghx4kmhxnlm4bk2c7ddg2gl83zwamv41k261w6"; })
+  (fetchNuGet { pname = "Microsoft.ClearScript.V8.Native.linux-arm64"; version = "7.4.4"; sha256 = "0iaiqxprzb097b9361m1zl6k12jgdb1ij04cr0wdvrjbk6lgc7lg"; })
+  (fetchNuGet { pname = "Microsoft.ClearScript.V8.Native.linux-x64"; version = "7.4.4"; sha256 = "12kf79dwhcdwy6wsc7a2ryq8qf4d5jq1p7kwlbqbnl9b0k7yxhrk"; })
+  (fetchNuGet { pname = "Microsoft.ClearScript.V8.Native.osx-arm64"; version = "7.4.4"; sha256 = "0a5cyawb20yjhpwrb14gdbx1sjdfk1ls9gcn83fvwhvdzvk906dz"; })
+  (fetchNuGet { pname = "Microsoft.ClearScript.V8.Native.osx-x64"; version = "7.4.4"; sha256 = "0vw5jvpz430fx7sbjv1i80l6npiymi2m37l6dl8bvlh565crk76g"; })
+  (fetchNuGet { pname = "Microsoft.ClearScript.V8.Native.win-x64"; version = "7.4.4"; sha256 = "1kwv3rvmb4pp1kp9dw8v0nhjrxfci4xz39gxs5ck0j802w65g7b4"; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Analyzers"; version = "1.1.0"; sha256 = "08r667hj2259wbim1p3al5qxkshydykmb7nd9ygbjlg4mmydkapc"; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Analyzers"; version = "3.3.3"; sha256 = "09m4cpry8ivm9ga1abrxmvw16sslxhy2k5sl14zckhqb1j164im6"; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Common"; version = "1.3.0"; sha256 = "097qi36jhyllpqj313nxzwc64a4f65p014gaj6fz4z5jcphkkk15"; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Common"; version = "4.5.0"; sha256 = "0hjzca7v3qq4wqzi9chgxzycbaysnjgj28ps20695x61sia6i3da"; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.CSharp"; version = "1.3.0"; sha256 = "0vpslncd5lk88ijb42qbp88dfrd0fg4kri44w6jpmxb3fcqazais"; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.CSharp"; version = "4.5.0"; sha256 = "1l6v0ii5lapmfnfpjwi3j5bwlx8v9nvyani5pwvqzdfqsd5m7mp5"; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.CSharp.Workspaces"; version = "4.5.0"; sha256 = "0skg5a8i4fq6cndxcjwciai808p0zpqz9kbvck94mcywfzassv1a"; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.VisualBasic"; version = "1.3.0"; sha256 = "186chky80rryhzh5dh8j318ghyvn1a7r2876rlyadxdrs7aqv0ll"; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Workspaces.Common"; version = "4.5.0"; sha256 = "1wjwsrnn5frahqciwaxsgalv80fs6xhqy6kcqy7hcsh7jrfc1kjq"; })
+  (fetchNuGet { pname = "Microsoft.CodeCoverage"; version = "17.8.0"; sha256 = "173wjadp3gan4x2jfjchngnc4ca4mb95h1sbb28jydfkfw0z1zvj"; })
+  (fetchNuGet { pname = "Microsoft.CSharp"; version = "4.0.1"; sha256 = "0zxc0apx1gcx361jlq8smc9pfdgmyjh6hpka8dypc9w23nlsh6yj"; })
+  (fetchNuGet { pname = "Microsoft.CSharp"; version = "4.3.0"; sha256 = "0gw297dgkh0al1zxvgvncqs0j15lsna9l1wpqas4rflmys440xvb"; })
+  (fetchNuGet { pname = "Microsoft.CSharp"; version = "4.7.0"; sha256 = "0gd67zlw554j098kabg887b5a6pq9kzavpa3jjy5w53ccjzjfy8j"; })
+  (fetchNuGet { pname = "Microsoft.EntityFrameworkCore"; version = "8.0.0"; sha256 = "1xhmax0xrvw4lyz1868f1sr3nbrcv3ckr5qnf61c8q9bwj06b9v7"; })
+  (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Abstractions"; version = "8.0.0"; sha256 = "019r991228nxv1fibsxg5z81rr7ydgy77c9v7yvlx35kfppxq4s3"; })
+  (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Analyzers"; version = "8.0.0"; sha256 = "1vcbad0pzkx5wadnd5inglx56x0yybdlxgknbhifdga0bx76j9sa"; })
+  (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Design"; version = "8.0.0"; sha256 = "0pa1v87q4hzphv0h020adw7hn84803lrrxylk8h57j93axm5kmm0"; })
+  (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.InMemory"; version = "8.0.0"; sha256 = "0x78a5hjy73ncjnhi50x54wrn935kc3s0r9sjd5436xchcq6l4d4"; })
+  (fetchNuGet { pname = "Microsoft.EntityFrameworkCore.Relational"; version = "8.0.0"; sha256 = "0ngsxk717si11g4a01ah2np8gp8b3k09y23229anr9jrhykr1bw1"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Caching.Abstractions"; version = "8.0.0"; sha256 = "04m6ywsf9731z24nfd14z0ah8xl06619ba7mkdb4vg8h5jpllsn4"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Caching.Memory"; version = "8.0.0"; sha256 = "0bv8ihd5i2gwr97qljwf56h8mdwspmlw0zs64qyk608fb3ciwi25"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.CommandLineUtils"; version = "1.1.1"; sha256 = "0g61kphvdira64g543qlf610sia02scdmki1566d5kr6v390qvbq"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Configuration"; version = "3.1.0"; sha256 = "1rszgz0rd5kvib5fscz6ss3pkxyjwqy0xpd4f2ypgzf5z5g5d398"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Configuration"; version = "8.0.0"; sha256 = "080kab87qgq2kh0ijry5kfdiq9afyzb8s0k3jqi5zbbi540yq4zl"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Configuration.Abstractions"; version = "3.1.0"; sha256 = "1f7h52kamljglx5k08ccryilvk6d6cvr9c26lcb6b2c091znzk0q"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Configuration.Abstractions"; version = "8.0.0"; sha256 = "1jlpa4ggl1gr5fs7fdcw04li3y3iy05w3klr9lrrlc7v8w76kq71"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Configuration.Binder"; version = "3.1.0"; sha256 = "13jj7jxihiswmhmql7r5jydbca4x5qj6h7zq10z17gagys6dc7pw"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Configuration.Binder"; version = "8.0.0"; sha256 = "1m0gawiz8f5hc3li9vd5psddlygwgkiw13d7div87kmkf4idza8r"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection"; version = "3.1.0"; sha256 = "1xc61dy07bn2q73mx1z3ylrw80xpa682qjby13gklnqq636a3gab"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection"; version = "5.0.0"; sha256 = "15sdwcyzz0qlybwbdq854bn3jk6kx7awx28gs864c4shhbqkppj4"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection"; version = "6.0.0"; sha256 = "1wlhb2vygzfdjbdzy7waxblmrx0q3pdcqvpapnpmq9fcx5m8r6w1"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection"; version = "8.0.0"; sha256 = "0i7qziz0iqmbk8zzln7kx9vd0lbx1x3va0yi3j1bgkjir13h78ps"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection.Abstractions"; version = "2.2.0"; sha256 = "1jyzfdr9651h3x6pxwhpfbb9mysfh8f8z1jvy4g117h9790r9zx5"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection.Abstractions"; version = "3.1.0"; sha256 = "1pvms778xkyv1a3gfwrxnh8ja769cxi416n7pcidn9wvg15ifvbh"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection.Abstractions"; version = "5.0.0"; sha256 = "17cz6s80va0ch0a6nqa1wbbbp3p8sqxb96lj4qcw67ivkp2yxiyj"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection.Abstractions"; version = "6.0.0"; sha256 = "1vi67fw7q99gj7jd64gnnfr4d2c0ijpva7g9prps48ja6g91x6a9"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection.Abstractions"; version = "8.0.0"; sha256 = "1zw0bpp5742jzx03wvqc8csnvsbgdqi0ls9jfc5i2vd3cl8b74pg"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.DependencyModel"; version = "8.0.0"; sha256 = "02jnx23hm1vid3yd9pw4gghzn6qkgdl5xfc5r0zrcxdax70rsh5a"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Diagnostics"; version = "8.0.0"; sha256 = "0ghwkld91k20hcbmzg2137w81mzzdh8hfaapdwckhza0vipya4kw"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Diagnostics.Abstractions"; version = "8.0.0"; sha256 = "15m4j6w9n8h0mj7hlfzb83hd3wn7aq1s7fxbicm16slsjfwzj82i"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Diagnostics.HealthChecks"; version = "8.0.0"; sha256 = "0l3a4cf7g31l61w68r9jjsd4fpxawlrjb58k5xf15yd5nahbiynq"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Diagnostics.HealthChecks.Abstractions"; version = "8.0.0"; sha256 = "16qa4yxy17awjaag1xhpw574gfkjjjqs24sydl0rj25kwvk3c728"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.FileProviders.Abstractions"; version = "2.2.0"; sha256 = "1f83ffb4xjwljg8dgzdsa3pa0582q6b4zm0si467fgkybqzk3c54"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.FileProviders.Abstractions"; version = "8.0.0"; sha256 = "1idq65fxwcn882c06yci7nscy9i0rgw6mqjrl7362prvvsd9f15r"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Hosting.Abstractions"; version = "8.0.0"; sha256 = "00d5dwmzw76iy8z40ly01hy9gly49a7rpf7k7m99vrid1kxp346h"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Http"; version = "3.1.0"; sha256 = "02ipxf75rqzsbmmy5ka44hh8krmxgky9mdxmh8f7fkbclpg2s6cy"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Http"; version = "8.0.0"; sha256 = "09hmkhxipbpfmwz9q80746zp6cvbx1cqffxr5xjxv5cbjg5662aj"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Logging"; version = "3.1.0"; sha256 = "1d3yhqj1rav7vswm747j7w8fh8paybji4rz941hhlq4b12mfqfh4"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Logging"; version = "5.0.0"; sha256 = "1qa1l18q2jh9azya8gv1p8anzcdirjzd9dxxisb4911i9m1648i3"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Logging"; version = "6.0.0"; sha256 = "0fd9jii3y3irfcwlsiww1y9npjgabzarh33rn566wpcz24lijszi"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Logging"; version = "8.0.0"; sha256 = "0nppj34nmq25gnrg0wh1q22y4wdqbih4ax493f226azv8mkp9s1i"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Logging.Abstractions"; version = "2.2.0"; sha256 = "02w7hp6jicr7cl5p456k2cmrjvvhm6spg5kxnlncw3b72358m5wl"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Logging.Abstractions"; version = "3.1.0"; sha256 = "1zyalrcksszmn9r5xjnirfh7847axncgzxkk3k5srbvlcch8fw8g"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Logging.Abstractions"; version = "5.0.0"; sha256 = "1yza38675dbv1qqnnhqm23alv2bbaqxp0pb7zinjmw8j2mr5r6wc"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Logging.Abstractions"; version = "6.0.0"; sha256 = "0b75fmins171zi6bfdcq1kcvyrirs8n91mknjnxy4c3ygi1rrnj0"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Logging.Abstractions"; version = "7.0.1"; sha256 = "0xv3sqc1lbx5j4yy6g2w3kakzvrpwqs2ihax6lqasj5sz5map6fk"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Logging.Abstractions"; version = "8.0.0"; sha256 = "1klcqhg3hk55hb6vmjiq2wgqidsl81aldw0li2z98lrwx26msrr6"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Logging.Configuration"; version = "8.0.0"; sha256 = "1d9b734vnll935661wqkgl7ry60rlh5p876l2bsa930mvfsaqfcv"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Logging.Console"; version = "8.0.0"; sha256 = "1mvp3ipw7k33v2qw2yrvc4vl5yzgpk3yxa94gg0gz7wmcmhzvmkd"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.ObjectPool"; version = "7.0.0"; sha256 = "15lz0qk2gr2q52i05ip51dzm9p4hzqlrammkc0hv2ng6g0z72697"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.ObjectPool"; version = "8.0.0"; sha256 = "0j76rwav1yxirb84zpik625xh991mw6xh0wnlzkspjxlc3j6n48p"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Options"; version = "2.2.0"; sha256 = "1b20yh03fg4nmmi3vlf6gf13vrdkmklshfzl3ijygcs4c2hly6v0"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Options"; version = "3.1.0"; sha256 = "0akccwhpn93a4qrssyb3rszdsp3j4p9hlxbsb7yhqb78xydaqhyh"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Options"; version = "5.0.0"; sha256 = "1rdmgpg770x8qwaaa6ryc27zh93p697fcyvn5vkxp0wimlhqkbay"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Options"; version = "6.0.0"; sha256 = "008pnk2p50i594ahz308v81a41mbjz9mwcarqhmrjpl2d20c868g"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Options"; version = "8.0.0"; sha256 = "0p50qn6zhinzyhq9sy5svnmqqwhw2jajs2pbjh9sah504wjvhscz"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Options.ConfigurationExtensions"; version = "8.0.0"; sha256 = "04nm8v5a3zp0ill7hjnwnja3s2676b4wffdri8hdk2341p7mp403"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Primitives"; version = "2.2.0"; sha256 = "0znah6arbcqari49ymigg3wiy2hgdifz8zsq8vdc3ynnf45r7h0c"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Primitives"; version = "3.1.0"; sha256 = "1w1y22njywwysi8qjnj4m83qhbq0jr4mmjib0hfawz6cwamh7xrb"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Primitives"; version = "5.0.0"; sha256 = "0swqcknyh87ns82w539z1mvy804pfwhgzs97cr3nwqk6g5s42gd6"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Primitives"; version = "6.0.0"; sha256 = "1kjiw6s4yfz9gm7mx3wkhp06ghnbs95icj9hi505shz9rjrg42q2"; })
+  (fetchNuGet { pname = "Microsoft.Extensions.Primitives"; version = "8.0.0"; sha256 = "0aldaz5aapngchgdr7dax9jw5wy7k7hmjgjpfgfv1wfif27jlkqm"; })
+  (fetchNuGet { pname = "Microsoft.IdentityModel.Abstractions"; version = "7.0.0"; sha256 = "0sc96z969qfybq5njsqm8hwhqv8jj6gysyjq7n9r9km1nqnhazmi"; })
+  (fetchNuGet { pname = "Microsoft.IdentityModel.Abstractions"; version = "7.1.2"; sha256 = "01jdg8b1hi4nx5h1cn9baalfkp4y70kc2wf4lz77kw8w1fvrppa0"; })
+  (fetchNuGet { pname = "Microsoft.IdentityModel.JsonWebTokens"; version = "7.0.0"; sha256 = "12xa4yx19j5q7nbisl57jla8x6pby964cr9xkv0qm4834x4zdd3h"; })
+  (fetchNuGet { pname = "Microsoft.IdentityModel.JsonWebTokens"; version = "7.1.2"; sha256 = "1y9yq07hr91aaxm7pahv3fc590dzydlffr4hs3zix1g45pvd4m4i"; })
+  (fetchNuGet { pname = "Microsoft.IdentityModel.Logging"; version = "7.0.0"; sha256 = "0hv1qb51v6frvhybwcn6m3haq768jgdx59p17jn217fbjiprq14s"; })
+  (fetchNuGet { pname = "Microsoft.IdentityModel.Logging"; version = "7.1.2"; sha256 = "1yi7s2pm4f8vl6b0qck0nrfsrf1h4jwamznkzl75n1cwxpbdikp8"; })
+  (fetchNuGet { pname = "Microsoft.IdentityModel.Tokens"; version = "7.0.0"; sha256 = "0cjdbi3ximvfz2nyp2vlxqskmscxw8drjighvy7dna3mi749isrh"; })
+  (fetchNuGet { pname = "Microsoft.IdentityModel.Tokens"; version = "7.1.2"; sha256 = "1q70c1ax9f5nggqp4g8nyfaz0481grsaxhp85cmjpmx8l3q35zx9"; })
+  (fetchNuGet { pname = "Microsoft.IO.RecyclableMemoryStream"; version = "3.0.0"; sha256 = "1zl39k27r4zq75r1x1zr1yl4nzxpkxdnnv6dwd4qp0xr22my85aq"; })
+  (fetchNuGet { pname = "Microsoft.Net.Http.Headers"; version = "2.2.0"; sha256 = "0w6lrk9z67bcirq2cj2ldfhnizc6id77ba6i30hjzgqjlyhh1gx5"; })
+  (fetchNuGet { pname = "Microsoft.NET.Test.Sdk"; version = "17.8.0"; sha256 = "1syvl3g0hbrcgfi9rq6pld8s8hqqww4dflf1lxn59ccddyyx0gmv"; })
+  (fetchNuGet { pname = "Microsoft.NETCore.App"; version = "1.0.0"; sha256 = "0i09cs7a7hxn9n1nx49382csvc7560j4hbxr2c8bwa69nhf2rrjp"; })
+  (fetchNuGet { pname = "Microsoft.NETCore.DotNetHost"; version = "1.0.1"; sha256 = "1qr4gnzlpwzv8jr7ijmdg13x2s9m35g4ma0bh18kci4ml7h9jb6a"; })
+  (fetchNuGet { pname = "Microsoft.NETCore.DotNetHostPolicy"; version = "1.0.1"; sha256 = "0vbqww1bmlkz7xq05zxykv27xdrkl6nrjhs1iiszaa9ivf7nklz1"; })
+  (fetchNuGet { pname = "Microsoft.NETCore.DotNetHostResolver"; version = "1.0.1"; sha256 = "109zs3bqhzh6mhbf2rfpwxmpb8fq57jr7wriyylynirsqh1lnql4"; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Jit"; version = "1.0.2"; sha256 = "0jaan2wmg80lr0mhgfy70kb5cqjwv1a2ikmxgd0glpcxp7wr7pag"; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "1.0.1"; sha256 = "01al6cfxp68dscl15z7rxfw9zvhm64dncsw09a1vmdkacsa2v6lr"; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "1.1.0"; sha256 = "08vh1r12g6ykjygq5d3vq09zylgb84l63k49jc4v8faw9g93iqqm"; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "1.1.1"; sha256 = "164wycgng4mi9zqi2pnsf1pq6gccbqvw6ib916mqizgjmd8f44pj"; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "5.0.0"; sha256 = "0mwpwdflidzgzfx2dlpkvvnkgkr2ayaf0s80737h4wa35gaj11rc"; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Runtime.CoreCLR"; version = "1.0.2"; sha256 = "1hxgsjyzh7hdgd34xwpn5s2myy1b1y9ms7xhvs6mkb75wap49bpc"; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "1.0.1"; sha256 = "0ppdkwy6s9p7x9jix3v4402wb171cdiibq7js7i13nxpdky7074p"; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "1.1.0"; sha256 = "193xwf33fbm0ni3idxzbr5fdq3i2dlfgihsac9jj7whj0gd902nh"; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Windows.ApiSets"; version = "1.0.1"; sha256 = "16k8chghkr25jf49banhzl839vs8n3vbfpg4wn4idi0hzjipix78"; })
+  (fetchNuGet { pname = "Microsoft.TestPlatform.ObjectModel"; version = "17.8.0"; sha256 = "0b0i7lmkrcfvim8i3l93gwqvkhhhfzd53fqfnygdqvkg6np0cg7m"; })
+  (fetchNuGet { pname = "Microsoft.TestPlatform.TestHost"; version = "17.8.0"; sha256 = "0f5jah93kjkvxwmhwb78lw11m9pkkq9fvf135hpymmmpxqbdh97q"; })
+  (fetchNuGet { pname = "Microsoft.VisualBasic"; version = "10.0.1"; sha256 = "0q6vv9qfkbwn7gz8qf1gfcn33r87m260hsxdsk838mcbqmjz6wgc"; })
+  (fetchNuGet { pname = "Microsoft.VisualStudio.Azure.Containers.Tools.Targets"; version = "1.19.5"; sha256 = "0m0j33fj8kgfdzhr96b1fzyyqba9xrsyvbm1vb1v97w67p5m3vk7"; })
+  (fetchNuGet { pname = "Microsoft.Win32.Primitives"; version = "4.0.1"; sha256 = "1n8ap0cmljbqskxpf8fjzn7kh1vvlndsa75k01qig26mbw97k2q7"; })
+  (fetchNuGet { pname = "Microsoft.Win32.Primitives"; version = "4.3.0"; sha256 = "0j0c1wj4ndj21zsgivsc24whiya605603kxrbiw6wkfdync464wq"; })
+  (fetchNuGet { pname = "Microsoft.Win32.Registry"; version = "4.0.0"; sha256 = "1spf4m9pikkc19544p29a47qnhcd885klncahz133hbnyqbkmz9k"; })
+  (fetchNuGet { pname = "Microsoft.Win32.Registry"; version = "5.0.0"; sha256 = "102hvhq2gmlcbq8y2cb7hdr2dnmjzfp2k3asr1ycwrfacwyaak7n"; })
+  (fetchNuGet { pname = "Mono.TextTemplating"; version = "2.2.1"; sha256 = "1ih6399x4bxzchw7pq5195imir9viy2r1w702vy87vrarxyjqdp1"; })
+  (fetchNuGet { pname = "Nethermind.Crypto.Pairings"; version = "1.0.1"; sha256 = "1d8n97snf30iymdzjn6528655cw0skpb3jb2kywbh5hj9f2nl7mp"; })
+  (fetchNuGet { pname = "Nethermind.Crypto.SecP256k1"; version = "1.1.1"; sha256 = "1vdj5625rk9zwnc9qajnpkszcsn85z9mnhq7gph5c0kd8fg70nx7"; })
+  (fetchNuGet { pname = "Nethermind.DotNetty.Buffers"; version = "1.0.1"; sha256 = "1xc4r3yxpcbh7wm1vb3jwl8k7d5p1mgx6zy5g5hcdsa1bi6ga9h3"; })
+  (fetchNuGet { pname = "Nethermind.DotNetty.Codecs"; version = "1.0.1"; sha256 = "087xg301vrvl70jzpb5wf9ii74waqbjzgyrx0w7g21ljhcsmsls7"; })
+  (fetchNuGet { pname = "Nethermind.DotNetty.Common"; version = "1.0.1"; sha256 = "0lrch8lhviki176hcihzzw79lfzwz5py6igpc56z342ijham0alv"; })
+  (fetchNuGet { pname = "Nethermind.DotNetty.Handlers"; version = "1.0.1"; sha256 = "10vlficmv30cl90d91h9ik522h76yahb187vfcmxpay61jg428j8"; })
+  (fetchNuGet { pname = "Nethermind.DotNetty.Transport"; version = "1.0.1"; sha256 = "1sdx03x17y50m0p08hh35r2hjr70ynclrqbzhygxxsq6ia75gz53"; })
+  (fetchNuGet { pname = "Nethermind.Gmp"; version = "1.0.1"; sha256 = "1x9in44pvg2jjiqrf8q9l4qyqilcbx6hr2ywgk42gjxri27agnih"; })
+  (fetchNuGet { pname = "Nethermind.Numerics.Int256"; version = "1.1.1"; sha256 = "1dydq1siivwbg8fzcwwjh92mmypjsz584dgpyi7lz4yx3m7lw7s0"; })
+  (fetchNuGet { pname = "NETStandard.Library"; version = "1.6.0"; sha256 = "0nmmv4yw7gw04ik8ialj3ak0j6pxa9spih67hnn1h2c38ba8h58k"; })
+  (fetchNuGet { pname = "NETStandard.Library"; version = "1.6.1"; sha256 = "1z70wvsx2d847a2cjfii7b83pjfs34q05gb037fdjikv5kbagml8"; })
+  (fetchNuGet { pname = "NETStandard.Library"; version = "2.0.0"; sha256 = "1bc4ba8ahgk15m8k4nd7x406nhi0kwqzbgjk2dmw52ss553xz7iy"; })
+  (fetchNuGet { pname = "Newtonsoft.Json"; version = "10.0.3"; sha256 = "06vy67bkshclpz69kps4vgzc9h2cgg41c8vlqmdbwclfky7c4haq"; })
+  (fetchNuGet { pname = "Newtonsoft.Json"; version = "13.0.1"; sha256 = "0fijg0w6iwap8gvzyjnndds0q4b8anwxxvik7y8vgq97dram4srb"; })
+  (fetchNuGet { pname = "Newtonsoft.Json"; version = "13.0.3"; sha256 = "0xrwysmrn4midrjal8g2hr1bbg38iyisl0svamb11arqws4w2bw7"; })
+  (fetchNuGet { pname = "Nito.Collections.Deque"; version = "1.2.1"; sha256 = "13rmaxawcmri2z0vwf6mvmi59x12qhrl29d5qxlj6ryb6w9wj5ha"; })
+  (fetchNuGet { pname = "NLog"; version = "5.2.8"; sha256 = "1z3h20m5rjnizm1jbf5j0vpdc1f373rzzkg6478p1lxv5j385c12"; })
+  (fetchNuGet { pname = "NLog.Targets.Seq"; version = "3.0.0"; sha256 = "0g8nr46mdc447n3hbkgmhdd7k65mg4zx7ydm349ddr0pwjivcm3f"; })
+  (fetchNuGet { pname = "NSubstitute"; version = "5.1.0"; sha256 = "0vjl2pgw4b6366x47xyc0nfz33rx96bwjpnn0diq8mksaxn6w6ir"; })
+  (fetchNuGet { pname = "NuGet.Frameworks"; version = "6.5.0"; sha256 = "0s37d1p4md0k6d4cy6sq36f2dgkd9qfbzapxhkvi8awwh0vrynhj"; })
+  (fetchNuGet { pname = "NUnit"; version = "3.14.0"; sha256 = "19p8911lrfds1k9rv47jk1bbn665s0pvghkd06gzbg78j6mzzqqa"; })
+  (fetchNuGet { pname = "NUnit.Analyzers"; version = "3.9.0"; sha256 = "13bk0kfh1c0xzmr5vzlwl7afzhz60xrw402mpkgfj954dv4s2agq"; })
+  (fetchNuGet { pname = "NUnit3TestAdapter"; version = "4.5.0"; sha256 = "1srx1629s0k1kmf02nmz251q07vj6pv58mdafcr5dr0bbn1fh78i"; })
+  (fetchNuGet { pname = "Open.NAT.Core"; version = "2.1.0.5"; sha256 = "0f6c7m1x1kssicbi6q60jys3fnbj6zs69v37wdsmvbqgc0pvk89f"; })
+  (fetchNuGet { pname = "Polly"; version = "8.2.0"; sha256 = "0gxdi4sf60vpxsb258v592ykkq9a3dq2awayp99yy9djys8bglks"; })
+  (fetchNuGet { pname = "Polly.Core"; version = "8.2.0"; sha256 = "00b4jbyiyslqvswy4j2lfw0rl0gq8m4v5fj2asb96i6l224bs7d3"; })
+  (fetchNuGet { pname = "Portable.BouncyCastle"; version = "1.9.0"; sha256 = "0kphjwz4hk2nki3b4f9z096xzd520nrpvi3cjib8fkjk6zhwrr8q"; })
+  (fetchNuGet { pname = "prometheus-net"; version = "8.0.1"; sha256 = "0fcx4479bagn11830sjm4k13d5g947w8i8bxnzsn1v1nyrva7fvl"; })
+  (fetchNuGet { pname = "prometheus-net"; version = "8.2.0"; sha256 = "19m9lkpc4h9a0jmn66p61x8960gk9fidcwic70nrvjhmd5m201fj"; })
+  (fetchNuGet { pname = "prometheus-net.AspNetCore"; version = "8.2.0"; sha256 = "1lilk7xw19wgl2i7cjbf09ssd4jicla45wj29hfy6d1bzcnd6yn8"; })
+  (fetchNuGet { pname = "Pyroscope"; version = "0.8.14"; sha256 = "0m1xm0ppqj0h5a9lxfl7wnzcq75ds8c4m44ibsglni2q02vh800a"; })
+  (fetchNuGet { pname = "ReadLine"; version = "2.0.1"; sha256 = "1bc7aiyh99kkf4indrqzlf3y6517xhxh02nizybkp4hbxga1caih"; })
+  (fetchNuGet { pname = "RichardSzalay.MockHttp"; version = "7.0.0"; sha256 = "167r48r1mbjgq8wc9w7lhh63vy853sc2dvxjld372zh8mqi5aasz"; })
+  (fetchNuGet { pname = "RocksDB"; version = "8.3.2.39829"; sha256 = "0mkgcr53wcsgb3jzc82p7n0qblj9i65sx0q19sf0s7lf6dlcb5qw"; })
+  (fetchNuGet { pname = "runtime.any.System.Collections"; version = "4.3.0"; sha256 = "0bv5qgm6vr47ynxqbnkc7i797fdi8gbjjxii173syrx14nmrkwg0"; })
+  (fetchNuGet { pname = "runtime.any.System.Diagnostics.Tools"; version = "4.3.0"; sha256 = "1wl76vk12zhdh66vmagni66h5xbhgqq7zkdpgw21jhxhvlbcl8pk"; })
+  (fetchNuGet { pname = "runtime.any.System.Diagnostics.Tracing"; version = "4.3.0"; sha256 = "00j6nv2xgmd3bi347k00m7wr542wjlig53rmj28pmw7ddcn97jbn"; })
+  (fetchNuGet { pname = "runtime.any.System.Globalization"; version = "4.3.0"; sha256 = "1daqf33hssad94lamzg01y49xwndy2q97i2lrb7mgn28656qia1x"; })
+  (fetchNuGet { pname = "runtime.any.System.Globalization.Calendars"; version = "4.3.0"; sha256 = "1ghhhk5psqxcg6w88sxkqrc35bxcz27zbqm2y5p5298pv3v7g201"; })
+  (fetchNuGet { pname = "runtime.any.System.IO"; version = "4.3.0"; sha256 = "0l8xz8zn46w4d10bcn3l4yyn4vhb3lrj2zw8llvz7jk14k4zps5x"; })
+  (fetchNuGet { pname = "runtime.any.System.Reflection"; version = "4.3.0"; sha256 = "02c9h3y35pylc0zfq3wcsvc5nqci95nrkq0mszifc0sjx7xrzkly"; })
+  (fetchNuGet { pname = "runtime.any.System.Reflection.Extensions"; version = "4.3.0"; sha256 = "0zyri97dfc5vyaz9ba65hjj1zbcrzaffhsdlpxc9bh09wy22fq33"; })
+  (fetchNuGet { pname = "runtime.any.System.Reflection.Primitives"; version = "4.3.0"; sha256 = "0x1mm8c6iy8rlxm8w9vqw7gb7s1ljadrn049fmf70cyh42vdfhrf"; })
+  (fetchNuGet { pname = "runtime.any.System.Resources.ResourceManager"; version = "4.3.0"; sha256 = "03kickal0iiby82wa5flar18kyv82s9s6d4xhk5h4bi5kfcyfjzl"; })
+  (fetchNuGet { pname = "runtime.any.System.Runtime"; version = "4.3.0"; sha256 = "1cqh1sv3h5j7ixyb7axxbdkqx6cxy00p4np4j91kpm492rf4s25b"; })
+  (fetchNuGet { pname = "runtime.any.System.Runtime.Handles"; version = "4.3.0"; sha256 = "0bh5bi25nk9w9xi8z23ws45q5yia6k7dg3i4axhfqlnj145l011x"; })
+  (fetchNuGet { pname = "runtime.any.System.Runtime.InteropServices"; version = "4.3.0"; sha256 = "0c3g3g3jmhlhw4klrc86ka9fjbl7i59ds1fadsb2l8nqf8z3kb19"; })
+  (fetchNuGet { pname = "runtime.any.System.Text.Encoding"; version = "4.3.0"; sha256 = "0aqqi1v4wx51h51mk956y783wzags13wa7mgqyclacmsmpv02ps3"; })
+  (fetchNuGet { pname = "runtime.any.System.Text.Encoding.Extensions"; version = "4.3.0"; sha256 = "0lqhgqi0i8194ryqq6v2gqx0fb86db2gqknbm0aq31wb378j7ip8"; })
+  (fetchNuGet { pname = "runtime.any.System.Threading.Tasks"; version = "4.3.0"; sha256 = "03mnvkhskbzxddz4hm113zsch1jyzh2cs450dk3rgfjp8crlw1va"; })
+  (fetchNuGet { pname = "runtime.any.System.Threading.Timer"; version = "4.3.0"; sha256 = "0aw4phrhwqz9m61r79vyfl5la64bjxj8l34qnrcwb28v49fg2086"; })
+  (fetchNuGet { pname = "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "16rnxzpk5dpbbl1x354yrlsbvwylrq456xzpsha1n9y3glnhyx9d"; })
+  (fetchNuGet { pname = "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "0rwpqngkqiapqc5c2cpkj7idhngrgss5qpnqg0yh40mbyflcxf8i"; })
+  (fetchNuGet { pname = "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0hkg03sgm2wyq8nqk6dbm9jh5vcq57ry42lkqdmfklrw89lsmr59"; })
+  (fetchNuGet { pname = "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "1n06gxwlinhs0w7s8a94r1q3lwqzvynxwd3mp10ws9bg6gck8n4r"; })
+  (fetchNuGet { pname = "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0c2p354hjx58xhhz7wv6div8xpi90sc6ibdm40qin21bvi7ymcaa"; })
+  (fetchNuGet { pname = "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "0404wqrc7f2yc0wxv71y3nnybvqx8v4j9d47hlscxy759a525mc3"; })
+  (fetchNuGet { pname = "runtime.native.System"; version = "4.0.0"; sha256 = "1ppk69xk59ggacj9n7g6fyxvzmk1g5p4fkijm0d7xqfkig98qrkf"; })
+  (fetchNuGet { pname = "runtime.native.System"; version = "4.3.0"; sha256 = "15hgf6zaq9b8br2wi1i3x0zvmk410nlmsmva9p0bbg73v6hml5k4"; })
+  (fetchNuGet { pname = "runtime.native.System.IO.Compression"; version = "4.1.0"; sha256 = "0d720z4lzyfcabmmnvh0bnj76ll7djhji2hmfh3h44sdkjnlkknk"; })
+  (fetchNuGet { pname = "runtime.native.System.IO.Compression"; version = "4.3.0"; sha256 = "1vvivbqsk6y4hzcid27pqpm5bsi6sc50hvqwbcx8aap5ifrxfs8d"; })
+  (fetchNuGet { pname = "runtime.native.System.Net.Http"; version = "4.0.1"; sha256 = "1hgv2bmbaskx77v8glh7waxws973jn4ah35zysnkxmf0196sfxg6"; })
+  (fetchNuGet { pname = "runtime.native.System.Net.Http"; version = "4.3.0"; sha256 = "1n6rgz5132lcibbch1qlf0g9jk60r0kqv087hxc0lisy50zpm7kk"; })
+  (fetchNuGet { pname = "runtime.native.System.Net.Security"; version = "4.0.1"; sha256 = "1nk4pf8vbrgf73p0skhwmzhgz1hax3j123ilhwdncr47l3x1dbhk"; })
+  (fetchNuGet { pname = "runtime.native.System.Security.Cryptography"; version = "4.0.0"; sha256 = "0k57aa2c3b10wl3hfqbgrl7xq7g8hh3a3ir44b31dn5p61iiw3z9"; })
+  (fetchNuGet { pname = "runtime.native.System.Security.Cryptography.Apple"; version = "4.3.0"; sha256 = "1b61p6gw1m02cc1ry996fl49liiwky6181dzr873g9ds92zl326q"; })
+  (fetchNuGet { pname = "runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "18pzfdlwsg2nb1jjjjzyb5qlgy6xjxzmhnfaijq5s2jw3cm3ab97"; })
+  (fetchNuGet { pname = "runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "0zy5r25jppz48i2bkg8b9lfig24xixg6nm3xyr1379zdnqnpm8f6"; })
+  (fetchNuGet { pname = "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0qyynf9nz5i7pc26cwhgi8j62ps27sqmf78ijcfgzab50z9g8ay3"; })
+  (fetchNuGet { pname = "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "096ch4n4s8k82xga80lfmpimpzahd2ip1mgwdqgar0ywbbl6x438"; })
+  (fetchNuGet { pname = "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "1klrs545awhayryma6l7g2pvnp9xy4z0r1i40r80zb45q3i9nbyf"; })
+  (fetchNuGet { pname = "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "1dm8fifl7rf1gy7lnwln78ch4rw54g0pl5g1c189vawavll7p6rj"; })
+  (fetchNuGet { pname = "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.Apple"; version = "4.3.0"; sha256 = "10yc8jdrwgcl44b4g93f1ds76b176bajd3zqi2faf5rvh1vy9smi"; })
+  (fetchNuGet { pname = "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0zcxjv5pckplvkg0r6mw3asggm7aqzbdjimhvsasb0cgm59x09l3"; })
+  (fetchNuGet { pname = "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "1m9z1k9kzva9n9kwinqxl97x2vgl79qhqjlv17k9s2ymcyv2bwr6"; })
+  (fetchNuGet { pname = "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0vhynn79ih7hw7cwjazn87rm9z9fj0rvxgzlab36jybgcpcgphsn"; })
+  (fetchNuGet { pname = "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "1cpx56mcfxz7cpn57wvj18sjisvzq8b5vd9rw16ihd2i6mcp3wa1"; })
+  (fetchNuGet { pname = "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "160p68l2c7cqmyqjwxydcvgw7lvl1cr0znkw8fp24d1by9mqc8p3"; })
+  (fetchNuGet { pname = "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "15gsm1a8jdmgmf8j5v1slfz8ks124nfdhk2vxs2rw3asrxalg8hi"; })
+  (fetchNuGet { pname = "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "15zrc8fgd8zx28hdghcj5f5i34wf3l6bq5177075m2bc2j34jrqy"; })
+  (fetchNuGet { pname = "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "0q0n5q1r1wnqmr5i5idsrd9ywl33k0js4pngkwq9p368mbxp8x1w"; })
+  (fetchNuGet { pname = "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "1p4dgxax6p7rlgj4q73k73rslcnz4wdcv8q2flg1s8ygwcm58ld5"; })
+  (fetchNuGet { pname = "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "1x0g58pbpjrmj2x2qw17rdwwnrcl0wvim2hdwz48lixvwvp22n9c"; })
+  (fetchNuGet { pname = "runtime.unix.Microsoft.Win32.Primitives"; version = "4.3.0"; sha256 = "0y61k9zbxhdi0glg154v30kkq7f8646nif8lnnxbvkjpakggd5id"; })
+  (fetchNuGet { pname = "runtime.unix.System.Console"; version = "4.3.0"; sha256 = "1pfpkvc6x2if8zbdzg9rnc5fx51yllprl8zkm5npni2k50lisy80"; })
+  (fetchNuGet { pname = "runtime.unix.System.Diagnostics.Debug"; version = "4.3.0"; sha256 = "1lps7fbnw34bnh3lm31gs5c0g0dh7548wfmb8zz62v0zqz71msj5"; })
+  (fetchNuGet { pname = "runtime.unix.System.IO.FileSystem"; version = "4.3.0"; sha256 = "14nbkhvs7sji5r1saj2x8daz82rnf9kx28d3v2qss34qbr32dzix"; })
+  (fetchNuGet { pname = "runtime.unix.System.Net.Primitives"; version = "4.3.0"; sha256 = "0bdnglg59pzx9394sy4ic66kmxhqp8q8bvmykdxcbs5mm0ipwwm4"; })
+  (fetchNuGet { pname = "runtime.unix.System.Net.Sockets"; version = "4.3.0"; sha256 = "03npdxzy8gfv035bv1b9rz7c7hv0rxl5904wjz51if491mw0xy12"; })
+  (fetchNuGet { pname = "runtime.unix.System.Private.Uri"; version = "4.3.0"; sha256 = "1jx02q6kiwlvfksq1q9qr17fj78y5v6mwsszav4qcz9z25d5g6vk"; })
+  (fetchNuGet { pname = "runtime.unix.System.Runtime.Extensions"; version = "4.3.0"; sha256 = "0pnxxmm8whx38dp6yvwgmh22smknxmqs5n513fc7m4wxvs1bvi4p"; })
+  (fetchNuGet { pname = "SCrypt"; version = "2.0.0.2"; sha256 = "03ira8iv45zcsv613bic0ak31v9am13x29dsj3j17xzhx65rg926"; })
+  (fetchNuGet { pname = "Seq.Api"; version = "2023.4.0"; sha256 = "17lpyf33gf0497ra0zp5b2wspwgqw03hlaadj341s8wsnypiwrm1"; })
+  (fetchNuGet { pname = "Shouldly"; version = "4.2.1"; sha256 = "03v0krqpgik60y7w6zwkr45v1rwbrvncf56s8mf5c958a549wswn"; })
+  (fetchNuGet { pname = "Snappy.Standard"; version = "0.2.0"; sha256 = "1dbrp35r1k6gdpqx576kcrplxbdxs32223pl4ds9hwhpf1fjac65"; })
+  (fetchNuGet { pname = "System.AppContext"; version = "4.1.0"; sha256 = "0fv3cma1jp4vgj7a8hqc9n7hr1f1kjp541s6z0q1r6nazb4iz9mz"; })
+  (fetchNuGet { pname = "System.AppContext"; version = "4.3.0"; sha256 = "1649qvy3dar900z3g817h17nl8jp4ka5vcfmsr05kh0fshn7j3ya"; })
+  (fetchNuGet { pname = "System.Buffers"; version = "4.0.0"; sha256 = "13s659bcmg9nwb6z78971z1lr6bmh2wghxi1ayqyzl4jijd351gr"; })
+  (fetchNuGet { pname = "System.Buffers"; version = "4.3.0"; sha256 = "0fgns20ispwrfqll4q1zc1waqcmylb3zc50ys9x8zlwxh9pmd9jy"; })
+  (fetchNuGet { pname = "System.Buffers"; version = "4.5.0"; sha256 = "1ywfqn4md6g3iilpxjn5dsr0f5lx6z0yvhqp4pgjcamygg73cz2c"; })
+  (fetchNuGet { pname = "System.CodeDom"; version = "4.4.0"; sha256 = "1zgbafm5p380r50ap5iddp11kzhr9khrf2pnai6k593wjar74p1g"; })
+  (fetchNuGet { pname = "System.CodeDom"; version = "6.0.0"; sha256 = "1i55cxp8ycc03dmxx4n22qi6jkwfl23cgffb95izq7bjar8avxxq"; })
+  (fetchNuGet { pname = "System.Collections"; version = "4.0.11"; sha256 = "1ga40f5lrwldiyw6vy67d0sg7jd7ww6kgwbksm19wrvq9hr0bsm6"; })
+  (fetchNuGet { pname = "System.Collections"; version = "4.3.0"; sha256 = "19r4y64dqyrq6k4706dnyhhw7fs24kpp3awak7whzss39dakpxk9"; })
+  (fetchNuGet { pname = "System.Collections.Concurrent"; version = "4.0.12"; sha256 = "07y08kvrzpak873pmyxs129g1ch8l27zmg51pcyj2jvq03n0r0fc"; })
+  (fetchNuGet { pname = "System.Collections.Concurrent"; version = "4.3.0"; sha256 = "0wi10md9aq33jrkh2c24wr2n9hrpyamsdhsxdcnf43b7y86kkii8"; })
+  (fetchNuGet { pname = "System.Collections.Immutable"; version = "1.2.0"; sha256 = "1jm4pc666yiy7af1mcf7766v710gp0h40p228ghj6bavx7xfa38m"; })
+  (fetchNuGet { pname = "System.Collections.Immutable"; version = "1.5.0"; sha256 = "1d5gjn5afnrf461jlxzawcvihz195gayqpcfbv6dd7pxa9ialn06"; })
+  (fetchNuGet { pname = "System.Collections.Immutable"; version = "6.0.0"; sha256 = "1js98kmjn47ivcvkjqdmyipzknb9xbndssczm8gq224pbaj1p88c"; })
+  (fetchNuGet { pname = "System.Collections.NonGeneric"; version = "4.3.0"; sha256 = "07q3k0hf3mrcjzwj8fwk6gv3n51cb513w4mgkfxzm3i37sc9kz7k"; })
+  (fetchNuGet { pname = "System.Collections.Specialized"; version = "4.3.0"; sha256 = "1sdwkma4f6j85m3dpb53v9vcgd0zyc9jb33f8g63byvijcj39n20"; })
+  (fetchNuGet { pname = "System.ComponentModel"; version = "4.0.1"; sha256 = "0v4qpmqlzyfad2kswxxj2frnaqqhz9201c3yn8fmmarx5vlzg52z"; })
+  (fetchNuGet { pname = "System.ComponentModel"; version = "4.3.0"; sha256 = "0986b10ww3nshy30x9sjyzm0jx339dkjxjj3401r3q0f6fx2wkcb"; })
+  (fetchNuGet { pname = "System.ComponentModel.Annotations"; version = "4.1.0"; sha256 = "0l6m3z6h2qjjam1rp1fzk7zz5czjjazmw78rbh72x25y6kmyn6wf"; })
+  (fetchNuGet { pname = "System.ComponentModel.Annotations"; version = "4.5.0"; sha256 = "1jj6f6g87k0iwsgmg3xmnn67a14mq88np0l1ys5zkxhkvbc8976p"; })
+  (fetchNuGet { pname = "System.ComponentModel.Primitives"; version = "4.3.0"; sha256 = "1svfmcmgs0w0z9xdw2f2ps05rdxmkxxhf0l17xk9l1l8xfahkqr0"; })
+  (fetchNuGet { pname = "System.ComponentModel.TypeConverter"; version = "4.3.0"; sha256 = "17ng0p7v3nbrg3kycz10aqrrlw4lz9hzhws09pfh8gkwicyy481x"; })
+  (fetchNuGet { pname = "System.Composition"; version = "6.0.0"; sha256 = "1p7hysns39cc24af6dwd4m48bqjsrr3clvi4aws152mh2fgyg50z"; })
+  (fetchNuGet { pname = "System.Composition.AttributedModel"; version = "6.0.0"; sha256 = "1mqrblb0l65hw39d0hnspqcv85didpn4wbiwhfgj4784wzqx2w6k"; })
+  (fetchNuGet { pname = "System.Composition.Convention"; version = "6.0.0"; sha256 = "02km3yb94p1c4s7liyhkmda0g71zm1rc8ijsfmy4bnlkq15xjw3b"; })
+  (fetchNuGet { pname = "System.Composition.Hosting"; version = "6.0.0"; sha256 = "0big5nk8c44rxp6cfykhk7rxvn2cgwa99w6c3v2a36adc3lj36ky"; })
+  (fetchNuGet { pname = "System.Composition.Runtime"; version = "6.0.0"; sha256 = "0vq5ik63yii1784gsa2f2kx9w6xllmm8b8rk0arid1jqdj1nyrlw"; })
+  (fetchNuGet { pname = "System.Composition.TypedParts"; version = "6.0.0"; sha256 = "0y9pq3y60nyrpfy51f576a0qjjdh61mcv8vnik32pm4bz56h9q72"; })
+  (fetchNuGet { pname = "System.Configuration.ConfigurationManager"; version = "4.4.0"; sha256 = "1hjgmz47v5229cbzd2pwz2h0dkq78lb2wp9grx8qr72pb5i0dk7v"; })
+  (fetchNuGet { pname = "System.Configuration.ConfigurationManager"; version = "8.0.0"; sha256 = "08dadpd8lx6x7craw3h3444p7ncz4wk0a3j1681lyhhd56ln66f6"; })
+  (fetchNuGet { pname = "System.Console"; version = "4.0.0"; sha256 = "0ynxqbc3z1nwbrc11hkkpw9skw116z4y9wjzn7id49p9yi7mzmlf"; })
+  (fetchNuGet { pname = "System.Console"; version = "4.3.0"; sha256 = "1flr7a9x920mr5cjsqmsy9wgnv3lvd0h1g521pdr1lkb2qycy7ay"; })
+  (fetchNuGet { pname = "System.Diagnostics.Debug"; version = "4.0.11"; sha256 = "0gmjghrqmlgzxivd2xl50ncbglb7ljzb66rlx8ws6dv8jm0d5siz"; })
+  (fetchNuGet { pname = "System.Diagnostics.Debug"; version = "4.3.0"; sha256 = "00yjlf19wjydyr6cfviaph3vsjzg3d5nvnya26i2fvfg53sknh3y"; })
+  (fetchNuGet { pname = "System.Diagnostics.DiagnosticSource"; version = "4.0.0"; sha256 = "1n6c3fbz7v8d3pn77h4v5wvsfrfg7v1c57lg3nff3cjyh597v23m"; })
+  (fetchNuGet { pname = "System.Diagnostics.DiagnosticSource"; version = "4.3.0"; sha256 = "0z6m3pbiy0qw6rn3n209rrzf9x1k4002zh90vwcrsym09ipm2liq"; })
+  (fetchNuGet { pname = "System.Diagnostics.DiagnosticSource"; version = "6.0.0"; sha256 = "0rrihs9lnb1h6x4h0hn6kgfnh58qq7hx8qq99gh6fayx4dcnx3s5"; })
+  (fetchNuGet { pname = "System.Diagnostics.DiagnosticSource"; version = "8.0.0"; sha256 = "0nzra1i0mljvmnj1qqqg37xs7bl71fnpl68nwmdajchh65l878zr"; })
+  (fetchNuGet { pname = "System.Diagnostics.EventLog"; version = "6.0.0"; sha256 = "08y1x2d5w2hnhkh9r1998pjc7r4qp0rmzax062abha85s11chifd"; })
+  (fetchNuGet { pname = "System.Diagnostics.EventLog"; version = "8.0.0"; sha256 = "1xnvcidh2qf6k7w8ij1rvj0viqkq84cq47biw0c98xhxg5rk3pxf"; })
+  (fetchNuGet { pname = "System.Diagnostics.FileVersionInfo"; version = "4.0.0"; sha256 = "1s5vxhy7i09bmw51kxqaiz9zaj9am8wsjyz13j85sp23z267hbv3"; })
+  (fetchNuGet { pname = "System.Diagnostics.Process"; version = "4.1.0"; sha256 = "061lrcs7xribrmq7kab908lww6kn2xn1w3rdc41q189y0jibl19s"; })
+  (fetchNuGet { pname = "System.Diagnostics.StackTrace"; version = "4.0.1"; sha256 = "0q29axqklpl36vvyni5h1cyb02lfvvkqprb9wfvcdca3181q5al2"; })
+  (fetchNuGet { pname = "System.Diagnostics.Tools"; version = "4.0.1"; sha256 = "19cknvg07yhakcvpxg3cxa0bwadplin6kyxd8mpjjpwnp56nl85x"; })
+  (fetchNuGet { pname = "System.Diagnostics.Tools"; version = "4.3.0"; sha256 = "0in3pic3s2ddyibi8cvgl102zmvp9r9mchh82ns9f0ms4basylw1"; })
+  (fetchNuGet { pname = "System.Diagnostics.Tracing"; version = "4.1.0"; sha256 = "1d2r76v1x610x61ahfpigda89gd13qydz6vbwzhpqlyvq8jj6394"; })
+  (fetchNuGet { pname = "System.Diagnostics.Tracing"; version = "4.3.0"; sha256 = "1m3bx6c2s958qligl67q7grkwfz3w53hpy7nc97mh6f7j5k168c4"; })
+  (fetchNuGet { pname = "System.Dynamic.Runtime"; version = "4.0.11"; sha256 = "1pla2dx8gkidf7xkciig6nifdsb494axjvzvann8g2lp3dbqasm9"; })
+  (fetchNuGet { pname = "System.Dynamic.Runtime"; version = "4.3.0"; sha256 = "1d951hrvrpndk7insiag80qxjbf2y0y39y8h5hnq9612ws661glk"; })
+  (fetchNuGet { pname = "System.Formats.Asn1"; version = "8.0.0"; sha256 = "04h75wflmzl0qh125p0209wx006rkyxic1y404m606yjvpl2alq1"; })
+  (fetchNuGet { pname = "System.Globalization"; version = "4.0.11"; sha256 = "070c5jbas2v7smm660zaf1gh0489xanjqymkvafcs4f8cdrs1d5d"; })
+  (fetchNuGet { pname = "System.Globalization"; version = "4.3.0"; sha256 = "1cp68vv683n6ic2zqh2s1fn4c2sd87g5hpp6l4d4nj4536jz98ki"; })
+  (fetchNuGet { pname = "System.Globalization.Calendars"; version = "4.0.1"; sha256 = "0bv0alrm2ck2zk3rz25lfyk9h42f3ywq77mx1syl6vvyncnpg4qh"; })
+  (fetchNuGet { pname = "System.Globalization.Calendars"; version = "4.3.0"; sha256 = "1xwl230bkakzzkrggy1l1lxmm3xlhk4bq2pkv790j5lm8g887lxq"; })
+  (fetchNuGet { pname = "System.Globalization.Extensions"; version = "4.0.1"; sha256 = "0hjhdb5ri8z9l93bw04s7ynwrjrhx2n0p34sf33a9hl9phz69fyc"; })
+  (fetchNuGet { pname = "System.Globalization.Extensions"; version = "4.3.0"; sha256 = "02a5zfxavhv3jd437bsncbhd2fp1zv4gxzakp1an9l6kdq1mcqls"; })
+  (fetchNuGet { pname = "System.IdentityModel.Tokens.Jwt"; version = "7.0.0"; sha256 = "15c717z4kspqxiwnia7dk1mj5gv7hg584q4x1xc7z1g0rnz28pwd"; })
+  (fetchNuGet { pname = "System.IdentityModel.Tokens.Jwt"; version = "7.1.2"; sha256 = "09ds8xanyd4zgncsl77gnlcz4kqw00s9ap3wvc6c8lrj91vmc58h"; })
+  (fetchNuGet { pname = "System.IO"; version = "4.1.0"; sha256 = "1g0yb8p11vfd0kbkyzlfsbsp5z44lwsvyc0h3dpw6vqnbi035ajp"; })
+  (fetchNuGet { pname = "System.IO"; version = "4.3.0"; sha256 = "05l9qdrzhm4s5dixmx68kxwif4l99ll5gqmh7rqgw554fx0agv5f"; })
+  (fetchNuGet { pname = "System.IO.Compression"; version = "4.1.0"; sha256 = "0iym7s3jkl8n0vzm3jd6xqg9zjjjqni05x45dwxyjr2dy88hlgji"; })
+  (fetchNuGet { pname = "System.IO.Compression"; version = "4.3.0"; sha256 = "084zc82yi6yllgda0zkgl2ys48sypiswbiwrv7irb3r0ai1fp4vz"; })
+  (fetchNuGet { pname = "System.IO.Compression.ZipFile"; version = "4.0.1"; sha256 = "0h72znbagmgvswzr46mihn7xm7chfk2fhrp5krzkjf29pz0i6z82"; })
+  (fetchNuGet { pname = "System.IO.Compression.ZipFile"; version = "4.3.0"; sha256 = "1yxy5pq4dnsm9hlkg9ysh5f6bf3fahqqb6p8668ndy5c0lk7w2ar"; })
+  (fetchNuGet { pname = "System.IO.FileSystem"; version = "4.0.1"; sha256 = "0kgfpw6w4djqra3w5crrg8xivbanh1w9dh3qapb28q060wb9flp1"; })
+  (fetchNuGet { pname = "System.IO.FileSystem"; version = "4.3.0"; sha256 = "0z2dfrbra9i6y16mm9v1v6k47f0fm617vlb7s5iybjjsz6g1ilmw"; })
+  (fetchNuGet { pname = "System.IO.FileSystem.Primitives"; version = "4.0.1"; sha256 = "1s0mniajj3lvbyf7vfb5shp4ink5yibsx945k6lvxa96r8la1612"; })
+  (fetchNuGet { pname = "System.IO.FileSystem.Primitives"; version = "4.3.0"; sha256 = "0j6ndgglcf4brg2lz4wzsh1av1gh8xrzdsn9f0yznskhqn1xzj9c"; })
+  (fetchNuGet { pname = "System.IO.FileSystem.Watcher"; version = "4.0.0"; sha256 = "0rgfjiqz8dqy8hmbfsls4sa46ss6p9vh86cvn1vqx7zg45pf3hir"; })
+  (fetchNuGet { pname = "System.IO.MemoryMappedFiles"; version = "4.0.0"; sha256 = "1ahp27llf76ngc0fngl8zy4y1sgflzrkmxddilnd0l0cbbq1lm6m"; })
+  (fetchNuGet { pname = "System.IO.Pipelines"; version = "6.0.3"; sha256 = "1jgdazpmwc21dd9naq3l9n5s8a1jnbwlvgkf1pnm0aji6jd4xqdz"; })
+  (fetchNuGet { pname = "System.IO.Pipelines"; version = "8.0.0"; sha256 = "00f36lqz1wf3x51kwk23gznkjjrf5nmqic9n7073nhrgrvb43nid"; })
+  (fetchNuGet { pname = "System.IO.UnmanagedMemoryStream"; version = "4.0.1"; sha256 = "012g8nwbfv94rhblsb3pxn1bazfpgjiy3kmy00679gg3651b87jb"; })
+  (fetchNuGet { pname = "System.Linq"; version = "4.1.0"; sha256 = "1ppg83svb39hj4hpp5k7kcryzrf3sfnm08vxd5sm2drrijsla2k5"; })
+  (fetchNuGet { pname = "System.Linq"; version = "4.3.0"; sha256 = "1w0gmba695rbr80l1k2h4mrwzbzsyfl2z4klmpbsvsg5pm4a56s7"; })
+  (fetchNuGet { pname = "System.Linq.Async"; version = "6.0.1"; sha256 = "10ira8hmv0i54yp9ggrrdm1c06j538sijfjpn1kmnh9j2xk5yzmq"; })
+  (fetchNuGet { pname = "System.Linq.Expressions"; version = "4.1.0"; sha256 = "1gpdxl6ip06cnab7n3zlcg6mqp7kknf73s8wjinzi4p0apw82fpg"; })
+  (fetchNuGet { pname = "System.Linq.Expressions"; version = "4.3.0"; sha256 = "0ky2nrcvh70rqq88m9a5yqabsl4fyd17bpr63iy2mbivjs2nyypv"; })
+  (fetchNuGet { pname = "System.Linq.Parallel"; version = "4.0.1"; sha256 = "0i33x9f4h3yq26yvv6xnq4b0v51rl5z8v1bm7vk972h5lvf4apad"; })
+  (fetchNuGet { pname = "System.Linq.Queryable"; version = "4.0.1"; sha256 = "11jn9k34g245yyf260gr3ldzvaqa9477w2c5nhb1p8vjx4xm3qaw"; })
+  (fetchNuGet { pname = "System.Management"; version = "6.0.1"; sha256 = "0va0y6a2pq9nxpyigsa3qxhga2ma7iqsab96b8jgssgs1g0y7dl3"; })
+  (fetchNuGet { pname = "System.Memory"; version = "4.5.1"; sha256 = "0f07d7hny38lq9w69wx4lxkn4wszrqf9m9js6fh9is645csm167c"; })
+  (fetchNuGet { pname = "System.Memory"; version = "4.5.3"; sha256 = "0naqahm3wljxb5a911d37mwjqjdxv9l0b49p5dmfyijvni2ppy8a"; })
+  (fetchNuGet { pname = "System.Net.Http"; version = "4.1.0"; sha256 = "1i5rqij1icg05j8rrkw4gd4pgia1978mqhjzhsjg69lvwcdfg8yb"; })
+  (fetchNuGet { pname = "System.Net.Http"; version = "4.3.0"; sha256 = "1i4gc757xqrzflbk7kc5ksn20kwwfjhw9w7pgdkn19y3cgnl302j"; })
+  (fetchNuGet { pname = "System.Net.Http"; version = "4.3.4"; sha256 = "0kdp31b8819v88l719j6my0yas6myv9d1viql3qz5577mv819jhl"; })
+  (fetchNuGet { pname = "System.Net.NameResolution"; version = "4.0.0"; sha256 = "0dj3pvpv069nyia28gkl4a0fb7q33hbxz2dg25qvpah3l7pbl0qh"; })
+  (fetchNuGet { pname = "System.Net.NameResolution"; version = "4.3.0"; sha256 = "15r75pwc0rm3vvwsn8rvm2krf929mjfwliv0mpicjnii24470rkq"; })
+  (fetchNuGet { pname = "System.Net.Primitives"; version = "4.0.11"; sha256 = "10xzzaynkzkakp7jai1ik3r805zrqjxiz7vcagchyxs2v26a516r"; })
+  (fetchNuGet { pname = "System.Net.Primitives"; version = "4.3.0"; sha256 = "0c87k50rmdgmxx7df2khd9qj7q35j9rzdmm2572cc55dygmdk3ii"; })
+  (fetchNuGet { pname = "System.Net.Requests"; version = "4.0.11"; sha256 = "13mka55sa6dg6nw4zdrih44gnp8hnj5azynz47ljsh2791lz3d9h"; })
+  (fetchNuGet { pname = "System.Net.Security"; version = "4.0.0"; sha256 = "0ybyfssnm0cri37byhxnkfrzprz77nizbfj553x7s1vry2pnm5gb"; })
+  (fetchNuGet { pname = "System.Net.Sockets"; version = "4.1.0"; sha256 = "1385fvh8h29da5hh58jm1v78fzi9fi5vj93vhlm2kvqpfahvpqls"; })
+  (fetchNuGet { pname = "System.Net.Sockets"; version = "4.3.0"; sha256 = "1ssa65k6chcgi6mfmzrznvqaxk8jp0gvl77xhf1hbzakjnpxspla"; })
+  (fetchNuGet { pname = "System.Net.WebHeaderCollection"; version = "4.0.1"; sha256 = "10bxpxj80c4z00z3ksrfswspq9qqsw8jwxcbzvymzycb97m9b55q"; })
+  (fetchNuGet { pname = "System.Net.WebSockets.WebSocketProtocol"; version = "4.5.3"; sha256 = "0z9ccndkkq6gpsh35q3pjm4zya47p6vakcyj8nc352g4wiizqc8c"; })
+  (fetchNuGet { pname = "System.Numerics.Vectors"; version = "4.1.1"; sha256 = "1xkzrpl700pp0l6dc9fx7cj318i596w0i0qixsbrz5v65fnhbzia"; })
+  (fetchNuGet { pname = "System.ObjectModel"; version = "4.0.12"; sha256 = "1sybkfi60a4588xn34nd9a58png36i0xr4y4v4kqpg8wlvy5krrj"; })
+  (fetchNuGet { pname = "System.ObjectModel"; version = "4.3.0"; sha256 = "191p63zy5rpqx7dnrb3h7prvgixmk168fhvvkkvhlazncf8r3nc2"; })
+  (fetchNuGet { pname = "System.Private.Uri"; version = "4.3.0"; sha256 = "04r1lkdnsznin0fj4ya1zikxiqr0h6r6a1ww2dsm60gqhdrf0mvx"; })
+  (fetchNuGet { pname = "System.Reactive"; version = "6.0.0"; sha256 = "1mkvx1fwychpczksy6svfmniqhbm3xqblxqik6178l12xgq7aw45"; })
+  (fetchNuGet { pname = "System.Reflection"; version = "4.1.0"; sha256 = "1js89429pfw79mxvbzp8p3q93il6rdff332hddhzi5wqglc4gml9"; })
+  (fetchNuGet { pname = "System.Reflection"; version = "4.3.0"; sha256 = "0xl55k0mw8cd8ra6dxzh974nxif58s3k1rjv1vbd7gjbjr39j11m"; })
+  (fetchNuGet { pname = "System.Reflection.DispatchProxy"; version = "4.0.1"; sha256 = "1maglcnvm3h8bfmx3rvwg4wjda7527iqp38cg1r6vh9japrw1n0r"; })
+  (fetchNuGet { pname = "System.Reflection.Emit"; version = "4.0.1"; sha256 = "0ydqcsvh6smi41gyaakglnv252625hf29f7kywy2c70nhii2ylqp"; })
+  (fetchNuGet { pname = "System.Reflection.Emit"; version = "4.3.0"; sha256 = "11f8y3qfysfcrscjpjym9msk7lsfxkk4fmz9qq95kn3jd0769f74"; })
+  (fetchNuGet { pname = "System.Reflection.Emit"; version = "4.7.0"; sha256 = "121l1z2ypwg02yz84dy6gr82phpys0njk7yask3sihgy214w43qp"; })
+  (fetchNuGet { pname = "System.Reflection.Emit.ILGeneration"; version = "4.0.1"; sha256 = "1pcd2ig6bg144y10w7yxgc9d22r7c7ww7qn1frdfwgxr24j9wvv0"; })
+  (fetchNuGet { pname = "System.Reflection.Emit.ILGeneration"; version = "4.3.0"; sha256 = "0w1n67glpv8241vnpz1kl14sy7zlnw414aqwj4hcx5nd86f6994q"; })
+  (fetchNuGet { pname = "System.Reflection.Emit.Lightweight"; version = "4.0.1"; sha256 = "1s4b043zdbx9k39lfhvsk68msv1nxbidhkq6nbm27q7sf8xcsnxr"; })
+  (fetchNuGet { pname = "System.Reflection.Emit.Lightweight"; version = "4.3.0"; sha256 = "0ql7lcakycrvzgi9kxz1b3lljd990az1x6c4jsiwcacrvimpib5c"; })
+  (fetchNuGet { pname = "System.Reflection.Extensions"; version = "4.0.1"; sha256 = "0m7wqwq0zqq9gbpiqvgk3sr92cbrw7cp3xn53xvw7zj6rz6fdirn"; })
+  (fetchNuGet { pname = "System.Reflection.Extensions"; version = "4.3.0"; sha256 = "02bly8bdc98gs22lqsfx9xicblszr2yan7v2mmw3g7hy6miq5hwq"; })
+  (fetchNuGet { pname = "System.Reflection.Metadata"; version = "1.3.0"; sha256 = "1y5m6kryhjpqqm2g3h3b6bzig13wkiw954x3b7icqjm6xypm1x3b"; })
+  (fetchNuGet { pname = "System.Reflection.Metadata"; version = "1.6.0"; sha256 = "1wdbavrrkajy7qbdblpbpbalbdl48q3h34cchz24gvdgyrlf15r4"; })
+  (fetchNuGet { pname = "System.Reflection.Metadata"; version = "6.0.1"; sha256 = "0fjqifk4qz9lw5gcadpfalpplyr0z2b3p9x7h0ll481a9sqvppc9"; })
+  (fetchNuGet { pname = "System.Reflection.Primitives"; version = "4.0.1"; sha256 = "1bangaabhsl4k9fg8khn83wm6yial8ik1sza7401621jc6jrym28"; })
+  (fetchNuGet { pname = "System.Reflection.Primitives"; version = "4.3.0"; sha256 = "04xqa33bld78yv5r93a8n76shvc8wwcdgr1qvvjh959g3rc31276"; })
+  (fetchNuGet { pname = "System.Reflection.TypeExtensions"; version = "4.1.0"; sha256 = "1bjli8a7sc7jlxqgcagl9nh8axzfl11f4ld3rjqsyxc516iijij7"; })
+  (fetchNuGet { pname = "System.Reflection.TypeExtensions"; version = "4.3.0"; sha256 = "0y2ssg08d817p0vdag98vn238gyrrynjdj4181hdg780sif3ykp1"; })
+  (fetchNuGet { pname = "System.Resources.Reader"; version = "4.0.0"; sha256 = "1jafi73dcf1lalrir46manq3iy6xnxk2z7gpdpwg4wqql7dv3ril"; })
+  (fetchNuGet { pname = "System.Resources.ResourceManager"; version = "4.0.1"; sha256 = "0b4i7mncaf8cnai85jv3wnw6hps140cxz8vylv2bik6wyzgvz7bi"; })
+  (fetchNuGet { pname = "System.Resources.ResourceManager"; version = "4.3.0"; sha256 = "0sjqlzsryb0mg4y4xzf35xi523s4is4hz9q4qgdvlvgivl7qxn49"; })
+  (fetchNuGet { pname = "System.Runtime"; version = "4.1.0"; sha256 = "02hdkgk13rvsd6r9yafbwzss8kr55wnj8d5c7xjnp8gqrwc8sn0m"; })
+  (fetchNuGet { pname = "System.Runtime"; version = "4.3.0"; sha256 = "066ixvgbf2c929kgknshcxqj6539ax7b9m570cp8n179cpfkapz7"; })
+  (fetchNuGet { pname = "System.Runtime.Caching"; version = "8.0.0"; sha256 = "0d0wgbbb96svhdx2fl4disd27fvhsf3x2mafkz6dzp02bh3c31n0"; })
+  (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "4.5.1"; sha256 = "1xcrjx5fwg284qdnxyi2d0lzdm5q4frlpkp0nf6vvkx1kdz2prrf"; })
+  (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "5.0.0"; sha256 = "02k25ivn50dmqx5jn8hawwmz24yf0454fjd823qk6lygj9513q4x"; })
+  (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "6.0.0"; sha256 = "0qm741kh4rh57wky16sq4m0v05fxmkjjr87krycf5vp9f0zbahbc"; })
+  (fetchNuGet { pname = "System.Runtime.Extensions"; version = "4.1.0"; sha256 = "0rw4rm4vsm3h3szxp9iijc3ksyviwsv6f63dng3vhqyg4vjdkc2z"; })
+  (fetchNuGet { pname = "System.Runtime.Extensions"; version = "4.3.0"; sha256 = "1ykp3dnhwvm48nap8q23893hagf665k0kn3cbgsqpwzbijdcgc60"; })
+  (fetchNuGet { pname = "System.Runtime.Handles"; version = "4.0.1"; sha256 = "1g0zrdi5508v49pfm3iii2hn6nm00bgvfpjq1zxknfjrxxa20r4g"; })
+  (fetchNuGet { pname = "System.Runtime.Handles"; version = "4.3.0"; sha256 = "0sw2gfj2xr7sw9qjn0j3l9yw07x73lcs97p8xfc9w1x9h5g5m7i8"; })
+  (fetchNuGet { pname = "System.Runtime.InteropServices"; version = "4.1.0"; sha256 = "01kxqppx3dr3b6b286xafqilv4s2n0gqvfgzfd4z943ga9i81is1"; })
+  (fetchNuGet { pname = "System.Runtime.InteropServices"; version = "4.3.0"; sha256 = "00hywrn4g7hva1b2qri2s6rabzwgxnbpw9zfxmz28z09cpwwgh7j"; })
+  (fetchNuGet { pname = "System.Runtime.InteropServices.RuntimeInformation"; version = "4.0.0"; sha256 = "0glmvarf3jz5xh22iy3w9v3wyragcm4hfdr17v90vs7vcrm7fgp6"; })
+  (fetchNuGet { pname = "System.Runtime.InteropServices.RuntimeInformation"; version = "4.3.0"; sha256 = "0q18r1sh4vn7bvqgd6dmqlw5v28flbpj349mkdish2vjyvmnb2ii"; })
+  (fetchNuGet { pname = "System.Runtime.Loader"; version = "4.0.0"; sha256 = "0lpfi3psqcp6zxsjk2qyahal7zaawviimc8lhrlswhip2mx7ykl0"; })
+  (fetchNuGet { pname = "System.Runtime.Numerics"; version = "4.0.1"; sha256 = "1y308zfvy0l5nrn46mqqr4wb4z1xk758pkk8svbz8b5ij7jnv4nn"; })
+  (fetchNuGet { pname = "System.Runtime.Numerics"; version = "4.3.0"; sha256 = "19rav39sr5dky7afygh309qamqqmi9kcwvz3i0c5700v0c5cg61z"; })
+  (fetchNuGet { pname = "System.Runtime.Serialization.Formatters"; version = "4.3.0"; sha256 = "114j35n8gcvn3sqv9ar36r1jjq0y1yws9r0yk8i6wm4aq7n9rs0m"; })
+  (fetchNuGet { pname = "System.Runtime.Serialization.Primitives"; version = "4.3.0"; sha256 = "01vv2p8h4hsz217xxs0rixvb7f2xzbh6wv1gzbfykcbfrza6dvnf"; })
+  (fetchNuGet { pname = "System.Security.AccessControl"; version = "5.0.0"; sha256 = "17n3lrrl6vahkqmhlpn3w20afgz09n7i6rv0r3qypngwi7wqdr5r"; })
+  (fetchNuGet { pname = "System.Security.Claims"; version = "4.0.1"; sha256 = "03dw0ls49bvsrffgwycyifjgz0qzr9r85skqhdyhfd51fqf398n6"; })
+  (fetchNuGet { pname = "System.Security.Claims"; version = "4.3.0"; sha256 = "0jvfn7j22l3mm28qjy3rcw287y9h65ha4m940waaxah07jnbzrhn"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Algorithms"; version = "4.2.0"; sha256 = "148s9g5dgm33ri7dnh19s4lgnlxbpwvrw2jnzllq2kijj4i4vs85"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Algorithms"; version = "4.3.0"; sha256 = "03sq183pfl5kp7gkvq77myv7kbpdnq3y0xj7vi4q1kaw54sny0ml"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Cng"; version = "4.2.0"; sha256 = "118jijz446kix20blxip0f0q8mhsh9bz118mwc2ch1p6g7facpzc"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Cng"; version = "4.3.0"; sha256 = "1k468aswafdgf56ab6yrn7649kfqx2wm9aslywjam1hdmk5yypmv"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Csp"; version = "4.0.0"; sha256 = "1cwv8lqj8r15q81d2pz2jwzzbaji0l28xfrpw29kdpsaypm92z2q"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Csp"; version = "4.3.0"; sha256 = "1x5wcrddf2s3hb8j78cry7yalca4lb5vfnkrysagbn6r9x6xvrx1"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Encoding"; version = "4.0.0"; sha256 = "0a8y1a5wkmpawc787gfmnrnbzdgxmx1a14ax43jf3rj9gxmy3vk4"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Encoding"; version = "4.3.0"; sha256 = "1jr6w70igqn07k5zs1ph6xja97hxnb3mqbspdrff6cvssgrixs32"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.OpenSsl"; version = "4.0.0"; sha256 = "16sx3cig3d0ilvzl8xxgffmxbiqx87zdi8fc73i3i7zjih1a7f4q"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0givpvvj8yc7gv4lhb6s1prq6p2c4147204a0wib89inqzd87gqc"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Pkcs"; version = "8.0.0"; sha256 = "04kqf1lhsq3fngiljanmrz2774x5h2fc8p57v04c51jwwqhwi9ya"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Primitives"; version = "4.0.0"; sha256 = "0i7cfnwph9a10bm26m538h5xcr8b36jscp9sy1zhgifksxz4yixh"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Primitives"; version = "4.3.0"; sha256 = "0pyzncsv48zwly3lw4f2dayqswcfvdwq2nz0dgwmi7fj3pn64wby"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.ProtectedData"; version = "4.4.0"; sha256 = "1q8ljvqhasyynp94a1d7jknk946m20lkwy2c3wa8zw2pc517fbj6"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.ProtectedData"; version = "8.0.0"; sha256 = "1ysjx3b5ips41s32zacf4vs7ig41906mxrsbmykdzi0hvdmjkgbx"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.X509Certificates"; version = "4.1.0"; sha256 = "0clg1bv55mfv5dq00m19cp634zx6inm31kf8ppbq1jgyjf2185dh"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.X509Certificates"; version = "4.3.0"; sha256 = "0valjcz5wksbvijylxijjxb1mp38mdhv03r533vnx1q3ikzdav9h"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.Xml"; version = "8.0.0"; sha256 = "0x9xpq5i49qss2phv95m76jpf8y8qw6lwx2x52x8i8f1sjpkqa2x"; })
+  (fetchNuGet { pname = "System.Security.Principal"; version = "4.0.1"; sha256 = "1nbzdfqvzzbgsfdd5qsh94d7dbg2v4sw0yx6himyn52zf8z6007p"; })
+  (fetchNuGet { pname = "System.Security.Principal"; version = "4.3.0"; sha256 = "12cm2zws06z4lfc4dn31iqv7072zyi4m910d4r6wm8yx85arsfxf"; })
+  (fetchNuGet { pname = "System.Security.Principal.Windows"; version = "4.0.0"; sha256 = "1d3vc8i0zss9z8p4qprls4gbh7q4218l9845kclx7wvw41809k6z"; })
+  (fetchNuGet { pname = "System.Security.Principal.Windows"; version = "4.3.0"; sha256 = "00a0a7c40i3v4cb20s2cmh9csb5jv2l0frvnlzyfxh848xalpdwr"; })
+  (fetchNuGet { pname = "System.Security.Principal.Windows"; version = "5.0.0"; sha256 = "1mpk7xj76lxgz97a5yg93wi8lj0l8p157a5d50mmjy3gbz1904q8"; })
+  (fetchNuGet { pname = "System.Text.Encoding"; version = "4.0.11"; sha256 = "1dyqv0hijg265dwxg6l7aiv74102d6xjiwplh2ar1ly6xfaa4iiw"; })
+  (fetchNuGet { pname = "System.Text.Encoding"; version = "4.3.0"; sha256 = "1f04lkir4iladpp51sdgmis9dj4y8v08cka0mbmsy0frc9a4gjqr"; })
+  (fetchNuGet { pname = "System.Text.Encoding.CodePages"; version = "4.0.1"; sha256 = "00wpm3b9y0k996rm9whxprngm8l500ajmzgy2ip9pgwk0icp06y3"; })
+  (fetchNuGet { pname = "System.Text.Encoding.CodePages"; version = "6.0.0"; sha256 = "0gm2kiz2ndm9xyzxgi0jhazgwslcs427waxgfa30m7yqll1kcrww"; })
+  (fetchNuGet { pname = "System.Text.Encoding.Extensions"; version = "4.0.11"; sha256 = "08nsfrpiwsg9x5ml4xyl3zyvjfdi4mvbqf93kjdh11j4fwkznizs"; })
+  (fetchNuGet { pname = "System.Text.Encoding.Extensions"; version = "4.3.0"; sha256 = "11q1y8hh5hrp5a3kw25cb6l00v5l5dvirkz8jr3sq00h1xgcgrxy"; })
+  (fetchNuGet { pname = "System.Text.Encodings.Web"; version = "8.0.0"; sha256 = "1wbypkx0m8dgpsaqgyywz4z760xblnwalb241d5qv9kx8m128i11"; })
+  (fetchNuGet { pname = "System.Text.Json"; version = "8.0.0"; sha256 = "134savxw0sq7s448jnzw17bxcijsi1v38mirpbb6zfxmqlf04msw"; })
+  (fetchNuGet { pname = "System.Text.RegularExpressions"; version = "4.1.0"; sha256 = "1mw7vfkkyd04yn2fbhm38msk7dz2xwvib14ygjsb8dq2lcvr18y7"; })
+  (fetchNuGet { pname = "System.Text.RegularExpressions"; version = "4.3.0"; sha256 = "1bgq51k7fwld0njylfn7qc5fmwrk2137gdq7djqdsw347paa9c2l"; })
+  (fetchNuGet { pname = "System.Threading"; version = "4.0.11"; sha256 = "19x946h926bzvbsgj28csn46gak2crv2skpwsx80hbgazmkgb1ls"; })
+  (fetchNuGet { pname = "System.Threading"; version = "4.3.0"; sha256 = "0rw9wfamvhayp5zh3j7p1yfmx9b5khbf4q50d8k5rk993rskfd34"; })
+  (fetchNuGet { pname = "System.Threading.Channels"; version = "6.0.0"; sha256 = "1qbyi7yymqc56frqy7awvcqc1m7x3xrpx87a37dgb3mbrjg9hlcj"; })
+  (fetchNuGet { pname = "System.Threading.Channels"; version = "7.0.0"; sha256 = "1qrmqa6hpzswlmyp3yqsbnmia9i5iz1y208xpqc1y88b1f6j1v8a"; })
+  (fetchNuGet { pname = "System.Threading.Overlapped"; version = "4.0.1"; sha256 = "0fi79az3vmqdp9mv3wh2phblfjls89zlj6p9nc3i9f6wmfarj188"; })
+  (fetchNuGet { pname = "System.Threading.Tasks"; version = "4.0.11"; sha256 = "0nr1r41rak82qfa5m0lhk9mp0k93bvfd7bbd9sdzwx9mb36g28p5"; })
+  (fetchNuGet { pname = "System.Threading.Tasks"; version = "4.3.0"; sha256 = "134z3v9abw3a6jsw17xl3f6hqjpak5l682k2vz39spj4kmydg6k7"; })
+  (fetchNuGet { pname = "System.Threading.Tasks.Dataflow"; version = "4.6.0"; sha256 = "0a1davr71wssyn4z1hr75lk82wqa0daz0vfwkmg1fm3kckfd72k1"; })
+  (fetchNuGet { pname = "System.Threading.Tasks.Extensions"; version = "4.0.0"; sha256 = "1cb51z062mvc2i8blpzmpn9d9mm4y307xrwi65di8ri18cz5r1zr"; })
+  (fetchNuGet { pname = "System.Threading.Tasks.Extensions"; version = "4.3.0"; sha256 = "1xxcx2xh8jin360yjwm4x4cf5y3a2bwpn2ygkfkwkicz7zk50s2z"; })
+  (fetchNuGet { pname = "System.Threading.Tasks.Parallel"; version = "4.0.1"; sha256 = "114wdg32hr46dfsnns3pgs67kcha5jn47p5gg0mhxfn5vrkr2p75"; })
+  (fetchNuGet { pname = "System.Threading.Thread"; version = "4.0.0"; sha256 = "1gxxm5fl36pjjpnx1k688dcw8m9l7nmf802nxis6swdaw8k54jzc"; })
+  (fetchNuGet { pname = "System.Threading.ThreadPool"; version = "4.0.10"; sha256 = "0fdr61yjcxh5imvyf93n2m3n5g9pp54bnw2l1d2rdl9z6dd31ypx"; })
+  (fetchNuGet { pname = "System.Threading.ThreadPool"; version = "4.3.0"; sha256 = "027s1f4sbx0y1xqw2irqn6x161lzj8qwvnh2gn78ciiczdv10vf1"; })
+  (fetchNuGet { pname = "System.Threading.Timer"; version = "4.0.1"; sha256 = "15n54f1f8nn3mjcjrlzdg6q3520571y012mx7v991x2fvp73lmg6"; })
+  (fetchNuGet { pname = "System.Threading.Timer"; version = "4.3.0"; sha256 = "1nx773nsx6z5whv8kaa1wjh037id2f1cxhb69pvgv12hd2b6qs56"; })
+  (fetchNuGet { pname = "System.Xml.ReaderWriter"; version = "4.0.11"; sha256 = "0c6ky1jk5ada9m94wcadih98l6k1fvf6vi7vhn1msjixaha419l5"; })
+  (fetchNuGet { pname = "System.Xml.ReaderWriter"; version = "4.3.0"; sha256 = "0c47yllxifzmh8gq6rq6l36zzvw4kjvlszkqa9wq3fr59n0hl3s1"; })
+  (fetchNuGet { pname = "System.Xml.XDocument"; version = "4.0.11"; sha256 = "0n4lvpqzy9kc7qy1a4acwwd7b7pnvygv895az5640idl2y9zbz18"; })
+  (fetchNuGet { pname = "System.Xml.XDocument"; version = "4.3.0"; sha256 = "08h8fm4l77n0nd4i4fk2386y809bfbwqb7ih9d7564ifcxr5ssxd"; })
+  (fetchNuGet { pname = "System.Xml.XmlDocument"; version = "4.0.1"; sha256 = "0ihsnkvyc76r4dcky7v3ansnbyqjzkbyyia0ir5zvqirzan0bnl1"; })
+  (fetchNuGet { pname = "System.Xml.XmlDocument"; version = "4.3.0"; sha256 = "0bmz1l06dihx52jxjr22dyv5mxv6pj4852lx68grjm7bivhrbfwi"; })
+  (fetchNuGet { pname = "System.Xml.XPath"; version = "4.0.1"; sha256 = "0fjqgb6y66d72d5n8qq1h213d9nv2vi8mpv8p28j3m9rccmsh04m"; })
+  (fetchNuGet { pname = "System.Xml.XPath.XDocument"; version = "4.0.1"; sha256 = "1fndc70lbjvh8kxs71c7cidfm8plznd61bg4fwpiyq3mq0qg5z0z"; })
+  (fetchNuGet { pname = "Tavis.UriTemplates"; version = "2.0.0"; sha256 = "089xzz4pcqx1zf8b0crmh1ac6s4bmdr75m1n63hja5j6kqgxbpa5"; })
+  (fetchNuGet { pname = "TestableIO.System.IO.Abstractions"; version = "20.0.4"; sha256 = "16jw4zw8pvck754r6744d11460w1fih8c77r8yzzw2w58iv2mns6"; })
+  (fetchNuGet { pname = "TestableIO.System.IO.Abstractions.TestingHelpers"; version = "20.0.4"; sha256 = "06h43ds6pmcnjxlphhhqg3sriisi53y583rhdgfdqdg6jpa144mn"; })
+  (fetchNuGet { pname = "TestableIO.System.IO.Abstractions.Wrappers"; version = "20.0.4"; sha256 = "1c5sf8dva9vswl2qqkc6xcmznia8d5nqw46yvk4b1f9idv53j5nz"; })
+  (fetchNuGet { pname = "Websocket.Client"; version = "5.0.0"; sha256 = "0pw1yw8wa70ghy5hy69zsni42fq7m9ml3chyrhy3hdz02ix4rpgy"; })
+  (fetchNuGet { pname = "YamlDotNet"; version = "13.3.1"; sha256 = "1wjwmaxs316npbawswq74mm3rlhydyfyx36dh7n9iv07ac0va5b9"; })
+  (fetchNuGet { pname = "YamlDotNet"; version = "13.7.1"; sha256 = "1m2lnfb2r8382fpjyxp79wnbis7l462zksj3618142q53y33bk5z"; })
 ]
diff --git a/packages/default.nix b/packages/default.nix
index df8990a2..108655dd 100644
--- a/packages/default.nix
+++ b/packages/default.nix
@@ -44,7 +44,7 @@
       besu = callPackage ./clients/execution/besu {};
       geth = callPackage ./clients/execution/geth {};
       geth-sealer = callPackage ./clients/execution/geth-sealer {};
-      nethermind = callPackage ./clients/execution/nethermind {};
+      nethermind = callPackageUnstable ./clients/execution/nethermind {};
       reth = callPackageUnstable ./clients/execution/reth {};
 
       # Signers

From fba79f7483dc5fd1de485d93b88712a2d8e9bf54 Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Tue, 23 Jan 2024 17:02:15 +0200
Subject: [PATCH 37/38] config(modules/nethermind): Use new executable

---
 modules/nethermind/default.nix | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/nethermind/default.nix b/modules/nethermind/default.nix
index 999af403..3286868c 100644
--- a/modules/nethermind/default.nix
+++ b/modules/nethermind/default.nix
@@ -136,7 +136,7 @@ in {
                 {
                   User = serviceName;
                   StateDirectory = serviceName;
-                  ExecStart = "${cfg.package}/bin/Nethermind.Runner ${scriptArgs}";
+                  ExecStart = "${cfg.package}/bin/nethermind ${scriptArgs}";
 
                   MemoryDenyWriteExecute = false;
                 }

From 98be43ba7ab43d4f3c2a931bb0e5e795c17fef5b Mon Sep 17 00:00:00 2001
From: Martin Nikov <mnikov12@gmail.com>
Date: Tue, 6 Feb 2024 16:21:20 +0200
Subject: [PATCH 38/38] feat(modules): Add initial `rocketpool` module

not all arguments are passed into the module
---
 modules/default.nix            |   1 +
 modules/rocketpool/args.nix    | 498 +++++++++++++++++++++++++++++++++
 modules/rocketpool/default.nix | 167 +++++++++++
 modules/rocketpool/options.nix |  46 +++
 4 files changed, 712 insertions(+)
 create mode 100644 modules/rocketpool/args.nix
 create mode 100644 modules/rocketpool/default.nix
 create mode 100644 modules/rocketpool/options.nix

diff --git a/modules/default.nix b/modules/default.nix
index ef02322b..b06a9216 100644
--- a/modules/default.nix
+++ b/modules/default.nix
@@ -19,6 +19,7 @@
       ./prysm-validator
       ./restore
       ./nimbus-eth2
+      ./rocketpool-service
     ];
   };
 }
diff --git a/modules/rocketpool/args.nix b/modules/rocketpool/args.nix
new file mode 100644
index 00000000..05ebde3e
--- /dev/null
+++ b/modules/rocketpool/args.nix
@@ -0,0 +1,498 @@
+lib:
+with lib; {
+  executionClientMode = mkOption {
+    type = types.enum ["local" "external"];
+    default = "local";
+    example = "external";
+    description = mdDoc ''
+      Choose which mode to use for your Execution client -
+      locally managed (Docker Mode), or externally managed (Hybrid Mode).
+    '';
+  };
+
+  executionClient = mkOption {
+    type = types.enum ["geth" "nethermind" "besu"];
+    default = "geth";
+    example = "nethermind";
+    description = mdDoc "Select which Execution client you would like to run.";
+  };
+
+  useFallbackClients = mkOption {
+    type = types.bool;
+    default = false;
+    description = mdDoc ''
+      Enable this if you would like to specify a fallback Execution and Consensus Client,
+      which will temporarily be used by the Smartnode and your Validator Client if
+      your primary Execution / Consensus client pair ever go offline
+      (e.g. if you switch, prune, or resync your clients).
+    '';
+  };
+
+  reconnectDelay = mkOption {
+    type = types.nullOr types.str;
+    default = null;
+    example = "60s";
+    description = mdDoc ''
+      The delay to wait after your primary
+      Execution or Consensus clients fail before trying to reconnect to them.
+      An example format is "10h20m30s" - this would make it 10 hours, 20 minutes, and 30 seconds.
+    '';
+  };
+
+  consensusClientMode = mkOption {
+    type = types.nullOr types.str;
+    default = null;
+    description = mdDoc ''
+      Choose which mode to use for your Consensus client -
+      locally managed (Docker Mode), or externally managed (Hybrid Mode).
+    '';
+  };
+
+  consensusClient = mkOption {
+    type = types.nullOr types.str;
+    default = null;
+    description = mdDoc ''Select which Consensus client you would like to use.'';
+  };
+
+  externalConsensusClient = mkOption {
+    type = types.nullOr types.str;
+    default = null;
+    description = mdDoc ''Select which Consensus client your externally managed client is.'';
+  };
+
+  # Metrics
+
+  enableMetrics = lib.mkEnableOption (mdDoc ''
+    the Smartnode's performance and status metrics system.
+    This will provide you with the node operator's Grafana dashboard.
+  '');
+
+  # Smartnode
+
+  smartnode-network = mkOption {
+    type = types.nullOr (types.enum ["mainnet" "prater" "holesky"]);
+    default = null;
+    description = mdDoc ''      
+      The Ethereum network you want to use - select Prater Testnet or Holesky Testnet 
+      to practice with fake ETH, or Mainnet to stake on the real network using real ETH.'';
+  };
+
+  smartnode-projectName = mkOption {
+    type = types.nullOr types.str;
+    default = null;
+    description = mdDoc ''      
+      This is the prefix that will be attached to all of the 
+      Docker containers managed by the Smartnode.'';
+  };
+
+  smartnode-dataPath = mkOption {
+    type = types.nullOr types.str;
+    default = null;
+    description = mdDoc ''      
+      The absolute path of the data folder that contains 
+      your node wallet's encrypted file, the password for your node wallet, and 
+      all of the validator keys for your minipools. You may use environment variables 
+      in this string.'';
+  };
+
+  smartnode-manualMaxFee = mkOption {
+    type = types.nullOr types.float;
+    default = null;
+    description = mdDoc ''
+      Set this if you want all of the Smartnode's transactions 
+      to use this specific max fee value (in gwei), which is the most you'd be willing 
+      to pay (*including the priority fee*).'';
+  };
+
+  smartnode-priorityFee = mkOption {
+    type = types.nullOr types.float;
+    default = null;
+    description = mdDoc ''
+      The default value for the priority fee (in gwei) for all 
+      of your transactions. This describes how much you're willing to pay *above the network's 
+      current base fee* - the higher this is, the more ETH you give to the validators for 
+      including your transaction, which generally means it will be included in a block faster 
+      (as long as your max fee is sufficiently high to cover the current network conditions).'';
+  };
+
+  smartnode-minipoolStakeGasThreshold = mkOption {
+    type = types.nullOr types.float;
+    default = null;
+    description = mdDoc ''
+      Occasionally, the Smartnode will attempt to perform some automatic transactions
+      (such as the second stake transaction to finish launching a minipool or the 
+      `reduce bond` transaction to convert a 16-ETH minipool to an 8-ETH one). During these, 
+      your node will use the `Rapid` suggestion from the gas estimator as its max fee.'';
+  };
+
+  smartnode-distributeThreshold = mkOption {
+    type = types.nullOr types.float;
+    default = null;
+    description = mdDoc ''The Smartnode will regularly check the balance of each of your minipools on the Execution Layer (**not** the Beacon Chain).'';
+  };
+
+  smartnode-rewardsTreeMode = mkOption {
+    type = types.nullOr (types.enum ["download" "generate"]);
+    default = null;
+    description = mdDoc ''Select how you want to acquire the Merkle Tree files for each rewards interval.'';
+  };
+
+  smartnode-rewardsTreeCustomUrl = mkOption {
+    type = types.nullOr types.str;
+    default = null;
+    description = mdDoc ''
+      The Smartnode will automatically download missing rewards
+      tree files from trusted sources like IPFS and Rocket Pool's repository on GitHub. 
+      Use this field if you would like to manually specify additional sources that host the 
+      rewards tree files, so the Smartnode can download from them as well.'';
+  };
+
+  smartnode-archiveECUrl = mkOption {
+    type = types.nullOr types.str;
+    default = null;
+    description = mdDoc ''
+      **For manual Merkle rewards tree generation only.**[white]
+      Generating the Merkle rewards tree files for past rewards intervals typically 
+      requires an Execution client with Archive mode enabled, which is usually disabled 
+      on your primary and fallback Execution clients to save disk space.
+      If you want to generate your own rewards tree files for intervals from a long 
+      time ago, you may enter the URL of an Execution client with Archive access here.
+      For a free light client with Archive access, you may use https://www.alchemy.com/supernode.'';
+  };
+
+  smartnode-watchtowerMaxFeeOverride = mkOption {
+    type = types.nullOr types.float;
+    default = null;
+    description = mdDoc ''
+      **For Oracle DAO members only.**
+      Use this to override the max fee (in gwei) for watchtower transactions. 
+      Note that if you set it below 200, the setting will be ignored; it can only 
+      be used to set the max fee higher than 200 during times of extreme network stress.
+      For Oracle DAO members only.'';
+  };
+
+  smartnode-watchtowerPrioFeeOverride = mkOption {
+    type = types.nullOr types.float;
+    default = null;
+    description = mdDoc ''
+      **For Oracle DAO members only.**
+      Use this to override the priority fee (in gwei) for watchtower transactions. 
+      Note that if you set it below 3, the setting will be ignored; it can only be
+      used to set the priority fee higher than 3 during times of extreme network stress.'';
+  };
+
+  smartnode-useRollingRecords = mkOption {
+    type = types.nullOr types.bool;
+    default = null;
+    description = mdDoc ''
+      **WARNING: EXPERIMENTAL**
+
+      Enable this to use the new rolling records feature, which stores attestation
+      records for the entire Rocket Pool network in real time instead of collecting
+      them all after a rewards period during tree generation.
+      Only useful for the Oracle DAO, or if you generate your own rewards trees.
+    '';
+  };
+
+  smartnode-recordCheckpointInterval = mkOption {
+    type = types.nullOr types.ints.unsigned;
+    default = null;
+    description = mdDoc ''The number of epochs that should pass before saving a new rolling record checkpoint. Used if Rolling Records is enabled.'';
+  };
+
+  smartnode-checkpointRetentionLimit = mkOption {
+    type = types.nullOr types.ints.unsigned;
+    default = null;
+    description = mdDoc ''The number of checkpoint files to save on-disk before pruning old ones. Used if Rolling Records is enabled.'';
+  };
+
+  smartnode-recordsPath = mkOption {
+    type = types.nullOr types.str;
+    default = null;
+    description = mdDoc ''The path of the folder to store rolling record checkpoints in during a rewards interval. Used if Rolling Records is enabled.'';
+  };
+
+  # Geth
+
+  geth-enablePbss = lib.mkEnableOption (mdDoc ''
+    rocketpool service resync-eth1  Enable Geth's new path-based state scheme. 
+    With this enabled, you will no longer need to manually prune Geth; it will automatically prune its database in real-time.
+
+    NOTE:
+    Enabling this will require you to remove and resync your Geth DB using rocketpool service resync-eth1.
+    You will need a synced fallback node configured before doing this, or you will no longer be able to attest until it has finished resyncing!'');
+
+  geth-maxPeers = mkOption {
+    type = types.nullOr types.ints.u16;
+    default = null;
+    description = mdDoc ''
+      The maximum number of peers Geth should connect to. This can be lowered to improve
+      performance on low-power systems or constrained config.Networks. We recommend keeping it at 12 or higher.'';
+  };
+
+  geth-containerTag = mkOption {
+    type = types.nullOr types.str;
+    default = null;
+    description = mdDoc ''The tag name of the Geth container you want to use on Docker Hub.'';
+  };
+
+  geth-additionalFlags = mkOption {
+    type = types.nullOr (types.listOf types.str);
+    default = null;
+    description = mdDoc ''
+      Additional custom command line flags you want to pass to Geth, to take advantage
+      of other settings that the Smartnode's configuration doesn't cover.'';
+  };
+
+  # Nethermind
+
+  nethermind-cache = mkOption {
+    type = types.nullOr types.ints.unsigned;
+    default = null;
+    description = mdDoc ''
+      The amount of RAM (in MB) you want to suggest for Nethermind's cache. 
+      While there is no guarantee that Nethermind will stay under this limit, 
+      lower values are preferred for machines with less RAM.'';
+  };
+
+  nethermind-maxPeers = mkOption {
+    type = types.nullOr types.ints.u16;
+    default = null;
+    description = mdDoc ''
+      The maximum number of peers Nethermind should connect to. This can be lowered
+       to improve performance on low-power systems or constrained config.Networks. We recommend keeping it at 12 or higher.'';
+  };
+
+  nethermind-pruneMemSize = mkOption {
+    type = types.nullOr types.ints.unsigned;
+    default = null;
+    description = mdDoc ''
+      The amount of RAM (in MB) you want to dedicate to Nethermind for its in-memory
+       pruning system. Higher values mean less writes to your SSD and slower overall database growth.'';
+  };
+
+  nethermind-fullPruneMemoryBudget = mkOption {
+    type = types.nullOr types.ints.unsigned;
+    default = null;
+    description = mdDoc ''
+      The amount of RAM (in MB) you want to dedicate to Nethermind for its full 
+      pruning system. Higher values mean less writes to your SSD and faster pruning times.'';
+  };
+
+  nethermind-additionalModules = mkOption {
+    type = types.nullOr (types.listOf types.str);
+    default = null;
+    description = mdDoc ''
+      Additional modules you want to add to the primary JSON-RPC route. 
+      The defaults are Eth,Net,Personal,Web3. You can add any additional ones you 
+      need here'';
+  };
+
+  nethermind-additionalUrls = mkOption {
+    type = types.nullOr (types.listOf types.str);
+    default = null;
+    description = mdDoc ''
+      Additional JSON-RPC URLs you want to run alongside the primary URL.
+      These will be added to the "--JsonRpc.AdditionalRpcUrls" argument.
+      Please consult the Nethermind documentation for more information on this flag, its intended usage, and its expected formatting.
+    '';
+  };
+
+  nethermind-containerTag = mkOption {
+    type = types.nullOr types.str;
+    default = null;
+    description = mdDoc ''The tag name of the Nethermind container you want to use on Docker Hub.'';
+  };
+
+  nethermind-additionalFlags = mkOption {
+    type = types.nullOr (types.listOf types.str);
+    default = null;
+    description = mdDoc ''
+      Additional custom command line flags you want to pass to Nethermind, 
+      to take advantage of other settings that the Smartnode's configuration doesn't cover.'';
+  };
+
+  # Nimbus
+
+  externalNimbus-httpUrl = mkOption {
+    type = types.nullOr types.str;
+    default = null;
+    description = mdDoc ''The URL of the HTTP Beacon API endpoint for your external client.'';
+  };
+
+  externalNimbus-graffiti = mkOption {
+    type = types.nullOr types.str;
+    default = null;
+    description = mdDoc ''Add a short message to any blocks you propose, so the world can see what you have to say!'';
+  };
+
+  externalNimbus-doppelgangerDetection = mkOption {
+    type = types.nullOr types.bool;
+    default = null;
+    description = mdDoc ''
+      enabled, your client will *intentionally* miss 1 or 2 
+      attestations on startup to check if validator keys are already running elsewhere. 
+      If they are, it will disable validation duties for them to prevent you from being slashed.'';
+  };
+
+  externalNimbus-containerTag = mkOption {
+    type = types.nullOr types.str;
+    default = null;
+    description = mdDoc ''
+      The tag name of the Nimbus validator container you want
+      to use from Docker Hub. This will be used for the Validator Client that Rocket Pool manages with your minipool keys.'';
+  };
+
+  externalNimbus-additionalVcFlags = mkOption {
+    type = types.nullOr (types.listOf types.str);
+    default = null;
+    description = mdDoc ''
+      Additional custom command line flags you want to pass Nimbus's Validator Client,
+      to take advantage of other settings that the Smartnode's configuration doesn't cover.'';
+  };
+
+  nimbus-maxPeers = mkOption {
+    type = types.nullOr types.ints.u16;
+    default = null;
+    description = mdDoc ''
+      The maximum number of peers your client should try to 
+      maintain. You can try lowering this if you have a low-resource system or a constrained network.'';
+  };
+
+  nimbus-pruningMode = mkOption {
+    type = types.nullOr (types.enum ["archive" "prune"]);
+    default = null;
+    description = mdDoc ''Choose how Nimbus will prune its database. Highlight each option to learn more about it.'';
+  };
+
+  nimbus-bnContainerTag = mkOption {
+    type = types.nullOr types.str;
+    default = null;
+    description = mdDoc ''The tag name of the Nimbus Beacon Node container you want to use on Docker Hub.'';
+  };
+
+  nimbus-containerTag = mkOption {
+    type = types.nullOr types.str;
+    default = null;
+    description = mdDoc ''The tag name of the Nimbus Validator Client container you want to use on Docker Hub.'';
+  };
+
+  nimbus-additionalBnFlags = mkOption {
+    type = types.nullOr (types.listOf types.str);
+    default = null;
+    description = mdDoc ''
+      Additional custom command line flags you want to pass
+      Nimbus's Beacon Client, to take advantage of other settings that the Smartnode's configuration doesn't cover.'';
+  };
+
+  nimbus-additionalVcFlags = mkOption {
+    type = types.nullOr (types.listOf types.str);
+    default = null;
+    description = mdDoc ''
+      Additional custom command line flags you want to pass Nimbus's Validator Client,
+      to take advantage of other settings that the Smartnode's configuration doesn't cover.'';
+  };
+
+  # MEV-Boost
+
+  enableMevBoost = lib.mkEnableOption (mdDoc ''
+    MEV-Boost, which connects your validator to one or more relays of your choice.
+    The relays act as intermediaries between you and professional block builders
+    that find and extract MEV opportunities. The builders will give you a healthy
+    tip in return, which tends to be worth more than blocks you built on your own.
+  '');
+
+  mevBoost-mode = mkOption {
+    type = types.nullOr (types.enum ["local" "external"]);
+    default = null;
+    description = mdDoc ''
+      Choose whether to let the Smartnode manage your MEV-Boost instance
+      (Locally Managed), or if you manage your own outside of the Smartnode 
+      stack (Externally Managed).'';
+  };
+
+  mevBoost-selectionMode = mkOption {
+    type = types.nullOr (types.enum ["profile" "relay"]);
+    default = null;
+    description = mdDoc ''Select how the TUI shows you the options for which MEV relays to enable.'';
+  };
+
+  mevBoost-enableRegulatedAllMev = lib.mkEnableOption (mdDoc ''
+    To learn more about MEV, please visit https://docs.rocketpool.net/guides/node/mev.html.
+    Select this to enable the relays that comply with government regulations (e.g. OFAC sanctions), 
+    Relays: Flashbots, bloXroute Regulated, Eden Network'');
+
+  mevBoost-enableUnregulatedAllMev = lib.mkEnableOption (mdDoc ''
+    To learn more about MEV, please visit https://docs.rocketpool.net/guides/node/mev.html.
+    Select this to enable the relays that do not follow any sanctions lists (do not censor transactions),
+    Relays: bloXroute Max Profit, Ultra Sound, Aestus
+  '');
+
+  mevBoost-flashbotsEnabled = lib.mkEnableOption (mdDoc ''
+    To learn more about MEV, please visit https://docs.rocketpool.net/guides/node/mev.html.
+    Flashbots is the developer of MEV-Boost, and one of the best-known and most trusted relays in the space.
+    Complies with Regulations: YES'');
+
+  mevBoost-bloxRouteMaxProfitEnabled = lib.mkEnableOption (mdDoc ''
+    To learn more about MEV, please visit https://docs.rocketpool.net/guides/node/mev.html.
+    Select this to enable the "max profit" relay from bloXroute.
+    Complies with Regulations: NO
+  '');
+
+  mevBoost-bloxRouteRegulatedEnabled = lib.mkEnableOption (mdDoc ''
+    To learn more about MEV, please visit https://docs.rocketpool.net/guides/node/mev.html.
+    Select this to enable the "regulated" relay from bloXroute.
+    Complies with Regulations: YES'');
+
+  mevBoost-edenEnabled = lib.mkEnableOption (mdDoc ''    
+    To learn more about MEV, please visit https://docs.rocketpool.net/guides/node/mev.html.
+    Eden Network is the home of Eden Relay, a block building hub focused on optimising block rewards for validators.
+    Complies with Regulations: YES'');
+
+  mevBoost-ultrasoundEnabled = lib.mkEnableOption (mdDoc ''
+    To learn more about MEV, please visit https://docs.rocketpool.net/guides/node/mev.html.
+    The ultra sound relay is a credibly-neutral and permissionless relay — a public good from the ultrasound.money team.
+    Complies with Regulations: NO'');
+
+  mevBoost-aestusEnabled = lib.mkEnableOption (mdDoc ''
+    To learn more about MEV, please visit https://docs.rocketpool.net/guides/node/mev.html.
+    The Aestus MEV-Boost Relay is an independent and non-censoring relay. 
+    It is committed to neutrality and the development of a healthy MEV-Boost ecosystem.
+    Complies with Regulations: NO'');
+
+  mevBoost-port = mkOption {
+    type = types.nullOr types.str;
+    default = null;
+    description = mdDoc ''The port that MEV-Boost should serve its API on.'';
+  };
+
+  mevBoost-openRpcPort = mkOption {
+    type = types.nullOr (types.enum ["closed" "localhost" "external"]);
+    default = null;
+    description = mdDoc ''
+      Expose the API port to other processes on your machine,
+      or to your local network so other local machines can access MEV-Boost's API.
+    '';
+  };
+
+  mevBoost-containerTag = mkOption {
+    type = types.nullOr types.str;
+    default = null;
+    description = mdDoc ''The tag name of the MEV-Boost container you want to use on Docker Hub.'';
+  };
+
+  mevBoost-additionalFlags = mkOption {
+    type = types.nullOr (types.listOf types.str);
+    default = null;
+    description = mdDoc ''
+      Additional custom command line flags you want to pass
+      to MEV-Boost, to take advantage of other settings that the Smartnode's 
+      configuration doesn't cover.'';
+  };
+
+  mevBoost-externalUrl = mkOption {
+    type = types.nullOr types.str;
+    default = null;
+    description = mdDoc ''The URL of the external MEV-Boost client or provider'';
+  };
+}
diff --git a/modules/rocketpool/default.nix b/modules/rocketpool/default.nix
new file mode 100644
index 00000000..091e576b
--- /dev/null
+++ b/modules/rocketpool/default.nix
@@ -0,0 +1,167 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  modulesLib = import ../lib.nix lib;
+
+  inherit (lib.lists) findFirst sublist last;
+  inherit (lib.strings) hasPrefix;
+  inherit (lib.attrsets) zipAttrsWith;
+  inherit
+    (lib)
+    concatStringsSep
+    filterAttrs
+    flatten
+    mapAttrs'
+    mapAttrsToList
+    mkIf
+    mkMerge
+    nameValuePair
+    types
+    ;
+  inherit (modulesLib) mkArgs baseServiceConfig defaultArgReducer;
+
+  eachRocketPool = config.services.ethereum.rocketpool;
+in {
+  ###### interface
+  inherit (import ./options.nix {inherit lib pkgs;}) options;
+
+  ###### implementation
+
+  config = mkIf (eachRocketPool != {}) {
+    systemd.services =
+      mapAttrs'
+      (
+        rocketpool: let
+          serviceName = "rocketpool";
+        in
+          cfg: let
+            geth-additionalFlags =
+              if cfg.args.geth-additionalFlags != null
+              then ''--geth-additionalFlags=${concatStringsSep "," cfg.args.geth-additionalFlags}''
+              else "";
+
+            nethermind-additionalModules =
+              if cfg.args.nethermind-additionalModules != null
+              then ''--nethermind-additionalModules=${concatStringsSep "," cfg.args.nethermind-additionalModules}''
+              else "";
+
+            nethermind-additionalUrls =
+              if cfg.args.nethermind-additionalUrls != null
+              then ''--nethermind-additionalUrls=${concatStringsSep "," cfg.args.nethermind-additionalUrls}''
+              else "";
+
+            nethermind-additionalFlags =
+              if cfg.args.nethermind-additionalFlags != null
+              then ''--nethermind-additionalFlags=${concatStringsSep "," cfg.args.nethermind-additionalFlags}''
+              else "";
+
+            externalNimbus-additionalVcFlags =
+              if cfg.args.externalNimbus-additionalVcFlags != null
+              then ''--externalNimbus-additionalVcFlags=${concatStringsSep "," cfg.args.externalNimbus-additionalVcFlags}''
+              else "";
+
+            nimbus-additionalBnFlags =
+              if cfg.args.nimbus-additionalBnFlags != null
+              then ''--nimbus-additionalBnFlags=${concatStringsSep "," cfg.args.nimbus-additionalBnFlags}''
+              else "";
+
+            nimbus-additionalVcFlags =
+              if cfg.args.nimbus-additionalVcFlags != null
+              then ''--nimbus-additionalVcFlags=${concatStringsSep "," cfg.args.nimbus-additionalVcFlags}''
+              else "";
+
+            mevBoost-additionalFlags =
+              if cfg.args.mevBoost-additionalFlags != null
+              then ''--mevBoost-additionalFlags=${concatStringsSep "," cfg.args.mevBoost-additionalFlags}''
+              else "";
+
+            serviceArgs = let
+              args = let
+                opts = import ./args.nix lib;
+
+                pathReducer = path: let
+                  p =
+                    if (last path == "enable")
+                    then sublist 0 ((builtins.length path) - 1) path
+                    else path;
+                in "--${concatStringsSep "-" p}";
+
+                argFormatter = {
+                  opt,
+                  path,
+                  value,
+                  argReducer ? defaultArgReducer,
+                  pathReducer ? defaultArgReducer,
+                }: let
+                  arg = pathReducer path;
+                in
+                  if (opt.type == types.bool)
+                  then
+                    (
+                      if value
+                      then "${arg}"
+                      else ""
+                    )
+                  else "${arg}=${argReducer value}";
+              in
+                mkArgs {
+                  inherit opts;
+                  inherit (cfg) args;
+                  inherit argFormatter;
+                  inherit pathReducer;
+                };
+              # filter out certain args which need to be treated differently
+              specialArgs = [
+                "--geth-additionalFlags"
+                "--nethermind-additionalModules"
+                "--nethermind-additionalUrls"
+                "--nethermind-additionalFlags"
+                "--externalNimbus-additionalVcFlags"
+                "--nimbus-additionalBnFlags"
+                "--nimbus-additionalVcFlags"
+                "--mevBoost-additionalFlags"
+              ];
+              isNormalArg = name: (findFirst (arg: hasPrefix arg name) null specialArgs) == null;
+              filteredArgs = builtins.filter isNormalArg args;
+            in
+              builtins.concatStringsSep " \\\n" (
+                builtins.filter (x: x != null && x != "") [
+                  geth-additionalFlags
+                  nethermind-additionalModules
+                  nethermind-additionalUrls
+                  nethermind-additionalFlags
+                  externalNimbus-additionalVcFlags
+                  nimbus-additionalBnFlags
+                  nimbus-additionalVcFlags
+                  mevBoost-additionalFlags
+                  (concatStringsSep " \\\n" filteredArgs)
+                  (lib.escapeShellArgs cfg.extraArgs)
+                ]
+              );
+          in
+            nameValuePair serviceName (mkIf cfg.enable {
+              after = ["network.target"];
+              wantedBy = ["multi-user.target"];
+              description = "Rocket Pool service (${rocketpool})";
+
+              # create service config by merging with the base config
+              serviceConfig = mkMerge [
+                baseServiceConfig
+                {
+                  User = serviceName;
+                  StateDirectory = serviceName;
+                  ExecStart = ''${lib.getExe cfg.package} service config ${serviceArgs}'';
+                  MemoryDenyWriteExecute = "false"; # causes a library loading error
+                }
+                # (mkIf (cfg.args.jwt-secret != null) {
+                #   LoadCredential = ["jwt-secret:${cfg.args.jwt-secret}"];
+                # })
+              ];
+            })
+      )
+      eachRocketPool;
+  };
+}
diff --git a/modules/rocketpool/options.nix b/modules/rocketpool/options.nix
new file mode 100644
index 00000000..049f889f
--- /dev/null
+++ b/modules/rocketpool/options.nix
@@ -0,0 +1,46 @@
+{
+  lib,
+  pkgs,
+  ...
+}: let
+  args = import ./args.nix lib;
+  rocketpoolOpts = with lib; {
+    options = {
+      enable = mkEnableOption (mdDoc "Rocket Pool service");
+
+      inherit args;
+
+      extraArgs = mkOption {
+        type = types.listOf types.str;
+        default = [];
+        description = mdDoc "Additional arguments passed to service.";
+      };
+
+      package = mkOption {
+        type = types.package;
+        default = pkgs.rocketpool;
+        defaultText = literalExpression "pkgs.rocketpool";
+        description = mdDoc "Package to use for Rocket Pool";
+      };
+
+      # mixin backup options
+      backup = let
+        inherit (import ../backup/lib.nix lib) options;
+      in
+        options;
+
+      # mixin restore options
+      restore = let
+        inherit (import ../restore/lib.nix lib) options;
+      in
+        options;
+    };
+  };
+in {
+  options.services.ethereum.rocketpool = with lib;
+    mkOption {
+      type = types.attrsOf (types.submodule rocketpoolOpts);
+      default = {};
+      description = mdDoc "Specification of one or more Rocket Pool instances.";
+    };
+}