@settlemint/sdk-cli 2.1.4-pr4cff9a3b → 2.1.4-pr585a70cc

package/dist/cli.js

@@ -245085,7 +245085,7 @@ var DotEnvSchema = z.object({
   SETTLEMINT_APPLICATION: UniqueNameSchema.optional(),
   SETTLEMINT_BLOCKCHAIN_NETWORK: UniqueNameSchema.optional(),
   SETTLEMINT_BLOCKCHAIN_NODE: UniqueNameSchema.optional(),
-  SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER: UniqueNameSchema.optional(),
+  SETTLEMINT_LOAD_BALANCER: UniqueNameSchema.optional(),
   SETTLEMINT_HASURA: UniqueNameSchema.optional(),
   SETTLEMINT_HASURA_ENDPOINT: UrlSchema.optional(),
   SETTLEMINT_HASURA_ADMIN_SECRET: z.string().optional(),
@@ -245278,7 +245278,7 @@ function pruneCurrentEnv(currentEnv, env2) {
 var package_default = {
   name: "@settlemint/sdk-cli",
   description: "Command-line interface for SettleMint SDK, providing development tools and project management capabilities",
-  version: "2.1.4-pr4cff9a3b",
+  version: "2.1.4-pr585a70cc",
   type: "module",
   private: false,
   license: "FSL-1.1-MIT",
@@ -245327,8 +245327,8 @@ var package_default = {
     "@inquirer/input": "4.1.9",
     "@inquirer/password": "4.0.12",
     "@inquirer/select": "4.1.1",
-    "@settlemint/sdk-js": "2.1.4-pr4cff9a3b",
-    "@settlemint/sdk-utils": "2.1.4-pr4cff9a3b",
+    "@settlemint/sdk-js": "2.1.4-pr585a70cc",
+    "@settlemint/sdk-utils": "2.1.4-pr585a70cc",
     "@types/node": "22.14.1",
     "@types/semver": "7.7.0",
     "@types/which": "3.0.4",
@@ -246742,7 +246742,7 @@ var DotEnvSchema2 = z.object({
   SETTLEMINT_APPLICATION: UniqueNameSchema2.optional(),
   SETTLEMINT_BLOCKCHAIN_NETWORK: UniqueNameSchema2.optional(),
   SETTLEMINT_BLOCKCHAIN_NODE: UniqueNameSchema2.optional(),
-  SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER: UniqueNameSchema2.optional(),
+  SETTLEMINT_LOAD_BALANCER: UniqueNameSchema2.optional(),
   SETTLEMINT_HASURA: UniqueNameSchema2.optional(),
   SETTLEMINT_HASURA_ENDPOINT: UrlSchema2.optional(),
   SETTLEMINT_HASURA_ADMIN_SECRET: z.string().optional(),
@@ -248059,47 +248059,6 @@ var getLoadBalancer = graphql(`
       }
     }
   `, [LoadBalancerFragment]);
-var getLoadBalancers = graphql(`
-    query getLoadBalancers($applicationUniqueName: String!) {
-      loadBalancersByUniqueName(applicationUniqueName: $applicationUniqueName) {
-        items {
-          ...LoadBalancer
-        }
-      }
-    }
-  `, [LoadBalancerFragment]);
-var createLoadBalancer = graphql(`
-    mutation createLoadBalancer(
-      $applicationId: ID!
-      $blockchainNetworkId: ID!
-      $name: String!
-      $provider: String!
-      $region: String!
-      $size: ClusterServiceSize
-      $type: ClusterServiceType
-      $connectedNodes: [ID!]!
-    ) {
-      createLoadBalancer(
-        applicationId: $applicationId
-        blockchainNetworkId: $blockchainNetworkId
-        name: $name
-        provider: $provider
-        region: $region
-        size: $size
-        type: $type
-        connectedNodes: $connectedNodes
-      ) {
-        ...LoadBalancer
-      }
-    }
-  `, [LoadBalancerFragment]);
-var restartLoadBalancer = graphql(`
-    mutation RestartLoadBalancer($uniqueName: String!) {
-      restartLoadBalancerByUniqueName(uniqueName: $uniqueName) {
-        ...LoadBalancer
-      }
-    }
-  `, [LoadBalancerFragment]);
 var loadBalancerRead = (gqlClient) => {
   return async (loadBalancerUniqueName) => {
     const { loadBalancerByUniqueName: loadBalancer } = await gqlClient.request(getLoadBalancer, {
@@ -248108,37 +248067,6 @@ var loadBalancerRead = (gqlClient) => {
     return loadBalancer;
   };
 };
-var loadBalancerList = (gqlClient) => {
-  return async (applicationUniqueName) => {
-    const {
-      loadBalancersByUniqueName: { items }
-    } = await gqlClient.request(getLoadBalancers, { applicationUniqueName });
-    return items;
-  };
-};
-var loadBalancerCreate = (gqlClient) => {
-  return async (args) => {
-    const { applicationUniqueName, blockchainNetworkUniqueName, connectedNodesUniqueNames, ...otherArgs } = args;
-    const [application, blockchainNetwork, connectedNodes] = await Promise.all([
-      applicationRead(gqlClient)(applicationUniqueName),
-      blockchainNetworkRead(gqlClient)(blockchainNetworkUniqueName),
-      Promise.all(connectedNodesUniqueNames.map((uniqueName) => blockchainNodeRead(gqlClient)(uniqueName)))
-    ]);
-    const { createLoadBalancer: loadBalancer } = await gqlClient.request(createLoadBalancer, {
-      ...otherArgs,
-      applicationId: application.id,
-      blockchainNetworkId: blockchainNetwork.id,
-      connectedNodes: connectedNodes.map((node) => node.id)
-    });
-    return loadBalancer;
-  };
-};
-var loadBalancerRestart = (gqlClient) => async (loadBalancerUniqueName) => {
-  const { restartLoadBalancerByUniqueName: loadBalancer } = await gqlClient.request(restartLoadBalancer, {
-    uniqueName: loadBalancerUniqueName
-  });
-  return loadBalancer;
-};
 var InsightsFragment = graphql(`
   fragment Insights on Insights {
     __typename
@@ -248839,12 +248767,6 @@ function createSettleMintClient(options) {
       create: blockchainNodeCreate(gqlClient),
       restart: blockchainNodeRestart(gqlClient)
     },
-    loadBalancer: {
-      list: loadBalancerList(gqlClient),
-      read: loadBalancerRead(gqlClient),
-      create: loadBalancerCreate(gqlClient),
-      restart: loadBalancerRestart(gqlClient)
-    },
     middleware: {
       list: middlewareList(gqlClient),
       read: middlewareRead(gqlClient),
@@ -252268,7 +252190,6 @@ async function applicationPrompt(env2, applications, accept) {
 }
 
 // src/prompts/cluster-service/service.prompt.ts
-var ALL2 = "All";
 async function servicePrompt({
   env: env2,
   services,
@@ -252277,13 +252198,12 @@ async function servicePrompt({
   defaultHandler,
   isRequired = false,
   isCi = is_in_ci_default,
-  singleOptionMessage,
-  allowAll = false
+  singleOptionMessage
 }) {
   if (services.length === 0) {
     return;
   }
-  const selectedService = services.find((service) => Array.isArray(service) ? false : service.uniqueName === env2[envKey]);
+  const selectedService = services.find((service) => service.uniqueName === env2[envKey]);
   const autoAccept = isCi || accept;
   if (autoAccept && selectedService) {
     return selectedService;
@@ -252292,7 +252212,7 @@ async function servicePrompt({
     return;
   }
   if (isRequired && services.length === 1) {
-    if (singleOptionMessage && !Array.isArray(services[0])) {
+    if (singleOptionMessage) {
       note(singleOptionMessage(services[0].uniqueName));
     }
     return services[0];
@@ -252301,30 +252221,13 @@ async function servicePrompt({
     name: `${service.name} (${service.uniqueName})`,
     value: service
   }));
-  if (allowAll) {
-    choices.unshift({
-      name: ALL2,
-      value: services
-    });
-  }
   if (!isRequired) {
     choices.push({
       name: "None",
       value: undefined
     });
   }
-  return defaultHandler({
-    defaultService: selectedService,
-    choices
-  });
-}
-
-// src/utils/cluster-service.ts
-function hasValidPrivateKey(privateKey) {
-  return privateKey.privateKeyType !== "HD_ECDSA_P256";
-}
-function isRunning(service) {
-  return service === undefined || service?.status === "COMPLETED";
+  return defaultHandler({ defaultService: selectedService, choices });
 }
 
 // src/prompts/cluster-service/blockchain-node.prompt.ts
@@ -252335,8 +252238,7 @@ async function blockchainNodePrompt({
   singleOptionMessage,
   promptMessage,
   filterRunningOnly = false,
-  isRequired = false,
-  allowAll = false
+  isRequired = false
 }) {
   return servicePrompt({
     env: env2,
@@ -252345,25 +252247,14 @@ async function blockchainNodePrompt({
     envKey: "SETTLEMINT_BLOCKCHAIN_NODE",
     isRequired,
     defaultHandler: async ({ defaultService: defaultNode, choices }) => {
-      const filteredChoices = filterRunningOnly ? choices.filter(({ value: node }) => {
-        return Array.isArray(node) ? true : isRunning(node);
-      }).map((item) => {
-        if (Array.isArray(item.value)) {
-          return {
-            ...item,
-            value: item.value.filter(isRunning)
-          };
-        }
-        return item;
-      }) : choices;
+      const filteredChoices = filterRunningOnly ? choices.filter(({ value: node }) => node === undefined || node?.status === "COMPLETED") : choices;
       return esm_default3({
         message: promptMessage ?? "Which blockchain node do you want to connect to?",
         choices: filteredChoices,
         default: defaultNode
       });
     },
-    singleOptionMessage,
-    allowAll
+    singleOptionMessage
   });
 }
 
@@ -252668,8 +252559,7 @@ async function servicesSpinner(settlemint, applicationUniqueName, types2) {
         storages,
         privateKeys,
         insights,
-        customDeployments,
-        loadBalancers
+        customDeployments
       ] = await Promise.all([
         shouldFetch("blockchain-network") ? settlemint.blockchainNetwork.list(applicationUniqueName) : Promise.resolve([]),
         shouldFetch("blockchain-node") ? settlemint.blockchainNode.list(applicationUniqueName) : Promise.resolve([]),
@@ -252678,8 +252568,7 @@ async function servicesSpinner(settlemint, applicationUniqueName, types2) {
         shouldFetch("storage") ? settlemint.storage.list(applicationUniqueName) : Promise.resolve([]),
         shouldFetch("private-key") ? settlemint.privateKey.list(applicationUniqueName) : Promise.resolve([]),
         shouldFetch("insights") ? settlemint.insights.list(applicationUniqueName) : Promise.resolve([]),
-        shouldFetch("custom-deployment") ? settlemint.customDeployment.list(applicationUniqueName) : Promise.resolve([]),
-        shouldFetch("load-balancer") ? settlemint.loadBalancer.list(applicationUniqueName) : Promise.resolve([])
+        shouldFetch("custom-deployment") ? settlemint.customDeployment.list(applicationUniqueName) : Promise.resolve([])
       ]);
       return {
         blockchainNetworks,
@@ -252689,8 +252578,7 @@ async function servicesSpinner(settlemint, applicationUniqueName, types2) {
         storages,
         privateKeys,
         insights,
-        customDeployments,
-        loadBalancers
+        customDeployments
       };
     }
   });
@@ -252730,7 +252618,7 @@ async function writeEnvSpinner(prod, env2) {
         SETTLEMINT_APPLICATION: env2.SETTLEMINT_APPLICATION,
         SETTLEMINT_BLOCKCHAIN_NETWORK: env2.SETTLEMINT_BLOCKCHAIN_NETWORK,
         SETTLEMINT_BLOCKCHAIN_NODE: env2.SETTLEMINT_BLOCKCHAIN_NODE,
-        SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER: env2.SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER,
+        SETTLEMINT_LOAD_BALANCER: env2.SETTLEMINT_LOAD_BALANCER,
         SETTLEMINT_HASURA: env2.SETTLEMINT_HASURA,
         SETTLEMINT_HASURA_ENDPOINT: env2.SETTLEMINT_HASURA_ENDPOINT,
         SETTLEMINT_THEGRAPH: env2.SETTLEMINT_THEGRAPH,
@@ -252839,35 +252727,6 @@ function getMinioEndpoints(service) {
   };
 }
 
-// src/prompts/cluster-service/blockchain-node-or-load-balancer.prompt.ts
-async function blockchainNodeOrLoadBalancerPrompt({
-  env: env2,
-  nodes,
-  loadBalancers,
-  accept,
-  singleOptionMessage,
-  promptMessage,
-  filterRunningOnly = false,
-  isRequired = false
-}) {
-  return servicePrompt({
-    env: env2,
-    services: [...loadBalancers, ...nodes],
-    accept,
-    envKey: "SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER",
-    isRequired,
-    defaultHandler: async ({ defaultService: defaultNode, choices }) => {
-      const filteredChoices = filterRunningOnly ? choices.filter(({ value: node }) => node === undefined || node?.status === "COMPLETED") : choices;
-      return esm_default3({
-        message: promptMessage ?? "Which blockchain node or load balancer do you want to connect to?",
-        choices: filteredChoices,
-        default: defaultNode
-      });
-    },
-    singleOptionMessage
-  });
-}
-
 // src/commands/connect.ts
 function connectCommand() {
   return new Command("connect").option("--prod", "Connect to your production environment").option("-a, --accept-defaults", "Accept the default and previously set values").option("-i, --instance <instance>", "The instance to connect to (defaults to the instance in the .env file)").description("Connects your project to your application on SettleMint").action(async ({ acceptDefaults, prod, instance }) => {
@@ -252887,30 +252746,11 @@ function connectCommand() {
     const workspace = await workspacePrompt(env2, workspaces, acceptDefaults);
     const application = await applicationPrompt(env2, workspace?.applications ?? [], acceptDefaults);
     const aatToken = await applicationAccessTokenPrompt(env2, application, settlemint, acceptDefaults);
-    const {
-      middlewares,
-      integrationTools,
-      storages,
-      privateKeys,
-      insights,
-      customDeployments,
-      blockchainNodes,
-      loadBalancers
-    } = await servicesSpinner(settlemint, application.uniqueName);
-    const nodesWithPrivateKey = blockchainNodes.filter((node) => node && ("privateKeys" in node) ? Array.isArray(node?.privateKeys) && node?.privateKeys?.length > 0 : false);
+    const { middlewares, integrationTools, storages, privateKeys, insights, customDeployments, blockchainNodes } = await servicesSpinner(settlemint, application.uniqueName);
     const blockchainNode = await blockchainNodePrompt({
       env: env2,
-      nodes: nodesWithPrivateKey,
-      accept: acceptDefaults,
-      promptMessage: "Which blockchain node do you want to use for sending transactions?"
-    });
-    const nodesWithoutPrivateKey = blockchainNodes.filter((node) => node && ("privateKeys" in node) ? !Array.isArray(node?.privateKeys) || node?.privateKeys?.length === 0 : true);
-    const loadBalancerOrBlockchainNode = await blockchainNodeOrLoadBalancerPrompt({
-      env: env2,
-      nodes: nodesWithoutPrivateKey,
-      loadBalancers,
-      accept: acceptDefaults,
-      promptMessage: "Which blockchain node or load balancer do you want to use for read operations?"
+      nodes: blockchainNodes,
+      accept: acceptDefaults
     });
     const hasura = await hasuraPrompt({
       env: env2,
@@ -252976,15 +252816,10 @@ function connectCommand() {
           uniqueName: blockchainNode.blockchainNetwork?.uniqueName
         },
         blockchainNode && {
-          type: "Blockchain Node (with private key, use for sending transactions)",
+          type: "Blockchain Node",
           name: blockchainNode.name,
           uniqueName: blockchainNode.uniqueName
         },
-        loadBalancerOrBlockchainNode && {
-          type: "Blockchain Node or Load Balancer (without private key, use for read operations)",
-          name: loadBalancerOrBlockchainNode.name,
-          uniqueName: loadBalancerOrBlockchainNode.uniqueName
-        },
         hasura && {
           type: "Hasura",
           name: hasura.name,
@@ -253035,7 +252870,6 @@ function connectCommand() {
       SETTLEMINT_APPLICATION: application.uniqueName,
       SETTLEMINT_BLOCKCHAIN_NETWORK: blockchainNode?.blockchainNetwork?.uniqueName,
       SETTLEMINT_BLOCKCHAIN_NODE: blockchainNode?.uniqueName,
-      SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER: loadBalancerOrBlockchainNode?.uniqueName,
       SETTLEMINT_HASURA: hasura?.uniqueName,
       ...getHasuraEndpoints(hasura),
       SETTLEMINT_THEGRAPH: thegraph?.uniqueName,
@@ -256377,8 +256211,7 @@ var SETTLEMINT_CLIENT_MAP = {
   "integration tool": "integrationTool",
   storage: "storage",
   insights: "insights",
-  "application access token": "applicationAccessToken",
-  "load balancer": "loadBalancer"
+  "application access token": "applicationAccessToken"
 };
 var LABELS_MAP = {
   application: { singular: "application", plural: "applications", command: "app" },
@@ -256399,8 +256232,7 @@ var LABELS_MAP = {
     singular: "application access token",
     plural: "application access tokens",
     command: "application-access-token"
-  },
-  "load balancer": { singular: "load balancer", plural: "load balancers", command: "load-balancer" }
+  }
 };
 
 // src/spinners/service.spinner.ts
@@ -257490,14 +257322,12 @@ function blockscoutInsightsCreateCommand() {
             return missingApplication();
           }
           let blockchainNodeUniqueName = loadBalancer ? undefined : blockchainNode ?? env2.SETTLEMINT_BLOCKCHAIN_NODE;
-          const loadBalancerUniqueName = blockchainNodeUniqueName ? undefined : loadBalancer ?? env2.SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER;
+          const loadBalancerUniqueName = blockchainNodeUniqueName ? undefined : loadBalancer ?? env2.SETTLEMINT_LOAD_BALANCER;
           if (!blockchainNodeUniqueName && !loadBalancerUniqueName) {
             const blockchainNodes = await serviceSpinner("blockchain node", () => settlemint.blockchainNode.list(applicationUniqueName));
-            const loadBalancers = await serviceSpinner("load balancer", () => settlemint.loadBalancer.list(applicationUniqueName));
-            const node = await blockchainNodeOrLoadBalancerPrompt({
+            const node = await blockchainNodePrompt({
               env: env2,
               nodes: blockchainNodes,
-              loadBalancers,
               accept: acceptDefaults,
               isRequired: true
             });
@@ -257610,104 +257440,6 @@ function integrationToolCreateCommand() {
   return cmd2;
 }
 
-// src/commands/platform/load-balancer/evm/create.ts
-function loadBalancerEvmCreateCommand() {
-  return getCreateCommand({
-    name: "evm",
-    type: "load balancer",
-    subType: "EVM",
-    alias: "e",
-    execute: (cmd2, baseAction) => {
-      addClusterServiceArgs(cmd2).option("--app, --application <application>", "The application unique name to create the load balancer in (defaults to application from env)").option("--blockchain-nodes <blockchainNodes...>", "Blockchain node unique names where the load balancer connects to (must be from the same network)").action(async (name3, { application, provider, region, size, type: type4, blockchainNodes, acceptDefaults, ...defaultArgs }) => {
-        return baseAction({
-          ...defaultArgs,
-          acceptDefaults,
-          provider,
-          region
-        }, async ({ settlemint, env: env2, showSpinner, provider: provider2, region: region2 }) => {
-          const applicationUniqueName = application ?? env2.SETTLEMINT_APPLICATION;
-          if (!applicationUniqueName) {
-            return missingApplication();
-          }
-          let networkUniqueName;
-          let connectedNodesUniqueNames = blockchainNodes;
-          if (!connectedNodesUniqueNames) {
-            const networks = await serviceSpinner("blockchain network", () => settlemint.blockchainNetwork.list(applicationUniqueName));
-            const network = await blockchainNetworkPrompt({
-              env: env2,
-              networks,
-              accept: acceptDefaults,
-              isRequired: true
-            });
-            if (!network) {
-              return nothingSelectedError("blockchain network");
-            }
-            const blockchainNodes2 = await serviceSpinner("blockchain node", () => settlemint.blockchainNode.list(applicationUniqueName));
-            const connectedNodes = await blockchainNodePrompt({
-              env: env2,
-              nodes: blockchainNodes2.filter((node) => node.blockchainNetwork?.uniqueName === networkUniqueName),
-              accept: acceptDefaults,
-              promptMessage: "Which blockchain node do you want to connect the load balancer to?",
-              allowAll: true
-            });
-            connectedNodesUniqueNames = Array.isArray(connectedNodes) ? blockchainNodes2.map((node) => node.uniqueName) : connectedNodes ? [connectedNodes.uniqueName] : [];
-          }
-          if (!networkUniqueName) {
-            const applicationBlockchainNodes = await serviceSpinner("blockchain node", () => settlemint.blockchainNode.list(applicationUniqueName));
-            const selectedBlockchainNodes = applicationBlockchainNodes.filter((node) => connectedNodesUniqueNames.includes(node.uniqueName));
-            if (selectedBlockchainNodes.length === 0) {
-              return cancel2("blockchain network");
-            }
-            const onTheSameNetwork = selectedBlockchainNodes.every((node) => node.blockchainNetwork?.uniqueName === selectedBlockchainNodes[0].blockchainNetwork?.uniqueName);
-            if (!onTheSameNetwork) {
-              return cancel2("Blockchain nodes must be on the same network");
-            }
-            networkUniqueName = selectedBlockchainNodes[0].blockchainNetwork?.uniqueName;
-          }
-          const result = await showSpinner(() => settlemint.loadBalancer.create({
-            applicationUniqueName,
-            name: name3,
-            blockchainNetworkUniqueName: networkUniqueName,
-            provider: provider2,
-            region: region2,
-            size,
-            type: type4,
-            connectedNodesUniqueNames
-          }));
-          return {
-            result,
-            mapDefaultEnv: () => {
-              return {
-                SETTLEMINT_APPLICATION: applicationUniqueName,
-                SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER: result.uniqueName
-              };
-            }
-          };
-        });
-      });
-    },
-    examples: [
-      {
-        description: "Create an EVM load balancer and save as default",
-        command: "platform create load-balancer evm my-lb --accept-defaults -d"
-      },
-      {
-        description: "Create an EVM load balancer and connect to specific blockchain nodes",
-        command: "platform create load-balancer evm my-lb --blockchain-nodes my-node1 my-node2 --accept-defaults"
-      },
-      {
-        description: "Create an EVM load balancer in a different application",
-        command: "platform create load-balancer evm my-lb --application my-app --accept-defaults"
-      }
-    ]
-  });
-}
-
-// src/commands/platform/load-balancer/create.ts
-function loadBalancerCreateCommand() {
-  return new Command("load-balancer").alias("lb").description("Create a load balancer in the SettleMint platform").addCommand(loadBalancerEvmCreateCommand());
-}
-
 // src/commands/platform/middleware/graph/create.ts
 function graphMiddlewareCreateCommand() {
   return getCreateCommand({
@@ -257716,7 +257448,7 @@ function graphMiddlewareCreateCommand() {
     subType: "The Graph",
     alias: "gr",
     execute: (cmd2, baseAction) => {
-      addClusterServiceArgs(cmd2).option("--application <application>", "Application unique name").option("--blockchain-node <blockchainNode>", "Blockchain Node unique name (mutually exclusive with load-balancer)").option("--load-balancer <loadBalancer>", "Load Balancer unique name (mutually exclusive with blockchain-node)").action(async (name3, { application, blockchainNode, loadBalancer, provider, region, size, type: type4, acceptDefaults, ...defaultArgs }) => {
+      addClusterServiceArgs(cmd2).option("--application <application>", "Application unique name").option("--blockchain-node <blockchainNode>", "Blockchain Node unique name").action(async (name3, { application, blockchainNode, provider, region, size, type: type4, acceptDefaults, ...defaultArgs }) => {
         return baseAction({
           ...defaultArgs,
           acceptDefaults,
@@ -257728,32 +257460,24 @@ function graphMiddlewareCreateCommand() {
             return missingApplication();
           }
           let blockchainNodeUniqueName = blockchainNode;
-          let loadBalancerUniqueName = loadBalancer;
-          if (!blockchainNodeUniqueName && !loadBalancerUniqueName) {
+          if (!blockchainNodeUniqueName) {
             const blockchainNodes = await serviceSpinner("blockchain node", () => settlemint.blockchainNode.list(applicationUniqueName));
-            const loadBalancers = await serviceSpinner("load balancer", () => settlemint.loadBalancer.list(applicationUniqueName));
-            const nodeOrLoadbalancer = await blockchainNodeOrLoadBalancerPrompt({
+            const node = await blockchainNodePrompt({
               env: env2,
               nodes: blockchainNodes,
-              loadBalancers,
               accept: acceptDefaults,
               isRequired: true
             });
-            if (!nodeOrLoadbalancer) {
-              return nothingSelectedError("blockchain node or load balancer");
-            }
-            if (nodeOrLoadbalancer.__typename?.endsWith("LoadBalancer")) {
-              loadBalancerUniqueName = nodeOrLoadbalancer.uniqueName;
-            } else {
-              blockchainNodeUniqueName = nodeOrLoadbalancer.uniqueName;
+            if (!node) {
+              return nothingSelectedError("blockchain node");
             }
+            blockchainNodeUniqueName = node.uniqueName;
           }
           const result = await showSpinner(() => settlemint.middleware.create({
             name: name3,
             applicationUniqueName,
             interface: "HA_GRAPH",
             blockchainNodeUniqueName,
-            loadBalancerUniqueName,
             provider: provider2,
             region: region2,
             size,
@@ -257819,25 +257543,19 @@ function smartContractPortalMiddlewareCreateCommand() {
             return missingApplication();
           }
           let blockchainNodeUniqueName = loadBalancer ? undefined : blockchainNode ?? env2.SETTLEMINT_BLOCKCHAIN_NODE;
-          let loadBalancerUniqueName = blockchainNodeUniqueName ? undefined : loadBalancer ?? env2.SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER;
+          const loadBalancerUniqueName = blockchainNodeUniqueName ? undefined : loadBalancer ?? env2.SETTLEMINT_LOAD_BALANCER;
           if (!blockchainNodeUniqueName && !loadBalancerUniqueName) {
             const blockchainNodes = await serviceSpinner("blockchain node", () => settlemint.blockchainNode.list(applicationUniqueName));
-            const loadBalancers = await serviceSpinner("load balancer", () => settlemint.loadBalancer.list(applicationUniqueName));
-            const nodeOrLoadbalancer = await blockchainNodeOrLoadBalancerPrompt({
+            const node = await blockchainNodePrompt({
               env: env2,
               nodes: blockchainNodes,
-              loadBalancers,
               accept: acceptDefaults,
               isRequired: true
             });
-            if (!nodeOrLoadbalancer) {
-              return nothingSelectedError("blockchain node or load balancer");
-            }
-            if (nodeOrLoadbalancer.__typename?.endsWith("LoadBalancer")) {
-              loadBalancerUniqueName = nodeOrLoadbalancer.uniqueName;
-            } else {
-              blockchainNodeUniqueName = nodeOrLoadbalancer.uniqueName;
+            if (!node) {
+              return nothingSelectedError("blockchain node");
             }
+            blockchainNodeUniqueName = node.uniqueName;
           }
           const parsedAbis = [];
           if (abis && abis.length > 0) {
@@ -258208,7 +257926,7 @@ function storageCreateCommand() {
 
 // src/commands/platform/create.ts
 function createCommand3() {
-  return new Command("create").alias("c").description("Create a resource in the SettleMint platform").addCommand(workspaceCreateCommand()).addCommand(applicationCreateCommand()).addCommand(blockchainNetworkCreateCommand()).addCommand(blockchainNodeCreateCommand()).addCommand(privateKeyCreateCommand()).addCommand(middlewareCreateCommand()).addCommand(storageCreateCommand()).addCommand(integrationToolCreateCommand()).addCommand(insightsCreateCommand()).addCommand(applicationAccessTokenCreateCommand()).addCommand(loadBalancerCreateCommand());
+  return new Command("create").alias("c").description("Create a resource in the SettleMint platform").addCommand(workspaceCreateCommand()).addCommand(applicationCreateCommand()).addCommand(blockchainNetworkCreateCommand()).addCommand(blockchainNodeCreateCommand()).addCommand(privateKeyCreateCommand()).addCommand(middlewareCreateCommand()).addCommand(storageCreateCommand()).addCommand(integrationToolCreateCommand()).addCommand(insightsCreateCommand()).addCommand(applicationAccessTokenCreateCommand());
 }
 
 // src/prompts/delete-confirmation.prompt.ts
@@ -258448,19 +258166,6 @@ function integrationToolRestartCommand() {
   return new Command("integration-tool").alias("it").description("Restart an integration tool service in the SettleMint platform").addCommand(hasuraRestartCommand());
 }
 
-// src/commands/platform/load-balancer/restart.ts
-function loadBalancerRestartCommand() {
-  return getRestartCommand({
-    name: "load-balancer",
-    type: "load balancer",
-    alias: "lb",
-    envKey: "SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER",
-    restartFunction: async (settlemint, id) => {
-      return settlemint.loadBalancer.restart(id);
-    }
-  });
-}
-
 // src/commands/platform/middleware/graph/restart.ts
 function graphRestartCommand() {
   return getRestartCommand({
@@ -258527,7 +258232,7 @@ function storageRestartCommand() {
 
 // src/commands/platform/restart.ts
 function restartCommand() {
-  const cmd2 = new Command("restart").description("Restart a resource in the SettleMint platform").addCommand(blockchainNetworkRestartCommand()).addCommand(customDeploymentRestartCommand()).addCommand(insightsRestartCommand()).addCommand(integrationToolRestartCommand()).addCommand(middlewareRestartCommand()).addCommand(storageRestartCommand()).addCommand(loadBalancerRestartCommand());
+  const cmd2 = new Command("restart").description("Restart a resource in the SettleMint platform").addCommand(blockchainNetworkRestartCommand()).addCommand(customDeploymentRestartCommand()).addCommand(insightsRestartCommand()).addCommand(integrationToolRestartCommand()).addCommand(middlewareRestartCommand()).addCommand(storageRestartCommand());
   return cmd2;
 }
 
@@ -259370,6 +259075,38 @@ function getStatusAction(status) {
   return "Please try again later.";
 }
 
+// src/prompts/smart-contract-set/address.prompt.ts
+async function addressPrompt({
+  env: env2,
+  accept,
+  prod,
+  node,
+  hardhatConfig
+}) {
+  const possiblePrivateKeys = node.privateKeys?.filter((privateKey) => validPrivateKey(privateKey)) ?? [];
+  const defaultAddress = hardhatConfig.networks?.btp?.from ?? possiblePrivateKeys[0]?.address;
+  const defaultPossible = accept && defaultAddress;
+  if (defaultPossible) {
+    if (possiblePrivateKeys.some((privateKey) => privateKey.address?.toLowerCase() === defaultAddress?.toLowerCase())) {
+      return defaultAddress;
+    }
+    note(`Private key with address '${defaultAddress}' is not activated on the node '${node.uniqueName}'.
+Please select another key or activate this key on the node and try again.`, "warn");
+  }
+  const address = await esm_default3({
+    message: "Which private key do you want to deploy from?",
+    choices: possiblePrivateKeys.map(({ address: address2, name: name3 }) => ({
+      name: name3,
+      value: address2
+    })),
+    default: defaultAddress ?? possiblePrivateKeys[0]?.address
+  });
+  return address;
+}
+function validPrivateKey(privateKey) {
+  return privateKey.privateKeyType !== "HD_ECDSA_P256";
+}
+
 // src/commands/smart-contract-set/hardhat/utils/select-target-node.ts
 async function selectTargetNode({
   env: env2,
@@ -259393,7 +259130,6 @@ async function selectTargetNode({
       nodes: validNodes,
       accept: autoAccept,
       isRequired: true,
-      filterRunningOnly: true,
       promptMessage: "Which blockchain node do you want to connect to? (Only nodes with private keys activated are shown)",
       singleOptionMessage: (node2) => `Using '${node2}' - the only node with active private keys. To use a different node, ensure it has a private key activated.`
     });
@@ -259415,7 +259151,7 @@ function validateNode(node, cancelOnError = true) {
     }
     return false;
   }
-  if (node.privateKeys?.filter(hasValidPrivateKey).length === 0) {
+  if (node.privateKeys?.filter((privateKey) => validPrivateKey(privateKey)).length === 0) {
     if (cancelOnError) {
       cancel2(`The specified blockchain node '${node.uniqueName}' does not have an ECDSA P256 or HSM ECDSA P256 private key activated. Please activate an ECDSA P256 or HSM ECDSA P256 private key on your node and try again.`);
     }
@@ -259430,33 +259166,6 @@ function validateNode(node, cancelOnError = true) {
   return true;
 }
 
-// src/prompts/smart-contract-set/address.prompt.ts
-async function addressPrompt({
-  accept,
-  node,
-  hardhatConfig
-}) {
-  const possiblePrivateKeys = node.privateKeys?.filter(hasValidPrivateKey) ?? [];
-  const defaultAddress = hardhatConfig.networks?.btp?.from ?? possiblePrivateKeys[0]?.address;
-  const defaultPossible = accept && defaultAddress;
-  if (defaultPossible) {
-    if (possiblePrivateKeys.some((privateKey) => privateKey.address?.toLowerCase() === defaultAddress?.toLowerCase())) {
-      return defaultAddress;
-    }
-    note(`Private key with address '${defaultAddress}' is not activated on the node '${node.uniqueName}'.
-Please select another key or activate this key on the node and try again.`, "warn");
-  }
-  const address = await esm_default3({
-    message: "Which private key do you want to deploy from?",
-    choices: possiblePrivateKeys.map(({ address: address2, name: name3 }) => ({
-      name: name3,
-      value: address2
-    })),
-    default: defaultAddress
-  });
-  return address;
-}
-
 // src/utils/smart-contract-set/hardhat-config.ts
 async function getHardhatConfigData(envConfig) {
   try {
@@ -259546,7 +259255,7 @@ function hardhatDeployRemoteCommand() {
     }
     let address = defaultSender ?? null;
     if (!defaultSender) {
-      address = await addressPrompt({ accept: autoAccept, node, hardhatConfig });
+      address = await addressPrompt({ env: env2, accept: autoAccept, prod, node, hardhatConfig });
     }
     if (!address) {
       return nothingSelectedError("private key");
@@ -260192,4 +259901,4 @@ async function sdkCliCommand(argv = process.argv) {
 // src/cli.ts
 sdkCliCommand();
 
-//# debugId=33076A9097BEE00964756E2164756E21
+//# debugId=DEE98450FE7ED53964756E2164756E21