starknet 10.1.0 → 10.3.0

package/dist/index.mjs

@@ -1851,6 +1851,24 @@ var CairoBytes31 = class _CairoBytes31 {
   }
 };
 
+// src/utils/ec.ts
+var ec_exports = {};
+__export(ec_exports, {
+  starkCurve: () => starkCurve,
+  weierstrass: () => weierstrass
+});
+import * as starkCurve from "@scure/starknet";
+import * as weierstrass from "@noble/curves/abstract/weierstrass";
+
+// src/utils/hash/pedersenCore.ts
+function computePedersenHash(a, b) {
+  return starkCurve.pedersen(BigInt(a), BigInt(b));
+}
+function computeHashOnElements(data) {
+  return [...data, data.length].reduce((x, y) => starkCurve.pedersen(BigInt(x), BigInt(y)), 0).toString();
+}
+var computePedersenHashOnElements = computeHashOnElements;
+
 // src/utils/errors/rpc.ts
 var errorCodes = {
   FAILED_TO_RECEIVE_TXN: 1,
@@ -2145,6 +2163,31 @@ var CairoByteArray = class _CairoByteArray {
     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 computeHashOnElements(serialized);
+  }
   /**
    * returns an array of all the data chunks and the pending word
    * when concatenated, represents the original bytes sequence
@@ -4705,7 +4748,7 @@ __export(hash_exports, {
   computeCompiledClassHashBlake: () => computeCompiledClassHashBlake,
   computeCompiledClassHashPoseidon: () => computeCompiledClassHashPoseidon,
   computeContractClassHash: () => computeContractClassHash,
-  computeHashOnElements: () => computeHashOnElements2,
+  computeHashOnElements: () => computeHashOnElements,
   computeHintedClassHash: () => computeHintedClassHash,
   computeLegacyContractClassHash: () => computeLegacyContractClassHash,
   computePedersenHash: () => computePedersenHash,
@@ -4845,24 +4888,13 @@ __export(v2_exports, {
   calculateL2MessageTxHash: () => calculateL2MessageTxHash,
   calculateTransactionHash: () => calculateTransactionHash,
   calculateTransactionHashCommon: () => calculateTransactionHashCommon2,
-  computeHashOnElements: () => computeHashOnElements
+  computeHashOnElements: () => computeHashOnElements2
 });
-
-// src/utils/ec.ts
-var ec_exports = {};
-__export(ec_exports, {
-  starkCurve: () => starkCurve,
-  weierstrass: () => weierstrass
-});
-import * as starkCurve from "@scure/starknet";
-import * as weierstrass from "@noble/curves/abstract/weierstrass";
-
-// src/utils/hash/transactionHash/v2.ts
-function computeHashOnElements(data) {
+function computeHashOnElements2(data) {
   return [...data, data.length].reduce((x, y) => starkCurve.pedersen(toBigInt(x), toBigInt(y)), 0).toString();
 }
 function calculateTransactionHashCommon2(txHashPrefix, version, contractAddress, entryPointSelector, calldata, maxFee, chainId, additionalData = []) {
-  const calldataHash = computeHashOnElements(calldata);
+  const calldataHash = computeHashOnElements2(calldata);
   const dataToHash = [
     txHashPrefix,
     version,
@@ -4873,7 +4905,7 @@ function calculateTransactionHashCommon2(txHashPrefix, version, contractAddress,
     chainId,
     ...additionalData
   ];
-  return computeHashOnElements(dataToHash);
+  return computeHashOnElements2(dataToHash);
 }
 function calculateDeclareTransactionHash2(classHash, senderAddress, version, maxFee, chainId, nonce, compiledClassHash) {
   return calculateTransactionHashCommon2(
@@ -5032,18 +5064,11 @@ function flattenEntryPointData(data, encodedBuiltinsArray) {
 }
 
 // src/utils/hash/classHash/pedersen.ts
-function computePedersenHash(a, b) {
-  return starkCurve.pedersen(BigInt(a), BigInt(b));
-}
-function computeHashOnElements2(data) {
-  return [...data, data.length].reduce((x, y) => starkCurve.pedersen(BigInt(x), BigInt(y)), 0).toString();
-}
-var computePedersenHashOnElements = computeHashOnElements2;
 function calculateContractAddressFromHash(salt, classHash, constructorCalldata, deployerAddress) {
   const compiledCalldata = CallData.compile(constructorCalldata);
-  const constructorCalldataHash = computeHashOnElements2(compiledCalldata);
+  const constructorCalldataHash = computeHashOnElements(compiledCalldata);
   const CONTRACT_ADDRESS_PREFIX = felt("0x535441524b4e45545f434f4e54524143545f41444452455353");
-  const hash = computeHashOnElements2([
+  const hash = computeHashOnElements([
     CONTRACT_ADDRESS_PREFIX,
     deployerAddress,
     salt,
@@ -5061,21 +5086,21 @@ function computeHintedClassHash(compiledContract) {
 function computeLegacyContractClassHash(contract) {
   const compiledContract = isString(contract) ? parse2(contract) : contract;
   const apiVersion = toHex(API_VERSION);
-  const externalEntryPointsHash = computeHashOnElements2(
+  const externalEntryPointsHash = computeHashOnElements(
     compiledContract.entry_points_by_type.EXTERNAL.flatMap((e) => [e.selector, e.offset])
   );
-  const l1HandlerEntryPointsHash = computeHashOnElements2(
+  const l1HandlerEntryPointsHash = computeHashOnElements(
     compiledContract.entry_points_by_type.L1_HANDLER.flatMap((e) => [e.selector, e.offset])
   );
-  const constructorEntryPointHash = computeHashOnElements2(
+  const constructorEntryPointHash = computeHashOnElements(
     compiledContract.entry_points_by_type.CONSTRUCTOR.flatMap((e) => [e.selector, e.offset])
   );
-  const builtinsHash = computeHashOnElements2(
+  const builtinsHash = computeHashOnElements(
     compiledContract.program.builtins.map((s) => encodeShortString(s))
   );
   const hintedClassHash = computeHintedClassHash(compiledContract);
-  const dataHash = computeHashOnElements2(compiledContract.program.data);
-  return computeHashOnElements2([
+  const dataHash = computeHashOnElements(compiledContract.program.data);
+  return computeHashOnElements([
     apiVersion,
     externalEntryPointsHash,
     l1HandlerEntryPointsHash,
@@ -6418,6 +6443,12 @@ var RpcChannel = class {
     });
     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(
       {
@@ -7027,6 +7058,12 @@ var RpcChannel2 = class {
     });
     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(
       {
@@ -9717,6 +9754,34 @@ var RpcProvider = class {
   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);
   }
@@ -11599,7 +11664,12 @@ var Account = class {
       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
@@ -11624,7 +11694,15 @@ var Account = class {
         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,
@@ -11646,6 +11724,51 @@ var Account = class {
     });
     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: api_exports.ETransactionType.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 ''.