starknet 10.1.0 → 10.3.0

package/dist/index.global.js

@@ -6261,6 +6261,22 @@ ${indent}}` : "}";
     }
   };
 
+  // src/utils/ec.ts
+  var ec_exports = {};
+  __export(ec_exports, {
+    starkCurve: () => esm_exports4,
+    weierstrass: () => weierstrass_exports
+  });
+
+  // src/utils/hash/pedersenCore.ts
+  function computePedersenHash(a, b) {
+    return esm_exports4.pedersen(BigInt(a), BigInt(b));
+  }
+  function computeHashOnElements2(data) {
+    return [...data, data.length].reduce((x, y) => esm_exports4.pedersen(BigInt(x), BigInt(y)), 0).toString();
+  }
+  var computePedersenHashOnElements = computeHashOnElements2;
+
   // src/utils/errors/rpc.ts
   var errorCodes = {
     FAILED_TO_RECEIVE_TXN: 1,
@@ -6555,6 +6571,31 @@ ${indent}}` : "}";
       const allBytes = concatenateArrayBuffer(this.toElements());
       return buffer_default.from(allBytes);
     }
+    /**
+     * Compute the Pedersen hash of this ByteArray, following OpenZeppelin's `hash_byte_array` algorithm.
+     *
+     * Serializes the ByteArray to its felt252 components (data array length, each data chunk,
+     * pending_word, pending_word_len), then chains Pedersen hash over all elements starting
+     * from 0, and finalizes with the total element count.
+     *
+     * @returns {string} hex-string felt252 Pedersen hash of the ByteArray
+     * @example
+     * ```typescript
+     * const ba = new CairoByteArray('Hello');
+     * const result = ba.hash();
+     * // result = 0x15d19ad651ffaf8e90a13938db2081fa3ff01de0712e00cbe69891bace66c51
+     * ```
+     */
+    hash() {
+      this.assertInitialized();
+      const serialized = [
+        addHexPrefix(this.data.length.toString(16)),
+        ...this.data.flatMap((bytes31) => bytes31.toApiRequest()),
+        ...this.pending_word.toApiRequest(),
+        ...this.pending_word_len.toApiRequest()
+      ];
+      return computeHashOnElements2(serialized);
+    }
     /**
      * returns an array of all the data chunks and the pending word
      * when concatenated, represents the original bytes sequence
@@ -9115,7 +9156,7 @@ ${indent}}` : "}";
     computeCompiledClassHashBlake: () => computeCompiledClassHashBlake,
     computeCompiledClassHashPoseidon: () => computeCompiledClassHashPoseidon,
     computeContractClassHash: () => computeContractClassHash,
-    computeHashOnElements: () => computeHashOnElements3,
+    computeHashOnElements: () => computeHashOnElements2,
     computeHintedClassHash: () => computeHintedClassHash,
     computeLegacyContractClassHash: () => computeLegacyContractClassHash,
     computePedersenHash: () => computePedersenHash,
@@ -9253,22 +9294,13 @@ ${indent}}` : "}";
     calculateL2MessageTxHash: () => calculateL2MessageTxHash,
     calculateTransactionHash: () => calculateTransactionHash,
     calculateTransactionHashCommon: () => calculateTransactionHashCommon2,
-    computeHashOnElements: () => computeHashOnElements2
-  });
-
-  // src/utils/ec.ts
-  var ec_exports = {};
-  __export(ec_exports, {
-    starkCurve: () => esm_exports4,
-    weierstrass: () => weierstrass_exports
+    computeHashOnElements: () => computeHashOnElements3
   });
-
-  // src/utils/hash/transactionHash/v2.ts
-  function computeHashOnElements2(data) {
+  function computeHashOnElements3(data) {
     return [...data, data.length].reduce((x, y) => esm_exports4.pedersen(toBigInt(x), toBigInt(y)), 0).toString();
   }
   function calculateTransactionHashCommon2(txHashPrefix, version, contractAddress, entryPointSelector, calldata, maxFee, chainId, additionalData = []) {
-    const calldataHash = computeHashOnElements2(calldata);
+    const calldataHash = computeHashOnElements3(calldata);
     const dataToHash = [
       txHashPrefix,
       version,
@@ -9279,7 +9311,7 @@ ${indent}}` : "}";
       chainId,
       ...additionalData
     ];
-    return computeHashOnElements2(dataToHash);
+    return computeHashOnElements3(dataToHash);
   }
   function calculateDeclareTransactionHash2(classHash, senderAddress, version, maxFee, chainId, nonce, compiledClassHash) {
     return calculateTransactionHashCommon2(
@@ -9438,18 +9470,11 @@ ${indent}}` : "}";
   }
 
   // src/utils/hash/classHash/pedersen.ts
-  function computePedersenHash(a, b) {
-    return esm_exports4.pedersen(BigInt(a), BigInt(b));
-  }
-  function computeHashOnElements3(data) {
-    return [...data, data.length].reduce((x, y) => esm_exports4.pedersen(BigInt(x), BigInt(y)), 0).toString();
-  }
-  var computePedersenHashOnElements = computeHashOnElements3;
   function calculateContractAddressFromHash(salt, classHash, constructorCalldata, deployerAddress) {
     const compiledCalldata = CallData.compile(constructorCalldata);
-    const constructorCalldataHash = computeHashOnElements3(compiledCalldata);
+    const constructorCalldataHash = computeHashOnElements2(compiledCalldata);
     const CONTRACT_ADDRESS_PREFIX = felt("0x535441524b4e45545f434f4e54524143545f41444452455353");
-    const hash = computeHashOnElements3([
+    const hash = computeHashOnElements2([
       CONTRACT_ADDRESS_PREFIX,
       deployerAddress,
       salt,
@@ -9467,21 +9492,21 @@ ${indent}}` : "}";
   function computeLegacyContractClassHash(contract) {
     const compiledContract = isString(contract) ? parse2(contract) : contract;
     const apiVersion = toHex(API_VERSION);
-    const externalEntryPointsHash = computeHashOnElements3(
+    const externalEntryPointsHash = computeHashOnElements2(
       compiledContract.entry_points_by_type.EXTERNAL.flatMap((e) => [e.selector, e.offset])
     );
-    const l1HandlerEntryPointsHash = computeHashOnElements3(
+    const l1HandlerEntryPointsHash = computeHashOnElements2(
       compiledContract.entry_points_by_type.L1_HANDLER.flatMap((e) => [e.selector, e.offset])
     );
-    const constructorEntryPointHash = computeHashOnElements3(
+    const constructorEntryPointHash = computeHashOnElements2(
       compiledContract.entry_points_by_type.CONSTRUCTOR.flatMap((e) => [e.selector, e.offset])
     );
-    const builtinsHash = computeHashOnElements3(
+    const builtinsHash = computeHashOnElements2(
       compiledContract.program.builtins.map((s) => encodeShortString(s))
     );
     const hintedClassHash = computeHintedClassHash(compiledContract);
-    const dataHash = computeHashOnElements3(compiledContract.program.data);
-    return computeHashOnElements3([
+    const dataHash = computeHashOnElements2(compiledContract.program.data);
+    return computeHashOnElements2([
       apiVersion,
       externalEntryPointsHash,
       l1HandlerEntryPointsHash,
@@ -11555,6 +11580,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(
         {
@@ -12248,6 +12279,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(
         {
@@ -14938,6 +14975,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);
     }
@@ -16816,7 +16881,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
@@ -16841,7 +16911,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,
@@ -16863,6 +16941,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 ''.