@hiero-ledger/sdk 2.75.0 → 2.77.0

package/dist/umd.js

@@ -5119,7 +5119,11 @@
     var f = n.default;
   	if (typeof f == "function") {
   		var a = function a () {
-  			if (this instanceof a) {
+  			var isInstance = false;
+        try {
+          isInstance = this instanceof a;
+        } catch {}
+  			if (isInstance) {
           return Reflect.construct(f, arguments, this.constructor);
   			}
   			return f.apply(this, arguments);
@@ -43555,6 +43559,7 @@
           if (error instanceof GrpcServiceError) {
               return (
                   error.status._code === GrpcStatus.Timeout._code ||
+                  error.status._code === GrpcStatus.DeadlineExceeded._code ||
                   error.status._code === GrpcStatus.Unavailable._code ||
                   error.status._code === GrpcStatus.ResourceExhausted._code ||
                   error.status._code === GrpcStatus.GrpcWeb._code ||
@@ -43645,6 +43650,11 @@
                   requestTimeout != null ? requestTimeout : client.requestTimeout;
           }
 
+          // If the grpc deadline is not set on the request, use the default value from client
+          if (this._grpcDeadline == null) {
+              this._grpcDeadline = client.grpcDeadline;
+          }
+
           // Some request need to perform additional requests before the executing
           // such as paid queries need to fetch the cost of the query before
           // finally executing the actual query.
@@ -43762,6 +43772,12 @@
               }
 
               const channel = node.getChannel();
+
+              // Set the gRPC deadline on the channel if this query has a custom deadline
+              if (this._grpcDeadline != null) {
+                  channel.setGrpcDeadline(this._grpcDeadline);
+              }
+
               const request = await this._makeRequestAsync();
 
               let response;
@@ -43812,7 +43828,7 @@
                   // from blocking this request
                   const promises = [];
 
-                  // If a grpc deadline is est, we should race it, otherwise the only thing in the
+                  // If a grpc deadline is set, we should race it, otherwise the only thing in the
                   // list of promises will be the execution promise.
                   if (this._grpcDeadline != null) {
                       promises.push(
@@ -43821,7 +43837,11 @@
                               setTimeout(
                                   // eslint-disable-next-line ie11/no-loop-func
                                   () =>
-                                      reject(new Error("grpc deadline exceeded")),
+                                      reject(
+                                          new GrpcServiceError(
+                                              GrpcStatus.DeadlineExceeded,
+                                          ),
+                                      ),
                                   /** @type {number=} */ (this._grpcDeadline),
                               ),
                           ),
@@ -93070,6 +93090,7 @@
   	    transmit,
   	    serialize,
   	    asObject: opts.browser.asObject,
+  	    asObjectBindingsOnly: opts.browser.asObjectBindingsOnly,
   	    formatters: opts.browser.formatters,
   	    levels,
   	    timestamp: getTimeFunction(opts),
@@ -93079,6 +93100,13 @@
   	  logger.levels = getLevels(opts);
   	  logger.level = level;
 
+  	  logger.isLevelEnabled = function (level) {
+  	    if (!this.levels.values[level]) {
+  	      return false
+  	    }
+
+  	    return this.levels.values[level] >= this.levels.values[this.level]
+  	  };
   	  logger.setMaxListeners = logger.getMaxListeners =
   	  logger.emit = logger.addListener = logger.on =
   	  logger.prependListener = logger.once =
@@ -93278,7 +93306,7 @@
   	        argsIsSerialized = true;
   	      }
   	      if (opts.asObject || opts.formatters) {
-  	        write.call(proto, asObject(this, level, args, ts, opts));
+  	        write.call(proto, ...asObject(this, level, args, ts, opts));
   	      } else write.apply(proto, args);
 
   	      if (opts.transmit) {
@@ -93307,6 +93335,10 @@
   	  const argsCloned = args.slice();
   	  let msg = argsCloned[0];
   	  const logObject = {};
+
+  	  let lvl = (logger._childLevel | 0) + 1;
+  	  if (lvl < 1) lvl = 1;
+
   	  if (ts) {
   	    logObject.time = ts;
   	  }
@@ -93318,19 +93350,28 @@
   	    logObject.level = logger.levels.values[level];
   	  }
 
-  	  let lvl = (logger._childLevel | 0) + 1;
-  	  if (lvl < 1) lvl = 1;
-  	  // deliberate, catching objects, arrays
-  	  if (msg !== null && typeof msg === 'object') {
-  	    while (lvl-- && typeof argsCloned[0] === 'object') {
-  	      Object.assign(logObject, argsCloned.shift());
+  	  if (opts.asObjectBindingsOnly) {
+  	    if (msg !== null && typeof msg === 'object') {
+  	      while (lvl-- && typeof argsCloned[0] === 'object') {
+  	        Object.assign(logObject, argsCloned.shift());
+  	      }
   	    }
-  	    msg = argsCloned.length ? format(argsCloned.shift(), argsCloned) : undefined;
-  	  } else if (typeof msg === 'string') msg = format(argsCloned.shift(), argsCloned);
-  	  if (msg !== undefined) logObject[opts.messageKey] = msg;
 
-  	  const formattedLogObject = logObjectFormatter(logObject);
-  	  return formattedLogObject
+  	    const formattedLogObject = logObjectFormatter(logObject);
+  	    return [formattedLogObject, ...argsCloned]
+  	  } else {
+  	    // deliberate, catching objects, arrays
+  	    if (msg !== null && typeof msg === 'object') {
+  	      while (lvl-- && typeof argsCloned[0] === 'object') {
+  	        Object.assign(logObject, argsCloned.shift());
+  	      }
+  	      msg = argsCloned.length ? format(argsCloned.shift(), argsCloned) : undefined;
+  	    } else if (typeof msg === 'string') msg = format(argsCloned.shift(), argsCloned);
+  	    if (msg !== undefined) logObject[opts.messageKey] = msg;
+
+  	    const formattedLogObject = logObjectFormatter(logObject);
+  	    return [formattedLogObject]
+  	  }
   	}
 
   	function applySerializers (args, serialize, serializers, stdErrSerialize) {
@@ -96869,6 +96910,22 @@
 
   /* NOSONAR */
 
+  /**
+   * Default gRPC deadline in milliseconds (10 seconds)
+   *
+   * Maximum time allowed for a single gRPC request. If exceeded, the node
+   * is marked unhealthy and the SDK rotates to the next node.
+   */
+  const DEFAULT_GRPC_DEADLINE = 10 * 1000;
+
+  /**
+   * Default request timeout in milliseconds (2 minutes)
+   *
+   * Maximum total time for a complete Transaction/Query operation including
+   * retries and node rotation. Must be >= grpcDeadline.
+   */
+  const DEFAULT_REQUEST_TIMEOUT = 2 * 60 * 1000;
+
   // MAINNET node proxies are the same for both 'WebClient' and 'NativeClient'
   const MAINNET = {
       "node00.swirldslabs.com:443": new AccountId(3),
@@ -96899,7 +96956,7 @@
       "node29.swirldslabs.com:443": new AccountId(32),
       "node30.swirldslabs.com:443": new AccountId(33),
       "node31.swirldslabs.com:443": new AccountId(34),
-      // "node32.swirldslabs.com:443": new AccountId(35), - temporarily disabled
+      "node32.swirldslabs.com:443": new AccountId(35),
       "node33.swirldslabs.com:443": new AccountId(36),
       "node34.swirldslabs.com:443": new AccountId(37),
   };
@@ -97184,13 +97241,6 @@
        * @returns {Promise<NodeAddressBook>}
        */
       execute(client, requestTimeout) {
-          // Extra validation when initializing the client with only a mirror network
-          if (client._network._network.size === 0 && !client._timer) {
-              throw new Error(
-                  "The client's network update period is required. Please set it using the setNetworkUpdatePeriod method.",
-              );
-          }
-
           return new Promise((resolve, reject) => {
               void this._makeFetchRequest(
                   client,
@@ -97281,7 +97331,7 @@
                               certHash: node.node_cert_hash,
                               publicKey: node.public_key,
                               description: node.description,
-                              stake: node.stake.toString(),
+                              stake: node.stake?.toString(),
                           }),
                       );
 
@@ -97437,6 +97487,8 @@
    * @property {boolean} [scheduleNetworkUpdate]
    * @property {number} [shard]
    * @property {number} [realm]
+   * @property {number} [grpcDeadline]
+   * @property {number} [requestTimeout]
    */
 
   /**
@@ -97524,7 +97576,10 @@
           this._defaultRegenerateTransactionId = true;
 
           /** @private */
-          this._requestTimeout = null;
+          this._requestTimeout = DEFAULT_REQUEST_TIMEOUT;
+
+          /** @private */
+          this._grpcDeadline = DEFAULT_GRPC_DEADLINE;
 
           /**
            * @type {boolean}
@@ -97553,6 +97608,23 @@
               this._realm = props.realm;
           }
 
+          if (props != null && props.grpcDeadline != null) {
+              this.setGrpcDeadline(props.grpcDeadline);
+          }
+
+          if (props != null && props.requestTimeout != null) {
+              this.setRequestTimeout(props.requestTimeout);
+          }
+
+          // Validate that requestTimeout is larger than grpcDeadline after both are set
+          if (this._requestTimeout <= this._grpcDeadline) {
+              console.warn(
+                  `DEPRECATION WARNING: requestTimeout (${this._requestTimeout}ms) should be larger than grpcDeadline (${this._grpcDeadline}ms). ` +
+                      `This configuration may cause operations to fail unexpectedly. ` +
+                      `This will throw an error in the next major version. Please adjust your timeout values.`,
+              );
+          }
+
           /** @internal */
           /** @type {NodeJS.Timeout} */
           this._timer;
@@ -98072,21 +98144,65 @@
       }
 
       /**
-       * @param {number} requestTimeout - Number of milliseconds
+       * Set the total request timeout for complete operations.
+       *
+       * @param {number} requestTimeout - Maximum time in milliseconds for complete Transaction/Query operations
        * @returns {this}
        */
       setRequestTimeout(requestTimeout) {
+          if (requestTimeout <= 0) {
+              throw new Error("requestTimeout must be a positive number");
+          }
+          if (requestTimeout <= this._grpcDeadline) {
+              console.warn(
+                  `DEPRECATION WARNING: requestTimeout (${requestTimeout}ms) should be larger than grpcDeadline (${this._grpcDeadline}ms). ` +
+                      `This configuration may cause operations to fail unexpectedly. ` +
+                      `This will throw an error in the next major version. Please adjust your timeout values.`,
+              );
+          }
           this._requestTimeout = requestTimeout;
           return this;
       }
 
       /**
-       * @returns {?number}
+       * Get the total request timeout for complete operations.
+       *
+       * @returns {number} Maximum time in milliseconds for complete Transaction/Query operations
        */
       get requestTimeout() {
           return this._requestTimeout;
       }
 
+      /**
+       * Set the global gRPC deadline for all requests.
+       *
+       * @param {number} grpcDeadline - Maximum time in milliseconds for a single gRPC request
+       * @returns {this}
+       */
+      setGrpcDeadline(grpcDeadline) {
+          if (grpcDeadline <= 0) {
+              throw new Error("grpcDeadline must be a positive number");
+          }
+          if (grpcDeadline >= this._requestTimeout) {
+              console.warn(
+                  `DEPRECATION WARNING: grpcDeadline (${grpcDeadline}ms) should be smaller than requestTimeout (${this._requestTimeout}ms). ` +
+                      `This configuration may cause operations to fail unexpectedly. ` +
+                      `This will throw an error in the next major version. Please adjust your timeout values.`,
+              );
+          }
+          this._grpcDeadline = grpcDeadline;
+          return this;
+      }
+
+      /**
+       * Get the global gRPC deadline for all requests.
+       *
+       * @returns {number} Maximum time in milliseconds for a single gRPC request
+       */
+      get grpcDeadline() {
+          return this._grpcDeadline;
+      }
+
       /**
        * @returns {number}
        */
@@ -98191,7 +98307,9 @@
        * @returns {(address: string) => ChannelT}
        */
       _createNetworkChannel() {
-          throw new Error("not implemented");
+          return () => {
+              throw new Error("not implemented");
+          };
       }
 
       /**
@@ -98199,7 +98317,9 @@
        * @returns {(address: string) => MirrorChannelT}
        */
       _createMirrorNetworkChannel() {
-          throw new Error("not implemented");
+          return () => {
+              throw new Error("not implemented");
+          };
       }
 
       /**
@@ -98288,7 +98408,7 @@
 
   const SDK_NAME = "hiero-sdk-js";
   const SDK_VERSION =
-      "2.75.0" ;
+      "2.77.0" ;
 
   // SPDX-License-Identifier: Apache-2.0
 
@@ -98302,8 +98422,9 @@
   class Channel {
       /**
        * @protected
+       * @param {number} [grpcDeadline] - The gRPC deadline in milliseconds
        */
-      constructor() {
+      constructor(grpcDeadline = DEFAULT_GRPC_DEADLINE) {
           /**
            * @protected
            * @type {?HieroProto.proto.CryptoService}
@@ -98363,6 +98484,28 @@
            * @type {?HieroProto.proto.AddressBookService}
            */
           this._addressBook = null;
+
+          /**
+           * @protected
+           * @type {number}
+           */
+          this._grpcDeadline = grpcDeadline;
+      }
+
+      /**
+       * Set the gRPC deadline for this channel
+       * @param {number} deadline - The deadline in milliseconds, or null to clear
+       */
+      setGrpcDeadline(deadline) {
+          this._grpcDeadline = deadline;
+      }
+
+      /**
+       * Get the gRPC deadline for this channel
+       * @returns {number}
+       */
+      get grpcDeadline() {
+          return this._grpcDeadline;
       }
 
       /**
@@ -98634,15 +98777,185 @@
   class WebChannel extends Channel {
       /**
        * @param {string} address
+       * @param {number=} grpcDeadline
        */
-      constructor(address) {
-          super();
+      constructor(address, grpcDeadline) {
+          super(grpcDeadline);
 
           /**
            * @type {string}
            * @private
            */
           this._address = address;
+
+          // Set the gRPC deadline using the base class method
+
+          /**
+           * Flag indicating if the connection is ready (health check has passed)
+           * Set to true after the first successful health check
+           *
+           * @type {boolean}
+           * @private
+           */
+          this._isReady = false;
+
+          /**
+           * Promise that resolves when the health check is complete
+           * Used to prevent multiple concurrent health checks
+           *
+           * @type {Promise<void>|null}
+           * @private
+           */
+          this._healthCheckPromise = null;
+      }
+
+      /**
+       * Determines whether to use HTTPS based on the address
+       * @param {string} address - The address to check
+       * @returns {boolean} - True if HTTPS should be used, false for HTTP
+       * @private
+       */
+      _shouldUseHttps(address) {
+          return !(
+              address.includes("localhost") || address.includes("127.0.0.1")
+          );
+      }
+
+      /**
+       * Builds the full URL with appropriate scheme (http/https)
+       * @param {string} address - The base address
+       * @returns {string} - The full URL with scheme
+       * @private
+       */
+      _buildUrl(address) {
+          // Check if address already contains a scheme
+          const hasScheme =
+              address.startsWith("http://") || address.startsWith("https://");
+
+          if (hasScheme) {
+              // Use the address as-is if it already has a scheme
+              return address;
+          } else {
+              // Only prepend scheme if none exists
+              const shouldUseHttps = this._shouldUseHttps(address);
+              return shouldUseHttps ? `https://${address}` : `http://${address}`;
+          }
+      }
+
+      /**
+       * Check if the gRPC-Web proxy is reachable and healthy
+       * Performs a POST request and verifies the response has gRPC-Web headers,
+       * which indicates the proxy is running and processing gRPC requests.
+       * Results are cached per address for the entire lifecycle.
+       * Uses promise-based synchronization to prevent multiple concurrent health checks.
+       *
+       * @param {Date} deadline - Deadline for the health check
+       * @returns {Promise<void>}
+       * @private
+       */
+      async _waitForReady(deadline) {
+          // Check if we've already validated this address
+          if (this._isReady) {
+              return; // Health check already passed for this address
+          }
+
+          // If a health check is already in progress, wait for it to complete
+          if (this._healthCheckPromise) {
+              return this._healthCheckPromise;
+          }
+
+          // Start a new health check and store the promise
+          this._healthCheckPromise = this._performHealthCheck(deadline);
+
+          try {
+              await this._healthCheckPromise;
+          } finally {
+              // Clear the promise when done (success or failure)
+              this._healthCheckPromise = null;
+          }
+      }
+
+      /**
+       * Performs the actual health check request
+       * @param {Date} deadline - Deadline for the health check
+       * @returns {Promise<void>}
+       * @private
+       */
+      async _performHealthCheck(deadline) {
+          const address = this._buildUrl(this._address);
+
+          // Calculate remaining time until deadline
+          const timeoutMs = deadline.getTime() - Date.now();
+          if (timeoutMs <= 0) {
+              throw new GrpcServiceError(
+                  GrpcStatus.Timeout,
+                  ALL_WEB_NETWORK_NODES?.[this._address]?.toString(),
+              );
+          }
+
+          const abortController = new AbortController();
+          const timeoutId = setTimeout(() => abortController.abort(), timeoutMs);
+
+          try {
+              // Make a POST request to verify the gRPC-Web proxy is running
+              // We use a minimal gRPC-Web compatible request
+              //eslint-disable-next-line n/no-unsupported-features/node-builtins
+              const response = await fetch(address, {
+                  method: "POST",
+                  headers: {
+                      "content-type": "application/grpc-web+proto",
+                      "x-user-agent": `${SDK_NAME}/${SDK_VERSION}`,
+                      "x-grpc-web": "1",
+                  },
+                  body: new Uint8Array(0), // Empty body for health check
+                  signal: abortController.signal,
+              });
+
+              clearTimeout(timeoutId);
+
+              // Check if response is successful (200) or indicates a redirect (3xx)
+              // 3xx status codes indicate the resource has moved, which is valid for proxies
+              if (
+                  response.ok ||
+                  (response.status >= 300 && response.status < 400)
+              ) {
+                  const grpcStatus = response.headers.get("grpc-status");
+                  const grpcMessage = response.headers.get("grpc-message");
+
+                  // If gRPC headers exist, the proxy is running and processing requests
+                  if (grpcStatus != null || grpcMessage != null) {
+                      // Mark this connection as ready
+                      this._isReady = true;
+                      return; //  Healthy - gRPC-Web proxy is responding
+                  }
+              }
+
+              // If we get here, either status isn't 200/3xx or no gRPC headers present
+              // This means the proxy might not be configured correctly or not running
+              throw new GrpcServiceError(
+                  GrpcStatus.Unavailable,
+                  ALL_WEB_NETWORK_NODES?.[this._address]?.toString(),
+              );
+          } catch (error) {
+              clearTimeout(timeoutId);
+
+              if (error instanceof Error && error.name === "AbortError") {
+                  throw new GrpcServiceError(
+                      GrpcStatus.Timeout,
+                      ALL_WEB_NETWORK_NODES?.[this._address]?.toString(),
+                  );
+              }
+
+              if (error instanceof GrpcServiceError) {
+                  throw error;
+              }
+
+              // Network error - server is not reachable
+              throw new GrpcServiceError(
+                  GrpcStatus.Unavailable,
+                  ALL_WEB_NETWORK_NODES?.[this._address]?.toString(),
+              );
+          }
       }
 
       /**
@@ -98662,15 +98975,18 @@
       _createUnaryClient(serviceName) {
           // eslint-disable-next-line @typescript-eslint/no-misused-promises
           return async (method, requestData, callback) => {
+              // Calculate deadline for connection check
+              const deadline = new Date();
+              const milliseconds = this._grpcDeadline;
+
+              deadline.setMilliseconds(deadline.getMilliseconds() + milliseconds);
+
               try {
-                  const shouldUseHttps = !(
-                      this._address.includes("localhost") ||
-                      this._address.includes("127.0.0.1")
-                  );
+                  // Wait for connection to be ready (similar to gRPC waitForReady)
+                  await this._waitForReady(deadline);
 
-                  const address = shouldUseHttps
-                      ? `https://${this._address}`
-                      : `http://${this._address}`;
+                  // Build the full URL with appropriate scheme
+                  const address = this._buildUrl(this._address);
                   // this will be executed in a browser environment so eslint is
                   // disabled for the fetch call
                   //eslint-disable-next-line n/no-unsupported-features/node-builtins
@@ -98692,6 +99008,7 @@
                           HttpStatus._fromValue(response.status),
                       );
                       callback(error, null);
+                      return;
                   }
 
                   // Check headers for gRPC errors
@@ -98705,6 +99022,7 @@
                       );
                       error.message = grpcMessage;
                       callback(error, null);
+                      return;
                   }
 
                   const responseBuffer = await response.arrayBuffer();
@@ -98712,6 +99030,11 @@
 
                   callback(null, unaryResponse);
               } catch (error) {
+                  if (error instanceof GrpcServiceError) {
+                      callback(error, null);
+                      return;
+                  }
+
                   const err = new GrpcServiceError(
                       // retry on grpc web errors
                       GrpcStatus._fromValue(18),
@@ -98745,52 +99068,45 @@
        */
       constructor(props) {
           super(props);
+
           if (props != null) {
               if (typeof props.network === "string") {
-                  switch (props.network) {
+                  this._setNetworkFromName(props.network);
+              } else if (props.network != null) {
+                  Client._validateNetworkConsistency(props.network);
+
+                  const { shard, realm } = Client._extractShardRealm(
+                      props.network,
+                  );
+
+                  // Shard and realm are inferred from the network, so we need to set them here
+                  // to ensure that the client is properly configured.
+                  this._shard = shard;
+                  this._realm = realm;
+
+                  this.setNetwork(props.network);
+              }
+
+              if (typeof props.mirrorNetwork === "string") {
+                  switch (props.mirrorNetwork) {
                       case "mainnet":
-                          this.setNetwork(WebNetwork.MAINNET);
                           this.setMirrorNetwork(WebMirrorNetwork.MAINNET);
-                          this.setLedgerId(LedgerId.MAINNET);
                           break;
 
                       case "testnet":
-                          this.setNetwork(WebNetwork.TESTNET);
-                          this.setLedgerId(LedgerId.TESTNET);
                           this.setMirrorNetwork(WebMirrorNetwork.TESTNET);
                           break;
 
                       case "previewnet":
-                          this.setNetwork(WebNetwork.PREVIEWNET);
-                          this.setLedgerId(LedgerId.PREVIEWNET);
                           this.setMirrorNetwork(WebMirrorNetwork.PREVIEWNET);
                           break;
 
-                      case "local-node":
-                          this.setNetwork(WebNetwork.LOCAL_NODE);
-                          this.setLedgerId(LedgerId.LOCAL_NODE);
-                          this.setMirrorNetwork(WebMirrorNetwork.LOCAL_NODE);
-                          break;
-
                       default:
-                          throw new Error(
-                              // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                              `unknown network: ${props.network}`,
-                          );
+                          this.setMirrorNetwork([props.mirrorNetwork]);
+                          break;
                   }
-              } else if (props.network != null) {
-                  Client._validateNetworkConsistency(props.network);
-
-                  const { shard, realm } = Client._extractShardRealm(
-                      props.network,
-                  );
-
-                  // Shard and realm are inferred from the network, so we need to set them here
-                  // to ensure that the client is properly configured.
-                  this._shard = shard;
-                  this._realm = realm;
-
-                  this.setNetwork(props.network);
+              } else if (props.mirrorNetwork != null) {
+                  this.setMirrorNetwork(props.mirrorNetwork);
               }
           }
       }
@@ -98967,6 +99283,19 @@
                       break;
               }
           } else {
+              // Check for deprecation warnings for network endpoints with schemes
+              for (const [key] of Object.entries(network)) {
+                  if (key.startsWith("https://") || key.startsWith("http://")) {
+                      console.warn(
+                          '[Deprecation Notice] Hiero SDK: Network endpoint "' +
+                              key +
+                              '" includes a URL scheme (e.g. "https://"). ' +
+                              "This format was accepted in earlier versions but is now deprecated. " +
+                              'Please remove the scheme and use "host:port" instead (e.g. "node00.swirldslabs.com:443"). ' +
+                              "Support for scheme-prefixed endpoints will be removed in a future major release.",
+                      );
+                  }
+              }
               this._network.setNetwork(network);
           }
       }
@@ -99000,6 +99329,46 @@
           return this;
       }
 
+      /**
+       * @private
+       * @param {string} name
+       * @returns {this}
+       */
+      _setNetworkFromName(name) {
+          switch (name) {
+              case "mainnet":
+                  this.setNetwork(WebNetwork.MAINNET);
+                  this.setMirrorNetwork(WebMirrorNetwork.MAINNET);
+                  this.setLedgerId(LedgerId.MAINNET);
+                  break;
+
+              case "testnet":
+                  this.setNetwork(WebNetwork.TESTNET);
+                  this.setMirrorNetwork(WebMirrorNetwork.TESTNET);
+                  this.setLedgerId(LedgerId.TESTNET);
+                  break;
+
+              case "previewnet":
+                  this.setNetwork(WebNetwork.PREVIEWNET);
+                  this.setMirrorNetwork(WebMirrorNetwork.PREVIEWNET);
+                  this.setLedgerId(LedgerId.PREVIEWNET);
+                  break;
+
+              case "local-node":
+                  this.setNetwork(WebNetwork.LOCAL_NODE);
+                  this.setMirrorNetwork(WebMirrorNetwork.LOCAL_NODE);
+                  this.setLedgerId(LedgerId.LOCAL_NODE);
+                  break;
+
+              default:
+                  throw new Error(
+                      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+                      `unknown network: ${name}`,
+                  );
+          }
+          return this;
+      }
+
       /**
        * @override
        * @returns {Promise<this>}
@@ -99049,7 +99418,7 @@
        * @returns {(address: string) => WebChannel}
        */
       _createNetworkChannel() {
-          return (address) => new WebChannel(address);
+          return (address) => new WebChannel(address, this.grpcDeadline);
       }
 
       /**