starknet 8.3.1 → 8.4.0

package/dist/index.js

@@ -6716,6 +6716,48 @@ var RpcChannel2 = class {
     }
     return txReceipt;
   }
+  async fastWaitForTransaction(txHash, address, initNonceBN, options) {
+    const initNonce = BigInt(initNonceBN);
+    let retries = options?.retries ?? 50;
+    const retryInterval = options?.retryInterval ?? 500;
+    const errorStates = [RPCSPEC09.ETransactionExecutionStatus.REVERTED];
+    const successStates = [
+      RPCSPEC09.ETransactionFinalityStatus.ACCEPTED_ON_L2,
+      RPCSPEC09.ETransactionFinalityStatus.ACCEPTED_ON_L1,
+      RPCSPEC09.ETransactionFinalityStatus.PRE_CONFIRMED
+    ];
+    let txStatus;
+    const start = (/* @__PURE__ */ new Date()).getTime();
+    while (retries > 0) {
+      await wait(retryInterval);
+      txStatus = await this.getTransactionStatus(txHash);
+      logger.info(
+        `${retries} ${JSON.stringify(txStatus)} ${((/* @__PURE__ */ new Date()).getTime() - start) / 1e3}s.`
+      );
+      const executionStatus = txStatus.execution_status ?? "";
+      const finalityStatus = txStatus.finality_status;
+      if (errorStates.includes(executionStatus)) {
+        const message = `${executionStatus}: ${finalityStatus}`;
+        const error = new Error(message);
+        error.response = txStatus;
+        throw error;
+      } else if (successStates.includes(finalityStatus)) {
+        let currentNonce = initNonce;
+        while (currentNonce === initNonce && retries > 0) {
+          currentNonce = BigInt(await this.getNonceForAddress(address, BlockTag.PRE_CONFIRMED));
+          logger.info(
+            `${retries} Checking new nonce ${currentNonce} ${((/* @__PURE__ */ new Date()).getTime() - start) / 1e3}s.`
+          );
+          if (currentNonce !== initNonce) return true;
+          await wait(retryInterval);
+          retries -= 1;
+        }
+        return false;
+      }
+      retries -= 1;
+    }
+    return false;
+  }
   getStorageAt(contractAddress, key, blockIdentifier = this.blockIdentifier) {
     const contract_address = toHex(contractAddress);
     const parsedKey = toStorageKey(key);
@@ -8563,6 +8605,31 @@ var RpcProvider = class {
     );
     return createTransactionReceipt(receiptWoHelper);
   }
+  /**
+   * Wait up until a new transaction is possible with same the account.
+   * This method is fast, but Events and transaction report are not yet
+   * available. Useful for gaming activity.
+   * - only rpc 0.9 and onwards.
+   * @param {BigNumberish} txHash - transaction hash
+   * @param {string} address - address of the account
+   * @param {BigNumberish} initNonce - initial nonce of the account (before the transaction).
+   * @param {fastWaitForTransactionOptions} [options={retries: 50, retryInterval: 500}] - options to scan the network for the next possible transaction. `retries` is the number of times to retry.
+   * @returns {Promise<boolean>} Returns true if the next transaction is possible,
+   * false if the timeout has been reached,
+   * throw an error in case of provider communication.
+   */
+  async fastWaitForTransaction(txHash, address, initNonce, options) {
+    if (this.channel instanceof rpc_0_9_0_exports.RpcChannel) {
+      const isSuccess = await this.channel.fastWaitForTransaction(
+        txHash,
+        address,
+        initNonce,
+        options
+      );
+      return isSuccess;
+    }
+    throw new Error("Unsupported channel type");
+  }
   async getStorageAt(contractAddress, key, blockIdentifier) {
     return this.channel.getStorageAt(contractAddress, key, blockIdentifier);
   }
@@ -10970,6 +11037,50 @@ var Account = class extends RpcProvider2 {
       }
     );
   }
+  /**
+   * 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.
+   * - This method requires the provider to be initialized with `pre_confirmed` blockIdentifier option.
+   * - Rpc 0.9 minimum.
+   * - In a normal myAccount.execute() call, followed by myProvider.waitForTransaction(), you have an immediate access to the events and to the transaction report. Here, we are processing consecutive transactions faster, but events & transaction reports are not available immediately.
+   * - As a consequence of the previous point, 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, `retryInterval` is the time in ms between retries.
+   * @returns {Promise<fastExecuteResponse>} Response containing the transaction result and status for the next transaction. If `isReady` is true, you can execute the next transaction. 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.
+   * ```
+   */
+  async fastExecute(transactions, transactionsDetail = {}, waitDetail = {}) {
+    assert(
+      this.channel instanceof rpc_0_9_0_exports.RpcChannel,
+      "Wrong Rpc version in Provider. At least Rpc v0.9 required."
+    );
+    assert(
+      this.channel.blockIdentifier === BlockTag.PRE_CONFIRMED,
+      "Provider needs to be initialized with `pre_confirmed` blockIdentifier option."
+    );
+    const initNonce = BigInt(
+      transactionsDetail.nonce ?? await this.getNonceForAddress(this.address, BlockTag.PRE_CONFIRMED)
+    );
+    const details = { ...transactionsDetail, nonce: initNonce };
+    const resultTx = await this.execute(transactions, details);
+    const resultWait = await this.fastWaitForTransaction(
+      resultTx.transaction_hash,
+      this.address,
+      initNonce,
+      waitDetail
+    );
+    return { txResult: resultTx, isReady: resultWait };
+  }
   /**
    * First check if contract is already declared, if not declare it
    * If contract already declared returned transaction_hash is ''.