starknet 10.2.0 → 10.3.1

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
@@ -11580,6 +11594,12 @@ ${indent}}` : "}";
       });
       return this.waitMode ? this.waitForTransaction((await promise).transaction_hash) : promise;
     }
+    async invokeSignedTx(transaction) {
+      const promise = this.fetchEndpoint("starknet_addInvokeTransaction", {
+        invoke_transaction: transaction
+      });
+      return this.waitMode ? this.waitForTransaction((await promise).transaction_hash) : promise;
+    }
     async declare(declareTransaction, details) {
       const transaction = await this.buildTransaction(
         {
@@ -12273,6 +12293,12 @@ ${indent}}` : "}";
       });
       return this.waitMode ? this.waitForTransaction((await promise).transaction_hash) : promise;
     }
+    async invokeSignedTx(transaction) {
+      const promise = this.fetchEndpoint("starknet_addInvokeTransaction", {
+        invoke_transaction: transaction
+      });
+      return this.waitMode ? this.waitForTransaction((await promise).transaction_hash) : promise;
+    }
     async declare(declareTransaction, details) {
       const transaction = await this.buildTransaction(
         {
@@ -14217,7 +14243,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
@@ -14963,6 +15001,34 @@ ${indent}}` : "}";
     async invokeFunction(functionInvocation, details) {
       return this.channel.invoke(functionInvocation, details);
     }
+    /**
+     * Submit a pre-signed INVOKE_TXN_V3 transaction to the network.
+     *
+     * Broadcasts a transaction previously built and signed by `Account.getSignedTransaction()`.
+     * Fees are already included in the signed transaction and will not be re-estimated.
+     *
+     * @param transaction - A fully signed `RPC.INVOKE_TXN_V3` object, as returned by `Account.getSignedTransaction()`
+     *
+     * @returns The transaction hash if `waitMode` is disabled (default), or the transaction receipt if `waitMode` is enabled.
+     *
+     * @remarks
+     * - The transaction must be signed before calling this method ; use `Account.getSignedTransaction()` to produce it.
+     * - Resubmitting the same signed transaction (same nonce) will be rejected by the network.
+     * - If `waitMode` is enabled on the provider, this method waits for the transaction to be included in a block before returning.
+     *
+     * @example
+     * ```typescript
+     * const signedTx = await account.getSignedTransaction([
+     *   { contractAddress: erc20Address, entrypoint: 'transfer', calldata: [recipient, amount, 0] }
+     * ]);
+     * // inspect or store signedTx, then submit when ready:
+     * const { transaction_hash } = await provider.invokeSignedTx(signedTx);
+     * await provider.waitForTransaction(transaction_hash);
+     * ```
+     */
+    async invokeSignedTx(transaction) {
+      return this.channel.invokeSignedTx(transaction);
+    }
     async declareContract(transaction, details) {
       return this.channel.declare(transaction, details);
     }
@@ -16841,7 +16907,12 @@ ${indent}}` : "}";
         returnInitialReads
       });
     }
-    async execute(transactions, transactionsDetail = {}) {
+    /**
+     * Shared preparation logic for execute() and buildExecute().
+     * Runs hooks, estimates fees, and builds accountInvocations.
+     * @private
+     */
+    async prepareInvoke(transactions, transactionsDetail = {}) {
       const hookResult = this.accountPluginManager.runAccountHook("beforeExecute", {
         calls: transactions,
         details: transactionsDetail
@@ -16866,7 +16937,15 @@ ${indent}}` : "}";
           skipValidate: false
         }
       );
-      const invocation = accountInvocations[0];
+      return {
+        invocation: accountInvocations[0],
+        hookedTransactions,
+        hookedDetails,
+        detailsWithTip
+      };
+    }
+    async execute(transactions, transactionsDetail = {}) {
+      const { invocation, hookedTransactions, hookedDetails, detailsWithTip } = await this.prepareInvoke(transactions, transactionsDetail);
       const result = await this.provider.invokeFunction(
         {
           contractAddress: invocation.contractAddress,
@@ -16888,6 +16967,51 @@ ${indent}}` : "}";
       });
       return result;
     }
+    /**
+     * Build a signed INVOKE_TXN_V3 transaction without submitting it to the network.
+     *
+     * Produces a fully signed transaction object that can be inspected, stored,
+     * or submitted later via `provider.channel.sendTransaction()`.
+     * Main usage is to send a virtual transaction to a proof server.
+     * Fees are estimated automatically if not provided.
+     *
+     * @param transactions - Single call or array of calls to include in the transaction
+     * @param transactionsDetail - Transaction execution options
+     * @returns A fully signed `RPC.INVOKE_TXN_V3` object, ready to broadcast
+     *
+     * @remarks
+     * - Unlike `execute()`, this method does **not** submit the transaction ; the account nonce is unchanged after the call.
+     * - The `afterExecute` plugin hook is intentionally **not** triggered.
+     * - The returned object can be broadcast with `provider.channel.sendTransaction()`.
+     *
+     * @example
+     * ```typescript
+     * const signedTx = await account.getSignedTransaction(
+     *   { contractAddress: erc20Address, entrypoint: 'transfer', calldata: [recipient, amount, 0] }
+     * );
+     * ```
+     */
+    async getSignedTransaction(transactions, transactionsDetail = {}) {
+      const { invocation, hookedDetails, detailsWithTip } = await this.prepareInvoke(
+        transactions,
+        transactionsDetail
+      );
+      return this.provider.channel.buildTransaction(
+        {
+          type: ETransactionType2.INVOKE,
+          contractAddress: invocation.contractAddress,
+          calldata: invocation.calldata,
+          signature: invocation.signature,
+          ...hookedDetails.proofFacts && { proofFacts: hookedDetails.proofFacts },
+          ...hookedDetails.proof && { proof: hookedDetails.proof },
+          ...v3Details(detailsWithTip),
+          resourceBounds: invocation.resourceBounds,
+          nonce: invocation.nonce,
+          version: invocation.version
+        },
+        "transaction"
+      );
+    }
     /**
      * First check if contract is already declared, if not declare it
      * If contract already declared returned transaction_hash is ''.