starknet 10.3.0 → 10.3.2

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [10.3.2](https://github.com/starknet-io/starknet.js/compare/v10.3.1...v10.3.2) (2026-06-16)
+
+### Bug Fixes
+
+- surface clear error instead of crashing on empty node reply ([678ca1d](https://github.com/starknet-io/starknet.js/commit/678ca1db2b0f055708b03363688bddf75858a5e4))
+
+## [10.3.1](https://github.com/starknet-io/starknet.js/compare/v10.3.0...v10.3.1) (2026-06-15)
+
+### Bug Fixes
+
+- plugins methods in Account not available in dist ([58a150f](https://github.com/starknet-io/starknet.js/commit/58a150fa2910c7498d96ec2a335793c852ab87a9))
+
 # [10.3.0](https://github.com/starknet-io/starknet.js/compare/v10.2.0...v10.3.0) (2026-06-10)
 
 ### Features

package/dist/index.d.ts

@@ -5319,6 +5319,198 @@ declare class PluginManager {
     hasPlugin(name: string): boolean;
 }
 
+interface StarknetIdProviderMethods {
+    getStarkName(address: BigNumberish, StarknetIdContract?: string): Promise<string>;
+    getAddressFromStarkName(name: string, StarknetIdContract?: string): Promise<string>;
+    getStarkProfile(address: BigNumberish, StarknetIdContract?: string, StarknetIdIdentityContract?: string, StarknetIdVerifierContract?: string, StarknetIdPfpContract?: string, StarknetIdPopContract?: string, StarknetIdMulticallContract?: string): Promise<StarkProfile>;
+}
+interface StarknetIdAccountMethods {
+    getStarkName(address?: BigNumberish, StarknetIdContract?: string): Promise<string>;
+    getAddressFromStarkName(name: string, StarknetIdContract?: string): Promise<string>;
+    getStarkProfile(address: BigNumberish, StarknetIdContract?: string, StarknetIdIdentityContract?: string, StarknetIdVerifierContract?: string, StarknetIdPfpContract?: string, StarknetIdPopContract?: string, StarknetIdMulticallContract?: string): Promise<StarkProfile>;
+}
+declare class StarknetIdImpl {
+    static getStarkName(provider: ProviderInterface, address: BigNumberish, StarknetIdContract?: string): Promise<string>;
+    static getAddressFromStarkName(provider: ProviderInterface, name: string, StarknetIdContract?: string): Promise<string>;
+    static getStarkProfile(provider: ProviderInterface, address: BigNumberish, StarknetIdContract?: string, StarknetIdIdentityContract?: string, StarknetIdVerifierContract?: string, StarknetIdPfpContract?: string, StarknetIdPopContract?: string, StarknetIdMulticallContract?: string): Promise<StarkProfile>;
+}
+
+interface BrotherProfile {
+    name: string;
+    resolver: string;
+    tokenId: string;
+    expiryDate: number;
+    lastTransferTime: number;
+}
+interface BrotherIdProviderMethods {
+    getBrotherName(address: BigNumberish, BrotherIdContract?: string): Promise<string>;
+    getAddressFromBrotherName(name: string, BrotherIdContract?: string): Promise<string>;
+    getBrotherProfile(address: BigNumberish, BrotherIdContract?: string): Promise<BrotherProfile>;
+}
+declare class BrotherIdImpl {
+    static getBrotherName(provider: ProviderInterface, address: BigNumberish, BrotherIdContract?: string): Promise<string>;
+    static getAddressFromBrotherName(provider: ProviderInterface, name: string, BrotherIdContract?: string): Promise<string>;
+    static getBrotherProfile(provider: ProviderInterface, address: BigNumberish, BrotherIdContract?: string): Promise<BrotherProfile>;
+}
+/**
+ * BrotherId plugin - adds .brother domain resolution methods.
+ *
+ * @example
+ * ```typescript
+ * import { RpcProvider, brotherId } from 'starknet';
+ * const provider = new RpcProvider({ plugins: [brotherId()] });
+ * const name = await provider.getBrotherName('0x123...');
+ * ```
+ */
+declare function brotherId(): StarknetPlugin<BrotherIdProviderMethods>;
+
+/**
+ * Options for controlling fastWaitForTransaction polling behavior
+ */
+type FastWaitForTransactionOptions = {
+    /** Number of retry attempts (default: 50) */
+    retries?: number;
+    /** Milliseconds to wait between retries (default: 500) */
+    retryInterval?: number;
+};
+/**
+ * Response from fastExecute() containing transaction result and readiness status
+ */
+type FastExecuteResponse = {
+    /** The transaction invoke response with transaction hash */
+    txResult: InvokeFunctionResponse;
+    /** Whether the next transaction can be executed immediately */
+    isReady: boolean;
+};
+/**
+ * Provider methods added by the FastExecute plugin
+ */
+interface FastExecuteProviderMethods {
+    /**
+     * Wait for transaction confirmation with polling optimization for gaming.
+     *
+     * This method is fast but Events and transaction reports are not yet available.
+     * Useful for gaming activity and rapid-fire transaction scenarios.
+     *
+     * Only available on RPC 0.9 and onwards.
+     *
+     * @param {BigNumberish} txHash - Transaction hash to monitor
+     * @param {string} address - Address of the account (used to track nonce changes)
+     * @param {BigNumberish} initNonce - Initial nonce of the account (before the transaction)
+     * @param {FastWaitForTransactionOptions} [options={retries: 50, retryInterval: 500}] - Polling configuration
+     *        options. `retries` is the number of times to retry (default: 50), `retryInterval` is the time in ms
+     *        between retries (default: 500).
+     * @returns {Promise<boolean>} Returns true if the next transaction is possible (nonce increment detected),
+     *          false if the timeout has been reached, or throws an error in case of provider communication failure
+     *          or transaction reversion.
+     *
+     * @example
+     * ```typescript
+     * const isReady = await provider.fastWaitForTransaction(
+     *   '0x123abc...',
+     *   '0x456def...',
+     *   10,
+     *   { retries: 30, retryInterval: 500 }
+     * );
+     *
+     * if (isReady) {
+     *   // Next transaction can be sent
+     * }
+     * ```
+     */
+    fastWaitForTransaction(txHash: BigNumberish, address: string, initNonce: BigNumberish, options?: FastWaitForTransactionOptions): Promise<boolean>;
+}
+/**
+ * Account methods added by the FastExecute plugin
+ */
+interface FastExecuteAccountMethods {
+    /**
+     * Execute one or multiple calls through the account contract,
+     * responding as soon as a new transaction is possible with the same account.
+     * Useful for gaming usage where rapid consecutive transactions are needed.
+     *
+     * This method requires the provider to be initialized with `pre_confirmed` blockIdentifier option.
+     * RPC 0.9 minimum.
+     *
+     * In a normal `account.execute()` call followed by `provider.waitForTransaction()`, you have immediate access
+     * to the events and transaction report. Here, we process consecutive transactions faster, but events and
+     * transaction reports are not available immediately.
+     *
+     * As a consequence of the above, do not use contract/account deployment with this method.
+     *
+     * @param {AllowArray<Call>} transactions - Single call or array of calls to execute
+     * @param {UniversalDetails} [transactionsDetail] - Transaction execution options
+     * @param {FastWaitForTransactionOptions} [waitDetail={retries: 50, retryInterval: 500}] - Options to scan the
+     *        network for the next possible transaction. `retries` is the number of times to retry (default: 50),
+     *        `retryInterval` is the time in ms between retries (default: 500).
+     * @returns {Promise<FastExecuteResponse>} Response containing the transaction result and status for the next
+     *          transaction. If `isReady` is true, you can execute the next transaction immediately. If false,
+     *          timeout has been reached before the next transaction was possible.
+     *
+     * @example
+     * ```typescript
+     * const myProvider = new RpcProvider({
+     *   nodeUrl: url,
+     *   blockIdentifier: BlockTag.PRE_CONFIRMED
+     * });
+     * const myAccount = new Account({
+     *   provider: myProvider,
+     *   address: accountAddress0,
+     *   signer: privateKey0
+     * });
+     *
+     * const resp = await myAccount.fastExecute(
+     *   call,
+     *   { tip: recommendedTip },
+     *   { retries: 30, retryInterval: 500 }
+     * );
+     *
+     * // if resp.isReady is true, you can launch immediately a new tx
+     * if (resp.isReady) {
+     *   // send next transaction
+     * }
+     * ```
+     */
+    fastExecute(transactions: any, transactionsDetail?: any, waitDetail?: FastWaitForTransactionOptions): Promise<FastExecuteResponse>;
+}
+
+/**
+ * FastExecute plugin - adds gaming-optimized transaction execution
+ *
+ * Provides fastExecute() on accounts and fastWaitForTransaction() on providers
+ * for rapid successive transaction execution with minimal confirmation latency.
+ *
+ * Requires:
+ * - RPC 0.9 or later
+ * - Provider initialized with BlockTag.PRE_CONFIRMED
+ *
+ * @example
+ * ```typescript
+ * import { RpcProvider, Account } from 'starknet';
+ * import { fastExecute } from 'starknet/plugins';
+ *
+ * const provider = new RpcProvider({
+ *   nodeUrl: url,
+ *   blockIdentifier: BlockTag.PRE_CONFIRMED,
+ * });
+ *
+ * const account = new Account({ provider, address, signer });
+ *
+ * const resp = await account.fastExecute(
+ *   call,
+ *   { tip: recommendedTip },
+ *   { retries: 30, retryInterval: 500 }
+ * );
+ *
+ * if (resp.isReady) {
+ *   // Next transaction can be sent immediately
+ * }
+ * ```
+ */
+declare function fastExecute(): StarknetPlugin<FastExecuteProviderMethods, FastExecuteAccountMethods>;
+
+interface RpcProvider extends StarknetIdProviderMethods, BrotherIdProviderMethods, FastExecuteProviderMethods {
+}
 declare class RpcProvider implements ProviderInterface {
     responseParser: RPCResponseParser;
     channel: RpcChannel$2 | RpcChannel$1 | RpcChannel;
@@ -5602,6 +5794,8 @@ declare function verifyMessageInStarknet(provider: ProviderInterface, message: B
 
 declare function getGasPrices(channel: RpcChannel$2 | RpcChannel$1, blockIdentifier?: BlockIdentifier): Promise<GasPrices>;
 
+interface Account extends StarknetIdAccountMethods, BrotherIdProviderMethods, FastExecuteAccountMethods {
+}
 declare class Account implements AccountInterface {
     provider: RpcProvider;
     signer: SignerInterface;
@@ -6236,205 +6430,6 @@ declare class Contract implements ContractInterface {
     static factory(params: FactoryParams, details?: UniversalDetails): Promise<Contract>;
 }
 
-interface StarknetIdProviderMethods {
-    getStarkName(address: BigNumberish, StarknetIdContract?: string): Promise<string>;
-    getAddressFromStarkName(name: string, StarknetIdContract?: string): Promise<string>;
-    getStarkProfile(address: BigNumberish, StarknetIdContract?: string, StarknetIdIdentityContract?: string, StarknetIdVerifierContract?: string, StarknetIdPfpContract?: string, StarknetIdPopContract?: string, StarknetIdMulticallContract?: string): Promise<StarkProfile>;
-}
-interface StarknetIdAccountMethods {
-    getStarkName(address?: BigNumberish, StarknetIdContract?: string): Promise<string>;
-    getAddressFromStarkName(name: string, StarknetIdContract?: string): Promise<string>;
-    getStarkProfile(address: BigNumberish, StarknetIdContract?: string, StarknetIdIdentityContract?: string, StarknetIdVerifierContract?: string, StarknetIdPfpContract?: string, StarknetIdPopContract?: string, StarknetIdMulticallContract?: string): Promise<StarkProfile>;
-}
-declare class StarknetIdImpl {
-    static getStarkName(provider: ProviderInterface, address: BigNumberish, StarknetIdContract?: string): Promise<string>;
-    static getAddressFromStarkName(provider: ProviderInterface, name: string, StarknetIdContract?: string): Promise<string>;
-    static getStarkProfile(provider: ProviderInterface, address: BigNumberish, StarknetIdContract?: string, StarknetIdIdentityContract?: string, StarknetIdVerifierContract?: string, StarknetIdPfpContract?: string, StarknetIdPopContract?: string, StarknetIdMulticallContract?: string): Promise<StarkProfile>;
-}
-
-interface BrotherProfile {
-    name: string;
-    resolver: string;
-    tokenId: string;
-    expiryDate: number;
-    lastTransferTime: number;
-}
-interface BrotherIdProviderMethods {
-    getBrotherName(address: BigNumberish, BrotherIdContract?: string): Promise<string>;
-    getAddressFromBrotherName(name: string, BrotherIdContract?: string): Promise<string>;
-    getBrotherProfile(address: BigNumberish, BrotherIdContract?: string): Promise<BrotherProfile>;
-}
-declare class BrotherIdImpl {
-    static getBrotherName(provider: ProviderInterface, address: BigNumberish, BrotherIdContract?: string): Promise<string>;
-    static getAddressFromBrotherName(provider: ProviderInterface, name: string, BrotherIdContract?: string): Promise<string>;
-    static getBrotherProfile(provider: ProviderInterface, address: BigNumberish, BrotherIdContract?: string): Promise<BrotherProfile>;
-}
-/**
- * BrotherId plugin - adds .brother domain resolution methods.
- *
- * @example
- * ```typescript
- * import { RpcProvider, brotherId } from 'starknet';
- * const provider = new RpcProvider({ plugins: [brotherId()] });
- * const name = await provider.getBrotherName('0x123...');
- * ```
- */
-declare function brotherId(): StarknetPlugin<BrotherIdProviderMethods>;
-
-declare module '../provider/rpc' {
-    interface RpcProvider extends StarknetIdProviderMethods, BrotherIdProviderMethods {
-    }
-}
-declare module '../account/default' {
-    interface Account extends StarknetIdAccountMethods, BrotherIdProviderMethods {
-    }
-}
-
-/**
- * Options for controlling fastWaitForTransaction polling behavior
- */
-type FastWaitForTransactionOptions = {
-    /** Number of retry attempts (default: 50) */
-    retries?: number;
-    /** Milliseconds to wait between retries (default: 500) */
-    retryInterval?: number;
-};
-/**
- * Response from fastExecute() containing transaction result and readiness status
- */
-type FastExecuteResponse = {
-    /** The transaction invoke response with transaction hash */
-    txResult: InvokeFunctionResponse;
-    /** Whether the next transaction can be executed immediately */
-    isReady: boolean;
-};
-/**
- * Provider methods added by the FastExecute plugin
- */
-interface FastExecuteProviderMethods {
-    /**
-     * Wait for transaction confirmation with polling optimization for gaming.
-     *
-     * This method is fast but Events and transaction reports are not yet available.
-     * Useful for gaming activity and rapid-fire transaction scenarios.
-     *
-     * Only available on RPC 0.9 and onwards.
-     *
-     * @param {BigNumberish} txHash - Transaction hash to monitor
-     * @param {string} address - Address of the account (used to track nonce changes)
-     * @param {BigNumberish} initNonce - Initial nonce of the account (before the transaction)
-     * @param {FastWaitForTransactionOptions} [options={retries: 50, retryInterval: 500}] - Polling configuration
-     *        options. `retries` is the number of times to retry (default: 50), `retryInterval` is the time in ms
-     *        between retries (default: 500).
-     * @returns {Promise<boolean>} Returns true if the next transaction is possible (nonce increment detected),
-     *          false if the timeout has been reached, or throws an error in case of provider communication failure
-     *          or transaction reversion.
-     *
-     * @example
-     * ```typescript
-     * const isReady = await provider.fastWaitForTransaction(
-     *   '0x123abc...',
-     *   '0x456def...',
-     *   10,
-     *   { retries: 30, retryInterval: 500 }
-     * );
-     *
-     * if (isReady) {
-     *   // Next transaction can be sent
-     * }
-     * ```
-     */
-    fastWaitForTransaction(txHash: BigNumberish, address: string, initNonce: BigNumberish, options?: FastWaitForTransactionOptions): Promise<boolean>;
-}
-/**
- * Account methods added by the FastExecute plugin
- */
-interface FastExecuteAccountMethods {
-    /**
-     * Execute one or multiple calls through the account contract,
-     * responding as soon as a new transaction is possible with the same account.
-     * Useful for gaming usage where rapid consecutive transactions are needed.
-     *
-     * This method requires the provider to be initialized with `pre_confirmed` blockIdentifier option.
-     * RPC 0.9 minimum.
-     *
-     * In a normal `account.execute()` call followed by `provider.waitForTransaction()`, you have immediate access
-     * to the events and transaction report. Here, we process consecutive transactions faster, but events and
-     * transaction reports are not available immediately.
-     *
-     * As a consequence of the above, do not use contract/account deployment with this method.
-     *
-     * @param {AllowArray<Call>} transactions - Single call or array of calls to execute
-     * @param {UniversalDetails} [transactionsDetail] - Transaction execution options
-     * @param {FastWaitForTransactionOptions} [waitDetail={retries: 50, retryInterval: 500}] - Options to scan the
-     *        network for the next possible transaction. `retries` is the number of times to retry (default: 50),
-     *        `retryInterval` is the time in ms between retries (default: 500).
-     * @returns {Promise<FastExecuteResponse>} Response containing the transaction result and status for the next
-     *          transaction. If `isReady` is true, you can execute the next transaction immediately. If false,
-     *          timeout has been reached before the next transaction was possible.
-     *
-     * @example
-     * ```typescript
-     * const myProvider = new RpcProvider({
-     *   nodeUrl: url,
-     *   blockIdentifier: BlockTag.PRE_CONFIRMED
-     * });
-     * const myAccount = new Account({
-     *   provider: myProvider,
-     *   address: accountAddress0,
-     *   signer: privateKey0
-     * });
-     *
-     * const resp = await myAccount.fastExecute(
-     *   call,
-     *   { tip: recommendedTip },
-     *   { retries: 30, retryInterval: 500 }
-     * );
-     *
-     * // if resp.isReady is true, you can launch immediately a new tx
-     * if (resp.isReady) {
-     *   // send next transaction
-     * }
-     * ```
-     */
-    fastExecute(transactions: any, transactionsDetail?: any, waitDetail?: FastWaitForTransactionOptions): Promise<FastExecuteResponse>;
-}
-
-/**
- * FastExecute plugin - adds gaming-optimized transaction execution
- *
- * Provides fastExecute() on accounts and fastWaitForTransaction() on providers
- * for rapid successive transaction execution with minimal confirmation latency.
- *
- * Requires:
- * - RPC 0.9 or later
- * - Provider initialized with BlockTag.PRE_CONFIRMED
- *
- * @example
- * ```typescript
- * import { RpcProvider, Account } from 'starknet';
- * import { fastExecute } from 'starknet/plugins';
- *
- * const provider = new RpcProvider({
- *   nodeUrl: url,
- *   blockIdentifier: BlockTag.PRE_CONFIRMED,
- * });
- *
- * const account = new Account({ provider, address, signer });
- *
- * const resp = await account.fastExecute(
- *   call,
- *   { tip: recommendedTip },
- *   { retries: 30, retryInterval: 500 }
- * );
- *
- * if (resp.isReady) {
- *   // Next transaction can be sent immediately
- * }
- * ```
- */
-declare function fastExecute(): StarknetPlugin<FastExecuteProviderMethods, FastExecuteAccountMethods>;
-
 /** Default plugins shipped with the SDK */
 declare const defaultPlugins: StarknetPlugin<any, any>[];
 
@@ -9293,6 +9288,7 @@ declare class CairoFixedArray {
      * Cairo fixed array type.
      */
     readonly arrayType: string;
+    private static parseFixedArrayType;
     /**
      * Create an instance representing a Cairo fixed Array.
      * @param {any[]} content JS array representing a Cairo fixed array.

package/dist/index.global.js

@@ -5919,8 +5919,11 @@ ${indent}}` : "}";
   var isLen = (name) => /_len$/.test(name);
   var isTypeFelt = (type) => type === "felt" || type === "core::felt252";
   var isTypeArray = (type) => /\*/.test(type) || type.startsWith("core::array::Array::") || type.startsWith("core::array::Span::");
-  var isTypeTuple = (type) => /^\(.*\)$/i.test(type);
-  var isTypeNamedTuple = (type) => /\(.*\)/i.test(type) && type.includes(":");
+  var isTypeTuple = (type) => type.startsWith("(") && type.endsWith(")");
+  var isTypeNamedTuple = (type) => {
+    const start = type.indexOf("(");
+    return start !== -1 && type.indexOf(")", start + 1) !== -1 && type.includes(":");
+  };
   var isTypeStruct = (type, structs) => type in structs;
   var isTypeEnum = (type, enums) => type in enums;
   var isTypeOption = (type) => type.startsWith("core::option::Option::");
@@ -5936,7 +5939,7 @@ ${indent}}` : "}";
   var isTypeSecp256k1Point = (type) => type === Literal.Secp256k1Point;
   var isCairo1Type = (type) => type.includes("::");
   var getArrayType = (type) => {
-    return isCairo1Type(type) ? type.substring(type.indexOf("<") + 1, type.lastIndexOf(">")) : type.replace("*", "");
+    return isCairo1Type(type) ? type.substring(type.indexOf("<") + 1, type.lastIndexOf(">")) : type.replaceAll("*", "");
   };
   function isCairo1Abi(abi) {
     const { cairo } = getAbiContractVersion(abi);
@@ -7737,6 +7740,18 @@ ${indent}}` : "}";
      * Cairo fixed array type.
      */
     arrayType;
+    static parseFixedArrayType(type) {
+      if (!type.startsWith("[") || !type.endsWith("]")) {
+        return void 0;
+      }
+      const separator = type.lastIndexOf("; ");
+      const itemType = type.slice(1, separator);
+      const size = type.slice(separator + 2, -1);
+      if (separator <= 1 || size.length === 0 || ![...size].every((char) => char >= "0" && char <= "9")) {
+        return void 0;
+      }
+      return { itemType, size };
+    }
     /**
      * Create an instance representing a Cairo fixed Array.
      * @param {any[]} content JS array representing a Cairo fixed array.
@@ -7780,10 +7795,10 @@ ${indent}}` : "}";
      * ```
      */
     static getFixedArraySize(type) {
-      const matchArray = type.match(/(?<=; )\d+(?=\])/);
-      if (matchArray === null)
+      const fixedArrayType = _CairoFixedArray.parseFixedArrayType(type);
+      if (!fixedArrayType)
         throw new Error(`ABI type ${type} do not includes a valid number after ';' character.`);
-      return Number(matchArray[0]);
+      return Number(fixedArrayType.size);
     }
     /**
      * Retrieves the Cairo fixed array size from the CairoFixedArray instance.
@@ -7809,10 +7824,9 @@ ${indent}}` : "}";
      * ```
      */
     static getFixedArrayType = (type) => {
-      const matchArray = type.match(/(?<=\[).+(?=;)/);
-      if (matchArray === null)
-        throw new Error(`ABI type ${type} do not includes a valid type of data.`);
-      return matchArray[0];
+      const fixedArrayType = _CairoFixedArray.parseFixedArrayType(type);
+      if (!fixedArrayType) throw new Error(`ABI type ${type} do not includes a valid type of data.`);
+      return fixedArrayType.itemType;
     };
     /**
      * Retrieve the Cairo content type of the Cairo fixed array.
@@ -7870,7 +7884,7 @@ ${indent}}` : "}";
      * // result = true
      */
     static isTypeFixedArray(type) {
-      return /^\[.*;\s.*\]$/.test(type) && /(?<=\[).+(?=;)/.test(type) && /(?<=; )\d+(?=\])/.test(type);
+      return _CairoFixedArray.parseFixedArrayType(type) !== void 0;
     }
   };
 
@@ -8538,7 +8552,7 @@ ${indent}}` : "}";
             parsedDataArr.push(
               parseResponseValue(
                 responseIterator,
-                { name, type: output.type.replace("*", "") },
+                { name, type: output.type.replaceAll("*", "") },
                 parser,
                 structs,
                 enums
@@ -11263,18 +11277,20 @@ ${indent}}` : "}";
     }
     async fetchEndpoint(method, params) {
       try {
+        let error;
+        let result;
         if (this.batchClient) {
-          const { error: error2, result: result2 } = await this.batchClient.fetch(
-            method,
-            params,
-            this.requestId += 1
-          );
-          this.errorHandler(method, params, error2);
-          return result2;
+          ({ error, result } = await this.batchClient.fetch(method, params, this.requestId += 1));
+        } else {
+          const rawResult = await this.fetch(method, params, this.requestId += 1);
+          ({ error, result } = await rawResult.json());
         }
-        const rawResult = await this.fetch(method, params, this.requestId += 1);
-        const { error, result } = await rawResult.json();
         this.errorHandler(method, params, error);
+        if (result === void 0) {
+          throw new LibraryError(
+            `RPC: '${method}' returned an empty response (no result and no error). The node reply is malformed or not a valid JSON-RPC response.`
+          );
+        }
         return result;
       } catch (error) {
         this.errorHandler(method, params, error?.response?.data, error);
@@ -11902,18 +11918,20 @@ ${indent}}` : "}";
     }
     async fetchEndpoint(method, params) {
       try {
+        let error;
+        let result;
         if (this.batchClient) {
-          const { error: error2, result: result2 } = await this.batchClient.fetch(
-            method,
-            params,
-            this.requestId += 1
-          );
-          this.errorHandler(method, params, error2);
-          return result2;
+          ({ error, result } = await this.batchClient.fetch(method, params, this.requestId += 1));
+        } else {
+          const rawResult = await this.fetch(method, params, this.requestId += 1);
+          ({ error, result } = await rawResult.json());
         }
-        const rawResult = await this.fetch(method, params, this.requestId += 1);
-        const { error, result } = await rawResult.json();
         this.errorHandler(method, params, error);
+        if (result === void 0) {
+          throw new LibraryError(
+            `RPC: '${method}' returned an empty response (no result and no error). The node reply is malformed or not a valid JSON-RPC response.`
+          );
+        }
         return result;
       } catch (error) {
         this.errorHandler(method, params, error?.response?.data, error);
@@ -14229,7 +14247,19 @@ ${indent}}` : "}";
     });
   }
   function isStarkDomain(domain) {
-    return /^(?:[a-z0-9-]{1,48}(?:[a-z0-9-]{1,48}[a-z0-9-])?\.)*[a-z0-9-]{1,48}\.stark$/.test(domain);
+    const starkSuffix = ".stark";
+    if (!domain.endsWith(starkSuffix)) {
+      return false;
+    }
+    const name = domain.slice(0, -starkSuffix.length);
+    if (name.length === 0) {
+      return false;
+    }
+    return name.split(".").every((label) => {
+      return label.length > 0 && label.length <= 48 && [...label].every((char) => {
+        return char >= "a" && char <= "z" || char >= "0" && char <= "9" || char === "-";
+      });
+    });
   }
 
   // src/plugins/starknet-id/index.ts