starknet 10.2.0 → 10.3.0

package/dist/index.global.js

@@ -11580,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(
         {
@@ -12273,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(
         {
@@ -14963,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);
     }
@@ -16841,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
@@ -16866,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,
@@ -16888,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 ''.