starknet 8.3.1 → 8.5.0

package/dist/index.mjs

@@ -6546,6 +6546,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);
@@ -8393,6 +8435,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);
   }
@@ -8973,8 +9040,181 @@ var StarknetId = class _StarknetId {
   }
 };
 
+// src/provider/extensions/brotherId.ts
+function isBrotherDomain(domain) {
+  return domain.endsWith(".brother");
+}
+function encodeBrotherDomain(domain) {
+  const brotherName = domain.endsWith(".brother") ? domain.replace(".brother", "") : domain;
+  return useEncoded(brotherName);
+}
+function decodeBrotherDomain(encoded) {
+  const decoded = useDecoded([encoded]);
+  if (decoded.endsWith(".stark")) {
+    return decoded.replace(".stark", ".brother");
+  }
+  return decoded ? `${decoded}.brother` : decoded;
+}
+function getBrotherIdContract(chainId) {
+  switch (chainId) {
+    case _StarknetChainId.SN_MAIN:
+      return "0x0212f1c57700f5a3913dd11efba540196aad4cf67772f7090c62709dd804fa74";
+    default:
+      return "0x0212f1c57700f5a3913dd11efba540196aad4cf67772f7090c62709dd804fa74";
+  }
+}
+var BrotherId = class _BrotherId {
+  /**
+   * Gets the primary Brother domain name for an address
+   * @param address - The address to get the domain for
+   * @param BrotherIdContract - Optional contract address
+   * @returns The domain name with .brother suffix
+   */
+  async getBrotherName(address, BrotherIdContract) {
+    return _BrotherId.getBrotherName(
+      // After Mixin, this is ProviderInterface
+      this,
+      address,
+      BrotherIdContract
+    );
+  }
+  /**
+   * Gets the address associated with a Brother domain name
+   * @param name - The domain name (with or without .brother suffix)
+   * @param BrotherIdContract - Optional contract address
+   * @returns The resolver address for the domain
+   */
+  async getAddressFromBrotherName(name, BrotherIdContract) {
+    return _BrotherId.getAddressFromBrotherName(
+      // After Mixin, this is ProviderInterface
+      this,
+      name,
+      BrotherIdContract
+    );
+  }
+  /**
+   * Gets the complete profile information for a Brother domain
+   * @param address - The address to get the profile for
+   * @param BrotherIdContract - Optional contract address
+   * @returns The complete Brother profile information
+   */
+  async getBrotherProfile(address, BrotherIdContract) {
+    return _BrotherId.getBrotherProfile(
+      // After Mixin, this is ProviderInterface
+      this,
+      address,
+      BrotherIdContract
+    );
+  }
+  /**
+   * Static implementation of getBrotherName
+   * @param provider - The provider interface
+   * @param address - The address to get the domain for
+   * @param BrotherIdContract - Optional contract address
+   * @returns The domain name with .brother suffix
+   */
+  static async getBrotherName(provider, address, BrotherIdContract) {
+    const chainId = await provider.getChainId();
+    const contract = BrotherIdContract ?? getBrotherIdContract(chainId);
+    try {
+      const primaryDomain = await provider.callContract({
+        contractAddress: contract,
+        entrypoint: "getPrimary",
+        calldata: CallData.compile({
+          user: address
+        })
+      });
+      if (!primaryDomain[0] || primaryDomain[0] === "0x0") {
+        throw Error("Brother name not found");
+      }
+      const encodedDomain = BigInt(primaryDomain[0]);
+      return decodeBrotherDomain(encodedDomain);
+    } catch (e) {
+      if (e instanceof Error && e.message === "Brother name not found") {
+        throw e;
+      }
+      throw Error("Could not get brother name");
+    }
+  }
+  /**
+   * Static implementation of getAddressFromBrotherName
+   * @param provider - The provider interface
+   * @param name - The domain name
+   * @param BrotherIdContract - Optional contract address
+   * @returns The resolver address
+   */
+  static async getAddressFromBrotherName(provider, name, BrotherIdContract) {
+    const brotherName = name.endsWith(".brother") ? name : `${name}.brother`;
+    if (!isBrotherDomain(brotherName)) {
+      throw new Error("Invalid domain, must be a valid .brother domain");
+    }
+    const chainId = await provider.getChainId();
+    const contract = BrotherIdContract ?? getBrotherIdContract(chainId);
+    try {
+      const domainDetails = await provider.callContract({
+        contractAddress: contract,
+        entrypoint: "get_details_by_domain",
+        calldata: CallData.compile({
+          domain: encodeBrotherDomain(brotherName)
+        })
+      });
+      if (!domainDetails[0] || domainDetails[1] === "0x0") {
+        throw Error("Could not get address from brother name");
+      }
+      return domainDetails[1];
+    } catch {
+      throw Error("Could not get address from brother name");
+    }
+  }
+  /**
+   * Static implementation of getBrotherProfile
+   * @param provider - The provider interface
+   * @param address - The address to get the profile for
+   * @param BrotherIdContract - Optional contract address
+   * @returns The complete Brother profile
+   */
+  static async getBrotherProfile(provider, address, BrotherIdContract) {
+    const chainId = await provider.getChainId();
+    const contract = BrotherIdContract ?? getBrotherIdContract(chainId);
+    try {
+      const primaryDomain = await provider.callContract({
+        contractAddress: contract,
+        entrypoint: "getPrimary",
+        calldata: CallData.compile({
+          user: address
+        })
+      });
+      if (!primaryDomain[0] || primaryDomain[0] === "0x0") {
+        throw Error("Brother profile not found");
+      }
+      const encodedDomain = BigInt(primaryDomain[0]);
+      const decodedDomain = decodeBrotherDomain(encodedDomain);
+      const domain = decodedDomain.replace(".brother", "");
+      const domainDetails = await provider.callContract({
+        contractAddress: contract,
+        entrypoint: "get_details_by_domain",
+        calldata: CallData.compile({
+          domain: encodeBrotherDomain(domain)
+        })
+      });
+      return {
+        name: domain,
+        resolver: domainDetails[1],
+        tokenId: domainDetails[2],
+        expiryDate: parseInt(domainDetails[3], 16),
+        lastTransferTime: parseInt(domainDetails[4], 16)
+      };
+    } catch (e) {
+      if (e instanceof Error && e.message === "Brother profile not found") {
+        throw e;
+      }
+      throw Error("Could not get brother profile");
+    }
+  }
+};
+
 // src/provider/extensions/default.ts
-var RpcProvider2 = class extends Mixin(RpcProvider, StarknetId) {
+var RpcProvider2 = class extends Mixin(RpcProvider, StarknetId, BrotherId) {
 };
 
 // src/provider/interface.ts
@@ -10800,6 +11040,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 ''.
@@ -12098,7 +12382,10 @@ export {
   BlockStatus,
   BlockTag,
   CairoByteArray,
+  CairoBytes31,
   CairoCustomEnum,
+  CairoFelt,
+  CairoFelt252,
   CairoFixedArray,
   CairoInt128,
   CairoInt16,
@@ -12112,6 +12399,7 @@ export {
   CairoUint128,
   CairoUint16,
   CairoUint256,
+  CairoUint32,
   CairoUint512,
   CairoUint64,
   CairoUint8,