@settlemint/sdk-mcp 2.1.4-pr05b60a44 → 2.1.4-pr09bd8ab0

package/dist/mcp.js

@@ -28357,23 +28357,51 @@ var require_decrypt = __commonJS((exports, module) => {
   module.exports = decrypt;
 });
 
-// ../../node_modules/@noble/ciphers/_assert.js
-var require__assert = __commonJS((exports) => {
+// ../../node_modules/@noble/ciphers/utils.js
+var require_utils6 = __commonJS((exports) => {
+  /*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */
   Object.defineProperty(exports, "__esModule", { value: true });
+  exports.wrapCipher = exports.Hash = exports.nextTick = exports.isLE = undefined;
+  exports.isBytes = isBytes;
   exports.abool = abool;
+  exports.anumber = anumber;
   exports.abytes = abytes;
-  exports.aexists = aexists;
   exports.ahash = ahash;
-  exports.anumber = anumber;
+  exports.aexists = aexists;
   exports.aoutput = aoutput;
-  exports.isBytes = isBytes;
+  exports.u8 = u8;
+  exports.u32 = u32;
+  exports.clean = clean;
+  exports.createView = createView;
+  exports.bytesToHex = bytesToHex;
+  exports.hexToBytes = hexToBytes;
+  exports.hexToNumber = hexToNumber;
+  exports.bytesToNumberBE = bytesToNumberBE;
+  exports.numberToBytesBE = numberToBytesBE;
+  exports.utf8ToBytes = utf8ToBytes;
+  exports.bytesToUtf8 = bytesToUtf8;
+  exports.toBytes = toBytes;
+  exports.overlapBytes = overlapBytes;
+  exports.complexOverlapBytes = complexOverlapBytes;
+  exports.concatBytes = concatBytes;
+  exports.checkOpts = checkOpts;
+  exports.equalBytes = equalBytes;
+  exports.getOutput = getOutput;
+  exports.setBigUint64 = setBigUint64;
+  exports.u64Lengths = u64Lengths;
+  exports.isAligned32 = isAligned32;
+  exports.copyBytes = copyBytes;
+  function isBytes(a) {
+    return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+  }
+  function abool(b) {
+    if (typeof b !== "boolean")
+      throw new Error(`boolean expected, not ${b}`);
+  }
   function anumber(n) {
     if (!Number.isSafeInteger(n) || n < 0)
       throw new Error("positive integer expected, got " + n);
   }
-  function isBytes(a) {
-    return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
-  }
   function abytes(b, ...lengths) {
     if (!isBytes(b))
       throw new Error("Uint8Array expected");
@@ -28382,7 +28410,7 @@ var require__assert = __commonJS((exports) => {
   }
   function ahash(h) {
     if (typeof h !== "function" || typeof h.create !== "function")
-      throw new Error("Hash should be wrapped by utils.wrapConstructor");
+      throw new Error("Hash should be wrapped by utils.createHasher");
     anumber(h.outputLen);
     anumber(h.blockLen);
   }
@@ -28399,49 +28427,27 @@ var require__assert = __commonJS((exports) => {
       throw new Error("digestInto() expects output buffer of length at least " + min);
     }
   }
-  function abool(b) {
-    if (typeof b !== "boolean")
-      throw new Error(`boolean expected, not ${b}`);
+  function u8(arr) {
+    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
   }
-});
-
-// ../../node_modules/@noble/ciphers/utils.js
-var require_utils6 = __commonJS((exports) => {
-  Object.defineProperty(exports, "__esModule", { value: true });
-  exports.wrapCipher = exports.Hash = exports.nextTick = exports.isLE = exports.createView = exports.u32 = exports.u8 = undefined;
-  exports.bytesToHex = bytesToHex;
-  exports.hexToBytes = hexToBytes;
-  exports.hexToNumber = hexToNumber;
-  exports.bytesToNumberBE = bytesToNumberBE;
-  exports.numberToBytesBE = numberToBytesBE;
-  exports.utf8ToBytes = utf8ToBytes;
-  exports.bytesToUtf8 = bytesToUtf8;
-  exports.toBytes = toBytes;
-  exports.overlapBytes = overlapBytes;
-  exports.complexOverlapBytes = complexOverlapBytes;
-  exports.concatBytes = concatBytes;
-  exports.checkOpts = checkOpts;
-  exports.equalBytes = equalBytes;
-  exports.getOutput = getOutput;
-  exports.setBigUint64 = setBigUint64;
-  exports.u64Lengths = u64Lengths;
-  exports.isAligned32 = isAligned32;
-  exports.copyBytes = copyBytes;
-  exports.clean = clean;
-  /*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */
-  var _assert_js_1 = require__assert();
-  var u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
-  exports.u8 = u8;
-  var u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
-  exports.u32 = u32;
-  var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-  exports.createView = createView;
-  exports.isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
-  if (!exports.isLE)
-    throw new Error("Non little-endian hardware is not supported");
+  function u32(arr) {
+    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+  }
+  function clean(...arrays) {
+    for (let i = 0;i < arrays.length; i++) {
+      arrays[i].fill(0);
+    }
+  }
+  function createView(arr) {
+    return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+  }
+  exports.isLE = (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+  var hasHexBuiltin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
   var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
   function bytesToHex(bytes) {
-    (0, _assert_js_1.abytes)(bytes);
+    abytes(bytes);
+    if (hasHexBuiltin)
+      return bytes.toHex();
     let hex = "";
     for (let i = 0;i < bytes.length; i++) {
       hex += hexes[bytes[i]];
@@ -28461,6 +28467,8 @@ var require_utils6 = __commonJS((exports) => {
   function hexToBytes(hex) {
     if (typeof hex !== "string")
       throw new Error("hex string expected, got " + typeof hex);
+    if (hasHexBuiltin)
+      return Uint8Array.fromHex(hex);
     const hl = hex.length;
     const al = hl / 2;
     if (hl % 2)
@@ -28501,7 +28509,7 @@ var require_utils6 = __commonJS((exports) => {
   function toBytes(data) {
     if (typeof data === "string")
       data = utf8ToBytes(data);
-    else if ((0, _assert_js_1.isBytes)(data))
+    else if (isBytes(data))
       data = copyBytes(data);
     else
       throw new Error("Uint8Array expected, got " + typeof data);
@@ -28518,7 +28526,7 @@ var require_utils6 = __commonJS((exports) => {
     let sum = 0;
     for (let i = 0;i < arrays.length; i++) {
       const a = arrays[i];
-      (0, _assert_js_1.abytes)(a);
+      abytes(a);
       sum += a.length;
     }
     const res = new Uint8Array(sum);
@@ -28549,26 +28557,28 @@ var require_utils6 = __commonJS((exports) => {
   exports.Hash = Hash;
   var wrapCipher = (params, constructor) => {
     function wrappedCipher(key, ...args) {
-      (0, _assert_js_1.abytes)(key);
+      abytes(key);
+      if (!exports.isLE)
+        throw new Error("Non little-endian hardware is not yet supported");
       if (params.nonceLength !== undefined) {
         const nonce = args[0];
         if (!nonce)
           throw new Error("nonce / iv required");
         if (params.varSizeNonce)
-          (0, _assert_js_1.abytes)(nonce);
+          abytes(nonce);
         else
-          (0, _assert_js_1.abytes)(nonce, params.nonceLength);
+          abytes(nonce, params.nonceLength);
       }
       const tagl = params.tagLength;
       if (tagl && args[1] !== undefined) {
-        (0, _assert_js_1.abytes)(args[1]);
+        abytes(args[1]);
       }
       const cipher = constructor(key, ...args);
       const checkOutput = (fnLength, output) => {
         if (output !== undefined) {
           if (fnLength !== 2)
             throw new Error("cipher output not supported");
-          (0, _assert_js_1.abytes)(output);
+          abytes(output);
         }
       };
       let called = false;
@@ -28577,12 +28587,12 @@ var require_utils6 = __commonJS((exports) => {
           if (called)
             throw new Error("cannot encrypt() twice with same key + nonce");
           called = true;
-          (0, _assert_js_1.abytes)(data);
+          abytes(data);
           checkOutput(cipher.encrypt.length, output);
           return cipher.encrypt(data, output);
         },
         decrypt(data, output) {
-          (0, _assert_js_1.abytes)(data);
+          abytes(data);
           if (tagl && data.length < tagl)
             throw new Error("invalid ciphertext length: smaller than tagLength=" + tagl);
           checkOutput(cipher.decrypt.length, output);
@@ -28616,11 +28626,12 @@ var require_utils6 = __commonJS((exports) => {
     view.setUint32(byteOffset + h, wh, isLE);
     view.setUint32(byteOffset + l, wl, isLE);
   }
-  function u64Lengths(ciphertext, AAD) {
+  function u64Lengths(dataLength, aadLength, isLE) {
+    abool(isLE);
     const num = new Uint8Array(16);
-    const view = (0, exports.createView)(num);
-    setBigUint64(view, 0, BigInt(AAD ? AAD.length : 0), true);
-    setBigUint64(view, 8, BigInt(ciphertext.length), true);
+    const view = createView(num);
+    setBigUint64(view, 0, BigInt(aadLength), isLE);
+    setBigUint64(view, 8, BigInt(dataLength), isLE);
     return num;
   }
   function isAligned32(bytes) {
@@ -28629,11 +28640,6 @@ var require_utils6 = __commonJS((exports) => {
   function copyBytes(bytes) {
     return Uint8Array.from(bytes);
   }
-  function clean(...arrays) {
-    for (let i = 0;i < arrays.length; i++) {
-      arrays[i].fill(0);
-    }
-  }
 });
 
 // ../../node_modules/eciesjs/dist/consts.js
@@ -28716,14 +28722,13 @@ var require_webcrypto = __commonJS((exports) => {
   exports.getWebcryptoSubtle = getWebcryptoSubtle;
   exports.managedNonce = managedNonce;
   var crypto_1 = require_cryptoNode();
-  var _assert_js_1 = require__assert();
-  var utils_js_1 = require_utils6();
+  var utils_ts_1 = require_utils6();
   function randomBytes(bytesLength = 32) {
     if (crypto_1.crypto && typeof crypto_1.crypto.getRandomValues === "function") {
       return crypto_1.crypto.getRandomValues(new Uint8Array(bytesLength));
     }
     if (crypto_1.crypto && typeof crypto_1.crypto.randomBytes === "function") {
-      return crypto_1.crypto.randomBytes(bytesLength);
+      return Uint8Array.from(crypto_1.crypto.randomBytes(bytesLength));
     }
     throw new Error("crypto.getRandomValues must be defined");
   }
@@ -28734,12 +28739,12 @@ var require_webcrypto = __commonJS((exports) => {
   }
   function managedNonce(fn) {
     const { nonceLength } = fn;
-    (0, _assert_js_1.anumber)(nonceLength);
+    (0, utils_ts_1.anumber)(nonceLength);
     return (key, ...args) => ({
       encrypt(plaintext, ...argsEnc) {
         const nonce = randomBytes(nonceLength);
         const ciphertext = fn(key, nonce, ...args).encrypt(plaintext, ...argsEnc);
-        const out = (0, utils_js_1.concatBytes)(nonce, ciphertext);
+        const out = (0, utils_ts_1.concatBytes)(nonce, ciphertext);
         ciphertext.fill(0);
         return out;
       },
@@ -28784,21 +28789,21 @@ var require_webcrypto = __commonJS((exports) => {
   }
   function generate(algo) {
     return (key, nonce, AAD) => {
-      (0, _assert_js_1.abytes)(key);
-      (0, _assert_js_1.abytes)(nonce);
+      (0, utils_ts_1.abytes)(key);
+      (0, utils_ts_1.abytes)(nonce);
       const keyParams = { name: algo, length: key.length * 8 };
       const cryptParams = getCryptParams(algo, nonce, AAD);
       let consumed = false;
       return {
         encrypt(plaintext) {
-          (0, _assert_js_1.abytes)(plaintext);
+          (0, utils_ts_1.abytes)(plaintext);
           if (consumed)
             throw new Error("Cannot encrypt() twice with same key / nonce");
           consumed = true;
           return exports.utils.encrypt(key, keyParams, cryptParams, plaintext);
         },
         decrypt(ciphertext) {
-          (0, _assert_js_1.abytes)(ciphertext);
+          (0, utils_ts_1.abytes)(ciphertext);
           return exports.utils.decrypt(key, keyParams, cryptParams, ciphertext);
         }
       };
@@ -28810,7 +28815,7 @@ var require_webcrypto = __commonJS((exports) => {
 });
 
 // ../../node_modules/@noble/hashes/_assert.js
-var require__assert2 = __commonJS((exports) => {
+var require__assert = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.anumber = anumber;
   exports.abytes = abytes;
@@ -28884,7 +28889,7 @@ var require_utils7 = __commonJS((exports) => {
   exports.wrapXOFConstructorWithOpts = wrapXOFConstructorWithOpts;
   exports.randomBytes = randomBytes;
   var crypto_1 = require_cryptoNode2();
-  var _assert_ts_1 = require__assert2();
+  var _assert_ts_1 = require__assert();
   function isBytes(a) {
     return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
   }
@@ -29050,7 +29055,7 @@ var require__md = __commonJS((exports) => {
   exports.setBigUint64 = setBigUint64;
   exports.Chi = Chi;
   exports.Maj = Maj;
-  var _assert_ts_1 = require__assert2();
+  var _assert_ts_1 = require__assert();
   var utils_ts_1 = require_utils7();
   function setBigUint64(view, byteOffset, value, isLE) {
     if (typeof view.setBigUint64 === "function")
@@ -31573,7 +31578,7 @@ var require_ed25519 = __commonJS((exports) => {
 var require_hmac = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.hmac = exports.HMAC = undefined;
-  var _assert_ts_1 = require__assert2();
+  var _assert_ts_1 = require__assert();
   var utils_ts_1 = require_utils7();
 
   class HMAC extends utils_ts_1.Hash {
@@ -32901,7 +32906,7 @@ var require_hkdf = __commonJS((exports) => {
   exports.hkdf = undefined;
   exports.extract = extract;
   exports.expand = expand;
-  var _assert_ts_1 = require__assert2();
+  var _assert_ts_1 = require__assert();
   var hmac_ts_1 = require_hmac();
   var utils_ts_1 = require_utils7();
   function extract(hash, ikm, salt) {
@@ -61129,7 +61134,7 @@ var {
 var package_default = {
   name: "@settlemint/sdk-mcp",
   description: "MCP interface for SettleMint SDK, providing development tools and project management capabilities",
-  version: "2.1.4-pr05b60a44",
+  version: "2.1.4-pr09bd8ab0",
   type: "module",
   private: false,
   license: "FSL-1.1-MIT",
@@ -61171,8 +61176,8 @@ var package_default = {
     "@graphql-tools/load": "8.1.0",
     "@graphql-tools/url-loader": "8.0.31",
     "@modelcontextprotocol/sdk": "1.10.2",
-    "@settlemint/sdk-js": "2.1.4-pr05b60a44",
-    "@settlemint/sdk-utils": "2.1.4-pr05b60a44",
+    "@settlemint/sdk-js": "2.1.4-pr09bd8ab0",
+    "@settlemint/sdk-utils": "2.1.4-pr09bd8ab0",
     "@commander-js/extra-typings": "11.1.0",
     commander: "11.1.0",
     zod: "3.24.3"
@@ -61936,6 +61941,7 @@ var registerBlockchainConcepts = (server) => {
 ### Blockchain Networks
 - **Blockchain Network**: A blockchain instance running on the SettleMint platform
 - **Blockchain Node**: Individual node in a blockchain network
+- **Load Balancer**: Distributes incoming JSON-RPC requests across multiple blockchain nodes
 - **Network Type**: Type of blockchain network (Ethereum, Fabric, etc.)
 - **Consensus Mechanism**: Method used to achieve agreement on the blockchain state
 
@@ -64233,6 +64239,7 @@ var getEnv = (gqlClient) => {
 };
 var LoadBalancerFragment = graphql(`
   fragment LoadBalancer on LoadBalancer {
+    __typename
     id
     uniqueName
     name
@@ -65619,8 +65626,12 @@ var platformInsightsCreate = (server, env3, pat) => {
     provider: z.string().describe("Provider for the insights"),
     region: z.string().describe("Region for the insights"),
     insightsCategory: z.enum(["BLOCKCHAIN_EXPLORER", "HYPERLEDGER_EXPLORER", "OTTERSCAN_BLOCKCHAIN_EXPLORER"]).describe("Category of insights"),
-    blockchainNodeUniqueName: z.string().optional().describe("Unique name of the blockchain node to connect to")
+    blockchainNodeUniqueName: z.string().optional().describe("Unique name of the blockchain node to connect to (mutually exclusive with loadBalancerUniqueName)"),
+    loadBalancerUniqueName: z.string().optional().describe("Unique name of the load balancer to connect to (mutually exclusive with blockchainNodeUniqueName), prefer using a load balancer if available")
   }, async (params) => {
+    if (params.blockchainNodeUniqueName && params.loadBalancerUniqueName) {
+      throw new Error("Only one of 'blockchainNodeUniqueName' and 'loadBalancerUniqueName' may be provided");
+    }
     const insights = await client.insights.create({
       applicationUniqueName: params.applicationUniqueName,
       name: params.name,
@@ -65629,7 +65640,8 @@ var platformInsightsCreate = (server, env3, pat) => {
       provider: params.provider,
       region: params.region,
       insightsCategory: params.insightsCategory,
-      blockchainNodeUniqueName: params.blockchainNodeUniqueName
+      blockchainNodeUniqueName: params.blockchainNodeUniqueName,
+      loadBalancerUniqueName: params.loadBalancerUniqueName
     });
     return {
       content: [
@@ -65855,6 +65867,134 @@ var platformIntegrationToolRestart = (server, env3, pat) => {
   });
 };
 
+// src/tools/platform/load-balancer/create.ts
+var platformLoadBalancerCreate = (server, env3, pat) => {
+  const instance = env3.SETTLEMINT_INSTANCE;
+  if (!instance) {
+    throw new Error("SETTLEMINT_INSTANCE is not set");
+  }
+  const client = createSettleMintClient({
+    accessToken: pat,
+    instance
+  });
+  server.tool("platform-load-balancer-create", {
+    applicationUniqueName: z.string().describe("Unique name of the application to create the load balancer in"),
+    name: z.string().describe("Name of the load balancer"),
+    type: z.enum(["DEDICATED", "SHARED"]).describe("Type of the load balancer (DEDICATED or SHARED)"),
+    size: z.enum(["SMALL", "MEDIUM", "LARGE"]).describe("Size of the load balancer"),
+    provider: z.string().describe("Provider for the load balancer"),
+    region: z.string().describe("Region for the load balancer"),
+    blockchainNetworkUniqueName: z.string().describe("Unique name of the blockchain network for the load balancer"),
+    connectedNodesUniqueNames: z.array(z.string()).describe("Unique names of the nodes to connect to the load balancer")
+  }, async (params) => {
+    const loadBalancer = await client.loadBalancer.create({
+      applicationUniqueName: params.applicationUniqueName,
+      name: params.name,
+      type: params.type,
+      size: params.size,
+      provider: params.provider,
+      region: params.region,
+      blockchainNetworkUniqueName: params.blockchainNetworkUniqueName,
+      connectedNodesUniqueNames: params.connectedNodesUniqueNames
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          name: "Load Balancer Created",
+          description: `Created load balancer: ${params.name} in application: ${params.applicationUniqueName}`,
+          mimeType: "application/json",
+          text: JSON.stringify(loadBalancer, null, 2)
+        }
+      ]
+    };
+  });
+};
+
+// src/tools/platform/load-balancer/list.ts
+var platformLoadBalancerList = (server, env3, pat) => {
+  const instance = env3.SETTLEMINT_INSTANCE;
+  if (!instance) {
+    throw new Error("SETTLEMINT_INSTANCE is not set");
+  }
+  const client = createSettleMintClient({
+    accessToken: pat,
+    instance
+  });
+  server.tool("platform-load-balancer-list", {
+    applicationUniqueName: z.string().describe("Unique name of the application to list load balancers from")
+  }, async (params) => {
+    const loadBalancers = await client.loadBalancer.list(params.applicationUniqueName);
+    return {
+      content: [
+        {
+          type: "text",
+          name: "Load Balancer List",
+          description: `List of load balancers in application: ${params.applicationUniqueName}`,
+          mimeType: "application/json",
+          text: JSON.stringify(loadBalancers, null, 2)
+        }
+      ]
+    };
+  });
+};
+
+// src/tools/platform/load-balancer/read.ts
+var platformLoadBalancerRead = (server, env3, pat) => {
+  const instance = env3.SETTLEMINT_INSTANCE;
+  if (!instance) {
+    throw new Error("SETTLEMINT_INSTANCE is not set");
+  }
+  const client = createSettleMintClient({
+    accessToken: pat,
+    instance
+  });
+  server.tool("platform-load-balancer-read", {
+    loadBalancerUniqueName: z.string().describe("Unique name of the load balancer to read")
+  }, async (params) => {
+    const loadBalancer = await client.loadBalancer.read(params.loadBalancerUniqueName);
+    return {
+      content: [
+        {
+          type: "text",
+          name: "Load Balancer Details",
+          description: `Details for load balancer: ${params.loadBalancerUniqueName}`,
+          mimeType: "application/json",
+          text: JSON.stringify(loadBalancer, null, 2)
+        }
+      ]
+    };
+  });
+};
+
+// src/tools/platform/load-balancer/restart.ts
+var platformLoadBalancerRestart = (server, env3, pat) => {
+  const instance = env3.SETTLEMINT_INSTANCE;
+  if (!instance) {
+    throw new Error("SETTLEMINT_INSTANCE is not set");
+  }
+  const client = createSettleMintClient({
+    accessToken: pat,
+    instance
+  });
+  server.tool("platform-load-balancer-restart", {
+    loadBalancerUniqueName: z.string().describe("Unique name of the load balancer to restart")
+  }, async (params) => {
+    const loadBalancer = await client.loadBalancer.restart(params.loadBalancerUniqueName);
+    return {
+      content: [
+        {
+          type: "text",
+          name: "Load Balancer Restarted",
+          description: `Restarted load balancer: ${params.loadBalancerUniqueName}`,
+          mimeType: "application/json",
+          text: JSON.stringify(loadBalancer, null, 2)
+        }
+      ]
+    };
+  });
+};
+
 // src/tools/platform/middleware/create.ts
 var platformMiddlewareCreate = (server, env3, pat) => {
   const instance = env3.SETTLEMINT_INSTANCE;
@@ -65873,8 +66013,12 @@ var platformMiddlewareCreate = (server, env3, pat) => {
     provider: z.string().describe("Provider for the middleware"),
     region: z.string().describe("Region for the middleware"),
     interface: z.enum(["ATTESTATION_INDEXER", "BESU", "FIREFLY_FABCONNECT", "GRAPH", "HA_GRAPH", "SMART_CONTRACT_PORTAL"]).describe("Interface type for the middleware"),
-    blockchainNodeUniqueName: z.string().optional().describe("Unique name of the blockchain node to connect to")
+    blockchainNodeUniqueName: z.string().optional().describe("Unique name of the blockchain node to connect to (mutually exclusive with loadBalancerUniqueName), preferred option for interface SMART_CONTRACT_PORTAL"),
+    loadBalancerUniqueName: z.string().optional().describe("Unique name of the load balancer to connect to (mutually exclusive with blockchainNodeUniqueName), preferred option for all other interfaces")
   }, async (params) => {
+    if (params.blockchainNodeUniqueName && params.loadBalancerUniqueName) {
+      throw new Error("Only one of 'blockchainNodeUniqueName' and 'loadBalancerUniqueName' may be provided");
+    }
     const middleware = await client.middleware.create({
       applicationUniqueName: params.applicationUniqueName,
       name: params.name,
@@ -65883,7 +66027,8 @@ var platformMiddlewareCreate = (server, env3, pat) => {
       provider: params.provider,
       region: params.region,
       interface: params.interface,
-      blockchainNodeUniqueName: params.blockchainNodeUniqueName
+      blockchainNodeUniqueName: params.blockchainNodeUniqueName,
+      loadBalancerUniqueName: params.loadBalancerUniqueName
     });
     return {
       content: [
@@ -66731,6 +66876,10 @@ async function main() {
     platformBlockchainNodeRead(server, env3, pat);
     platformBlockchainNodeCreate(server, env3, pat);
     platformBlockchainNodeRestart(server, env3, pat);
+    platformLoadBalancerList(server, env3, pat);
+    platformLoadBalancerRead(server, env3, pat);
+    platformLoadBalancerCreate(server, env3, pat);
+    platformLoadBalancerRestart(server, env3, pat);
     platformMiddlewareList(server, env3, pat);
     platformMiddlewareRead(server, env3, pat);
     platformMiddlewareCreate(server, env3, pat);
@@ -66768,4 +66917,4 @@ await main().catch((error2) => {
   process.exit(1);
 });
 
-//# debugId=C73C546EEEF58ADC64756E2164756E21
+//# debugId=F535B59976F70AB664756E2164756E21