@settlemint/sdk-cli 2.1.4-pr3b65e859 → 2.1.4-pr4492e2b4

package/dist/cli.js

@@ -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-pr3b65e859",
+  version: "2.1.4-pr4492e2b4",
   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-pr3b65e859",
-    "@settlemint/sdk-utils": "2.1.4-pr3b65e859",
+    "@settlemint/sdk-js": "2.1.4-pr4492e2b4",
+    "@settlemint/sdk-utils": "2.1.4-pr4492e2b4",
     "@types/node": "22.14.1",
     "@types/semver": "7.7.0",
     "@types/which": "3.0.4",
@@ -248068,6 +248068,38 @@ var getLoadBalancers = graphql(`
       }
     }
   `, [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, {
@@ -248084,6 +248116,29 @@ var loadBalancerList = (gqlClient) => {
     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
@@ -248786,7 +248841,9 @@ function createSettleMintClient(options) {
     },
     loadBalancer: {
       list: loadBalancerList(gqlClient),
-      read: loadBalancerRead(gqlClient)
+      read: loadBalancerRead(gqlClient),
+      create: loadBalancerCreate(gqlClient),
+      restart: loadBalancerRestart(gqlClient)
     },
     middleware: {
       list: middlewareList(gqlClient),
@@ -251719,6 +251776,7 @@ async function codegenBlockscout(env2) {
           __schema {
             queryType { name }
             mutationType { name }
+            subscriptionType { name }
             types {
               ...FullType
             }
@@ -251800,10 +251858,6 @@ async function codegenBlockscout(env2) {
                         ofType {
                           kind
                           name
-                          ofType {
-                            kind
-                            name
-                          }
                         }
                       }
                     }
@@ -252211,6 +252265,7 @@ async function applicationPrompt(env2, applications, accept) {
 }
 
 // src/prompts/cluster-service/service.prompt.ts
+var ALL2 = "All";
 async function servicePrompt({
   env: env2,
   services,
@@ -252219,13 +252274,17 @@ async function servicePrompt({
   defaultHandler,
   isRequired = false,
   isCi = is_in_ci_default,
-  singleOptionMessage
+  singleOptionMessage,
+  allowAll = false
 }) {
   if (services.length === 0) {
     return;
   }
-  const selectedService = services.find((service) => service.uniqueName === env2[envKey]);
+  const selectedService = services.find((service) => Array.isArray(service) ? false : service.uniqueName === env2[envKey]);
   const autoAccept = isCi || accept;
+  if (autoAccept && allowAll) {
+    return services;
+  }
   if (autoAccept && selectedService) {
     return selectedService;
   }
@@ -252233,7 +252292,7 @@ async function servicePrompt({
     return;
   }
   if (isRequired && services.length === 1) {
-    if (singleOptionMessage) {
+    if (singleOptionMessage && !Array.isArray(services[0])) {
       note(singleOptionMessage(services[0].uniqueName));
     }
     return services[0];
@@ -252242,13 +252301,33 @@ 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 });
+  return defaultHandler({
+    defaultService: selectedService,
+    choices
+  });
+}
+
+// src/utils/cluster-service.ts
+function isValidPrivateKey(privateKey) {
+  return privateKey.privateKeyType !== "HD_ECDSA_P256";
+}
+function hasValidPrivateKey(service) {
+  return (service.privateKeys ?? []).some(isValidPrivateKey);
+}
+function isRunning(service) {
+  return service === undefined || service?.status === "COMPLETED";
 }
 
 // src/prompts/cluster-service/blockchain-node.prompt.ts
@@ -252259,7 +252338,8 @@ async function blockchainNodePrompt({
   singleOptionMessage,
   promptMessage,
   filterRunningOnly = false,
-  isRequired = false
+  isRequired = false,
+  allowAll = false
 }) {
   return servicePrompt({
     env: env2,
@@ -252268,14 +252348,25 @@ async function blockchainNodePrompt({
     envKey: "SETTLEMINT_BLOCKCHAIN_NODE",
     isRequired,
     defaultHandler: async ({ defaultService: defaultNode, choices }) => {
-      const filteredChoices = filterRunningOnly ? choices.filter(({ value: node }) => node === undefined || node?.status === "COMPLETED") : 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;
       return esm_default3({
         message: promptMessage ?? "Which blockchain node do you want to connect to?",
         choices: filteredChoices,
         default: defaultNode
       });
     },
-    singleOptionMessage
+    singleOptionMessage,
+    allowAll
   });
 }
 
@@ -252764,7 +252855,7 @@ async function blockchainNodeOrLoadBalancerPrompt({
 }) {
   return servicePrompt({
     env: env2,
-    services: [...nodes, ...loadBalancers],
+    services: [...loadBalancers, ...nodes],
     accept,
     envKey: "SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER",
     isRequired,
@@ -252809,19 +252900,20 @@ function connectCommand() {
       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 blockchainNode = await blockchainNodePrompt({
       env: env2,
-      nodes: blockchainNodes,
+      nodes: nodesWithPrivateKey,
       accept: acceptDefaults,
-      promptMessage: "Which blockchain node do you want to SEND unsigned transactions from?"
+      promptMessage: "Which blockchain node do you want to use for sending transactions?"
     });
-    const nodesWithNoSigning = blockchainNodes.filter((node) => node && ("privateKeys" in node) ? !Array.isArray(node?.privateKeys) || node?.privateKeys?.length === 0 : true);
+    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: nodesWithNoSigning,
+      nodes: nodesWithoutPrivateKey,
       loadBalancers,
       accept: acceptDefaults,
-      promptMessage: "Which blockchain node or load balancer do you want to READ/WRITE from/to? Transactions should be signed before sending to this node or load balancer"
+      promptMessage: "Which load balancer or blockchain node do you want to use for read operations?"
     });
     const hasura = await hasuraPrompt({
       env: env2,
@@ -252887,12 +252979,12 @@ function connectCommand() {
           uniqueName: blockchainNode.blockchainNetwork?.uniqueName
         },
         blockchainNode && {
-          type: "Blockchain Node",
+          type: "Blockchain Node (use for sending transactions)",
           name: blockchainNode.name,
           uniqueName: blockchainNode.uniqueName
         },
         loadBalancerOrBlockchainNode && {
-          type: "Blockchain Node or Load Balancer (signed transactions only)",
+          type: "Load Balancer or Blockchain Node (use for read operations)",
           name: loadBalancerOrBlockchainNode.name,
           uniqueName: loadBalancerOrBlockchainNode.uniqueName
         },
@@ -256813,7 +256905,10 @@ function getCreateCommand({
   usePersonalAccessToken = true,
   requiresDeployment = true
 }) {
-  const cmd2 = new Command(sanitizeCommandName(name3)).alias(alias).description(`Create a new ${subType ? `${subType} ${type4}` : type4} in the SettleMint platform.`).usage(createExamples(examples)).argument("<name>", `The ${subType ? `${subType} ${type4}` : type4} name`).option("-a, --accept-defaults", "Accept the default values").option("-d, --default", `Save as default ${type4}`).option("--prod", "Connect to production environment");
+  const cmd2 = new Command(sanitizeCommandName(name3)).description(`Create a new ${subType ? `${subType} ${type4}` : type4} in the SettleMint platform.`).usage(createExamples(examples)).argument("<name>", `The ${subType ? `${subType} ${type4}` : type4} name`).option("-a, --accept-defaults", "Accept the default values").option("-d, --default", `Save as default ${type4}`).option("--prod", "Connect to production environment");
+  if (alias) {
+    cmd2.alias(alias);
+  }
   if (requiresDeployment) {
     cmd2.option("-w, --wait", "Wait until deployed").option("-r, --restart-if-timeout", "Restart if wait time is exceeded");
   }
@@ -257521,6 +257616,107 @@ function integrationToolCreateCommand() {
   return cmd2;
 }
 
+// src/commands/platform/load-balancer/evm/create.ts
+function loadBalancerEvmCreateCommand() {
+  return getCreateCommand({
+    name: "evm",
+    type: "load balancer",
+    subType: "EVM",
+    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");
+            }
+            networkUniqueName = network.uniqueName;
+            const blockchainNodes2 = await serviceSpinner("blockchain node", () => settlemint.blockchainNode.list(applicationUniqueName));
+            const connectedNodes = await blockchainNodePrompt({
+              env: env2,
+              nodes: blockchainNodes2.filter((node) => node.blockchainNetwork?.uniqueName === network.uniqueName),
+              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 (connectedNodesUniqueNames.length === 0) {
+            return cancel2("A load balancer must connect to at least one blockchain node");
+          }
+          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 node(s) '${connectedNodesUniqueNames.join(", ")}' are not part of the application '${applicationUniqueName}'`);
+            }
+            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-network my-network --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({
@@ -257632,25 +257828,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_BLOCKCHAIN_NODE_OR_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,
+              nodes: blockchainNodes.filter(hasValidPrivateKey),
               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) {
@@ -258021,7 +258211,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());
+  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());
 }
 
 // src/prompts/delete-confirmation.prompt.ts
@@ -258261,6 +258451,19 @@ 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({
@@ -258327,7 +258530,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());
+  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());
   return cmd2;
 }
 
@@ -259170,11 +259373,6 @@ function getStatusAction(status) {
   return "Please try again later.";
 }
 
-// src/utils/blockchain-node.ts
-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,
@@ -259220,7 +259418,7 @@ function validateNode(node, cancelOnError = true) {
     }
     return false;
   }
-  if (node.privateKeys?.filter((privateKey) => validPrivateKey(privateKey)).length === 0) {
+  if (!hasValidPrivateKey(node)) {
     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.`);
     }
@@ -259241,7 +259439,7 @@ async function addressPrompt({
   node,
   hardhatConfig
 }) {
-  const possiblePrivateKeys = node.privateKeys?.filter((privateKey) => validPrivateKey(privateKey)) ?? [];
+  const possiblePrivateKeys = node.privateKeys?.filter(isValidPrivateKey) ?? [];
   const defaultAddress = hardhatConfig.networks?.btp?.from ?? possiblePrivateKeys[0]?.address;
   const defaultPossible = accept && defaultAddress;
   if (defaultPossible) {
@@ -259997,4 +260195,4 @@ async function sdkCliCommand(argv = process.argv) {
 // src/cli.ts
 sdkCliCommand();
 
-//# debugId=5250BB52C7AD397564756E2164756E21
+//# debugId=E9D8627ECFBED53C64756E2164756E21