starknet 10.5.3 → 10.6.1

package/dist/index.js

@@ -7815,11 +7815,12 @@ var WebSocketChannel = class {
     this.websocket.addEventListener("error", this.errorListener);
   }
   _processRequestQueue() {
-    logger.info(`WebSocket: Processing ${this.requestQueue.length} queued requests.`);
-    while (this.requestQueue.length > 0) {
-      const { method, params, resolve, reject } = this.requestQueue.shift();
+    const pending = this.requestQueue;
+    this.requestQueue = [];
+    logger.info(`WebSocket: Processing ${pending.length} queued requests.`);
+    pending.forEach(({ method, params, resolve, reject }) => {
       this.sendReceive(method, params).then(resolve).catch(reject);
-    }
+    });
   }
   async _restoreSubscriptions() {
     const oldSubscriptions = Array.from(this.activeSubscriptions.values());
@@ -12948,6 +12949,27 @@ var WalletAccountV5 = class _WalletAccountV5 extends Account {
   // TODO: MISSING ESTIMATES
 };
 
+// src/wallet/adapterV6.ts
+function toWalletApiCall(call) {
+  return {
+    contract_address: call.contractAddress,
+    entry_point: call.entrypoint,
+    calldata: CallData.toHex(call.calldata)
+  };
+}
+function fromWalletApiCall(call) {
+  return {
+    contractAddress: call.contract_address,
+    entrypoint: call.entry_point,
+    calldata: call.calldata ?? []
+  };
+}
+function toWalletApiActions(actions) {
+  return actions.map(
+    (action) => action.type === "subaccount_invoke" ? { ...action, calls: action.calls.map(toWalletApiCall) } : action
+  );
+}
+
 // src/wallet/connectV6.ts
 var connectV6_exports = {};
 __export(connectV6_exports, {
@@ -12963,6 +12985,7 @@ __export(connectV6_exports, {
   strk20Balances: () => strk20Balances,
   strk20InvokeTransaction: () => strk20InvokeTransaction,
   strk20PrepareInvoke: () => strk20PrepareInvoke,
+  strk20SubaccountCommitment: () => strk20SubaccountCommitment,
   subscribeWalletEvent: () => subscribeWalletEvent2,
   supportedSpecs: () => supportedSpecs3,
   supportedWalletApi: () => supportedWalletApi3,
@@ -13050,6 +13073,12 @@ function strk20InvokeTransaction(walletWSF, actions) {
     params: { actions }
   });
 }
+function strk20SubaccountCommitment(walletWSF, dapp_name, nonce) {
+  return walletWSF.features["starknet:walletApi"].request({
+    type: "wallet_strk20SubaccountCommitment",
+    params: { dapp_name, nonce }
+  });
+}
 
 // src/wallet/accountV6.ts
 var WalletAccountV6 = class _WalletAccountV6 extends WalletAccountV5 {
@@ -13063,22 +13092,100 @@ var WalletAccountV6 = class _WalletAccountV6 extends WalletAccountV5 {
   switchStarknetChain(chainId, silent_mode = false) {
     return switchStarknetChain3(this.v6Provider, chainId, silent_mode);
   }
+  /**
+   * Execute call(s) with an optional STRK20 privacy proof attached. Same signature as
+   * `execute()`, with an extra parameter for the proof provided by `strk20PrepareInvoke()`.
+   * @param {AllowArray<Call>} calls - The call(s) to invoke.
+   * @param {STRK20_PROOF} [proof] - The SNIP-36 zero-knowledge proof to attach.
+   * @returns {Promise<AddInvokeTransactionResult>} The hash of the submitted transaction.
+   * @example
+   * ```typescript
+   * const { proof } = await myWalletAccount.strk20PrepareInvoke(actions);
+   * const result = await myWalletAccount.executeWithProof(myContract.populate('claim'), proof);
+   * // result = { transaction_hash: '0x6f7d...' }
+   * ```
+   */
   executeWithProof(calls, proof) {
-    const txCalls = [].concat(calls).map((it) => ({
-      contract_address: it.contractAddress,
-      entry_point: it.entrypoint,
-      calldata: it.calldata
-    }));
+    const txCalls = [].concat(calls).map(toWalletApiCall);
     return addInvokeTransaction3(this.v6Provider, { calls: txCalls, proof });
   }
+  /**
+   * Get the private balances held by the user inside the STRK20 privacy pool.
+   * @param {Address[]} tokens - The tokens to get the private balance of. An empty array returns every shielded token.
+   * @returns {Promise<STRK20_BALANCE_ENTRY[]>} One entry per token.
+   * @example
+   * ```typescript
+   * const balances = await myWalletAccount.strk20Balances([strkAddress]);
+   * // balances = [{ token: '0x4718...', amount: '0x2386f26fc10000' }]
+   * ```
+   */
   strk20Balances(tokens) {
     return strk20Balances(this.v6Provider, tokens);
   }
-  strk20PrepareInvoke(actions, simulate) {
-    return strk20PrepareInvoke(this.v6Provider, actions, simulate);
+  /**
+   * Build the Starknet call and the SNIP-36 zero-knowledge proof of a STRK20 transaction,
+   * without submitting it : the DAPP submits the returned call itself, and therefore pays
+   * the fee (the wallet adds no fee action in this mode).
+   *
+   * With `simulate` set to true, the wallet skips the expensive proof generation and
+   * returns an empty proof : the call is then NOT submittable on-chain, and is only useful
+   * for fee estimation or UI previews.
+   * @param {STRK20_ACTION[]} actions - The STRK20 actions to perform atomically (min 1).
+   * @param {boolean} [simulate] - True to skip the proof generation.
+   * @returns {Promise<STRK20_CALL_AND_PROOF>} The Starknet.js call to submit, and its proof.
+   * @example
+   * ```typescript
+   * const { call, proof } = await myWalletAccount.strk20PrepareInvoke(actions);
+   * const result = await mySponsorAccount.execute(call, {
+   *   proof: proof.data,
+   *   proofFacts: proof.proof_facts,
+   * });
+   * // result = { transaction_hash: '0x6f7d...' }
+   * ```
+   */
+  async strk20PrepareInvoke(actions, simulate) {
+    const { call, proof } = await strk20PrepareInvoke(
+      this.v6Provider,
+      toWalletApiActions(actions),
+      simulate
+    );
+    return { call: fromWalletApiCall(call), proof };
   }
+  /**
+   * Submit STRK20 actions as a single atomic transaction. The wallet displays an approval
+   * UI, generates the SNIP-36 proof, adds the fee action, and submits — so this call may
+   * take significantly longer than a standard invoke.
+   * @param {STRK20_ACTION[]} actions - The STRK20 actions to perform atomically (min 1).
+   * @returns {Promise<{transaction_hash: string}>} The hash of the submitted transaction.
+   * @example
+   * ```typescript
+   * const result = await myWalletAccount.strk20InvokeTransaction(actions);
+   * // result = { transaction_hash: '0x6f7d...' }
+   * ```
+   */
   strk20InvokeTransaction(actions) {
-    return strk20InvokeTransaction(this.v6Provider, actions);
+    return strk20InvokeTransaction(this.v6Provider, toWalletApiActions(actions));
+  }
+  /**
+   * Compute the commitment of a DAPP STRK20 sub-account. The commitment is computed
+   * locally by the wallet from the user private state ; no transaction is sent.
+   *
+   * When `nonce` is given, the full commitment of this single sub-account is returned.
+   * When `nonce` is omitted, the partial (nonce independent) commitment is returned
+   * instead : it is shared by every sub-account the user derives for this DAPP, so it can
+   * be published once to let a DAPP recognize all the sub-accounts of a user without
+   * learning any individual nonce.
+   * @param {STRK20_DAPP_NAME} dappName - The DAPP that scopes the sub-account(s).
+   * @param {FELT} [nonce] - The sub-account nonce ; each nonce selects a distinct sub-account for this user + DAPP. Omit it to get the partial commitment.
+   * @returns {Promise<FELT>} The sub-account commitment.
+   * @example
+   * ```typescript
+   * const commitment = await myWalletAccount.strk20SubaccountCommitment('myDapp', '0x0');
+   * // commitment = '0x5f2e...'
+   * ```
+   */
+  strk20SubaccountCommitment(dappName, nonce) {
+    return strk20SubaccountCommitment(this.v6Provider, dappName, nonce);
   }
   static async connect(provider, walletProvider, cairoVersion, paymaster, silentMode = false) {
     const { accounts } = await standardConnect2(walletProvider, silentMode);