thirdweb 5.105.45 → 5.105.47

package/src/react/core/hooks/useStepExecutor.ts

@@ -38,7 +38,7 @@ interface StepExecutorOptions {
   /** Prepared quote returned by Bridge.prepare */
   request: BridgePrepareRequest;
   /** Wallet instance providing getAccount() & sendTransaction */
-  wallet: Wallet;
+  wallet?: Wallet;
   /** Window adapter for opening on-ramp URLs (web / RN) */
   windowAdapter: WindowAdapter;
   /** Thirdweb client for API calls */
@@ -408,6 +408,14 @@ export function useStepExecutor(
     abortControllerRef.current = abortController;
 
     try {
+      if (flatTxs.length > 0 && !wallet) {
+        throw new ApiError({
+          code: "INVALID_INPUT",
+          message: "No wallet provided to execute transactions",
+          statusCode: 400,
+        });
+      }
+
       // Execute onramp first if configured and not already completed
       if (preparedQuote.type === "onramp" && onrampStatus === "pending") {
         await executeOnramp(
@@ -417,89 +425,98 @@ export function useStepExecutor(
         );
       }
 
-      // Then execute transactions
-      const account = wallet.getAccount();
-      if (!account) {
-        throw new ApiError({
-          code: "INVALID_INPUT",
-          message: "Wallet not connected",
-          statusCode: 400,
-        });
-      }
-
-      // Start from where we left off, or from the beginning
-      const startIndex = currentTxIndex ?? 0;
-
-      for (let i = startIndex; i < flatTxs.length; i++) {
-        if (abortController.signal.aborted) {
-          break;
+      if (flatTxs.length > 0) {
+        // Then execute transactions
+        if (!wallet) {
+          throw new ApiError({
+            code: "INVALID_INPUT",
+            message: "No wallet provided to execute transactions",
+            statusCode: 400,
+          });
         }
-
-        const currentTx = flatTxs[i];
-        if (!currentTx) {
-          continue; // Skip invalid index
+        const account = wallet.getAccount();
+        if (!account) {
+          throw new ApiError({
+            code: "INVALID_INPUT",
+            message: "Wallet not connected",
+            statusCode: 400,
+          });
         }
 
-        setCurrentTxIndex(i);
-        const currentStepData = preparedQuote.steps[currentTx._stepIndex];
-        if (!currentStepData) {
-          throw new Error(`Invalid step index: ${currentTx._stepIndex}`);
-        }
+        // Start from where we left off, or from the beginning
+        const startIndex = currentTxIndex ?? 0;
 
-        // switch chain if needed
-        if (currentTx.chainId !== wallet.getChain()?.id) {
-          await wallet.switchChain(getCachedChain(currentTx.chainId));
-        }
+        for (let i = startIndex; i < flatTxs.length; i++) {
+          if (abortController.signal.aborted) {
+            break;
+          }
 
-        // Check if we can batch transactions
-        const canBatch =
-          account.sendBatchTransaction !== undefined && i < flatTxs.length - 1; // Not the last transaction
-
-        if (canBatch) {
-          // Find consecutive transactions on the same chain
-          const batchTxs: FlattenedTx[] = [currentTx];
-          let j = i + 1;
-          while (j < flatTxs.length) {
-            const nextTx = flatTxs[j];
-            if (!nextTx || nextTx.chainId !== currentTx.chainId) {
-              break;
-            }
-            batchTxs.push(nextTx);
-            j++;
+          const currentTx = flatTxs[i];
+          if (!currentTx) {
+            continue; // Skip invalid index
+          }
+
+          setCurrentTxIndex(i);
+          const currentStepData = preparedQuote.steps[currentTx._stepIndex];
+          if (!currentStepData) {
+            throw new Error(`Invalid step index: ${currentTx._stepIndex}`);
+          }
+
+          // switch chain if needed
+          if (currentTx.chainId !== wallet.getChain()?.id) {
+            await wallet.switchChain(getCachedChain(currentTx.chainId));
           }
 
-          // Execute batch if we have multiple transactions
-          if (batchTxs.length > 1) {
-            await executeBatch(
-              batchTxs,
-              account,
-              completedStatusResults,
-              abortController.signal,
-            );
-
-            // Mark all batched transactions as completed
-            for (const tx of batchTxs) {
-              setCompletedTxs((prev) => new Set(prev).add(tx._index));
+          // Check if we can batch transactions
+          const canBatch =
+            account.sendBatchTransaction !== undefined &&
+            i < flatTxs.length - 1; // Not the last transaction
+
+          if (canBatch) {
+            // Find consecutive transactions on the same chain
+            const batchTxs: FlattenedTx[] = [currentTx];
+            let j = i + 1;
+            while (j < flatTxs.length) {
+              const nextTx = flatTxs[j];
+              if (!nextTx || nextTx.chainId !== currentTx.chainId) {
+                break;
+              }
+              batchTxs.push(nextTx);
+              j++;
             }
 
-            // Skip ahead
-            i = j - 1;
-            continue;
+            // Execute batch if we have multiple transactions
+            if (batchTxs.length > 1) {
+              await executeBatch(
+                batchTxs,
+                account,
+                completedStatusResults,
+                abortController.signal,
+              );
+
+              // Mark all batched transactions as completed
+              for (const tx of batchTxs) {
+                setCompletedTxs((prev) => new Set(prev).add(tx._index));
+              }
+
+              // Skip ahead
+              i = j - 1;
+              continue;
+            }
           }
-        }
 
-        // Execute single transaction
-        await executeSingleTx(
-          currentTx,
-          account,
-          completedStatusResults,
-          abortController.signal,
-        );
+          // Execute single transaction
+          await executeSingleTx(
+            currentTx,
+            account,
+            completedStatusResults,
+            abortController.signal,
+          );
 
-        // Mark transaction as completed
-        setCompletedTxs((prev) => new Set(prev).add(currentTx._index));
+          // Mark transaction as completed
+          setCompletedTxs((prev) => new Set(prev).add(currentTx._index));
+        }
       }
-
       // All done - check if we actually completed everything
       if (!abortController.signal.aborted) {
         setCurrentTxIndex(undefined);

package/src/react/core/machines/paymentMachine.ts

@@ -29,7 +29,7 @@ export type PaymentMethod =
     }
   | {
       type: "fiat";
-      payerWallet: Wallet;
+      payerWallet?: Wallet;
       currency: string;
       onramp: "stripe" | "coinbase" | "transak";
     };

package/src/react/web/ui/Bridge/BridgeOrchestrator.tsx

@@ -369,8 +369,7 @@ export function BridgeOrchestrator({
 
       {state.value === "execute" &&
         state.context.quote &&
-        state.context.request &&
-        state.context.selectedPaymentMethod?.payerWallet && (
+        state.context.request && (
           <StepRunner
             autoStart={true}
             client={client}

package/src/react/web/ui/Bridge/BuyWidget.tsx

@@ -193,6 +193,11 @@ export type BuyWidgetProps = {
    * Custom label for the main action button.
    */
   buttonLabel?: string;
+
+  /**
+   * The receiver address for the purchased funds.
+   */
+  receiverAddress?: Address;
 };
 
 // Enhanced UIOptions to handle unsupported token state
@@ -455,7 +460,7 @@ export function BuyWidget(props: BuyWidgetProps) {
         paymentMethods={props.paymentMethods}
         presetOptions={props.presetOptions}
         purchaseData={props.purchaseData}
-        receiverAddress={undefined}
+        receiverAddress={props.receiverAddress}
         uiOptions={bridgeDataQuery.data.data}
         showThirdwebBranding={props.showThirdwebBranding}
       />

package/src/react/web/ui/Bridge/QuoteLoader.tsx

@@ -133,6 +133,7 @@ export function QuoteLoader({
         toChainId: destinationToken.chainId,
         toToken: destinationToken.address,
       });
+      return true;
     },
     queryKey: ["loading_quote", paymentMethod.type],
   });

package/src/react/web/ui/Bridge/StepRunner.tsx

@@ -30,7 +30,7 @@ interface StepRunnerProps {
   /**
    * Wallet instance for executing transactions
    */
-  wallet: Wallet;
+  wallet?: Wallet;
 
   /**
    * Thirdweb client for API calls

package/src/react/web/ui/Bridge/payment-details/PaymentDetails.tsx

@@ -101,6 +101,7 @@ export function PaymentDetails({
               : preparedQuote.intent.destinationTokenAddress,
         });
       }
+      return true;
     },
     queryKey: ["payment_details", preparedQuote.type],
   });
@@ -239,7 +240,7 @@ export function PaymentDetails({
               receiver={preparedQuote.intent.receiver}
               sender={
                 preparedQuote.intent.sender ||
-                paymentMethod.payerWallet.getAccount()?.address
+                paymentMethod.payerWallet?.getAccount()?.address
               }
               toAmount={displayData.destinationAmount}
               toToken={displayData.destinationToken}

package/src/react/web/ui/Bridge/payment-selection/PaymentSelection.tsx

@@ -196,15 +196,17 @@ export function PaymentSelection({
   const handleOnrampProviderSelected = (
     provider: "coinbase" | "stripe" | "transak",
   ) => {
-    if (!payerWallet) {
-      onError(new Error("No wallet available for fiat payment"));
+    const recipientAddress =
+      receiverAddress || payerWallet?.getAccount()?.address;
+    if (!recipientAddress) {
+      onError(new Error("No recipient address available for fiat payment"));
       return;
     }
 
     const fiatPaymentMethod: PaymentMethod = {
-      currency: "USD",
+      currency: currency || "USD",
       onramp: provider,
-      payerWallet, // Default to USD for now
+      payerWallet,
       type: "fiat",
     };
     handlePaymentMethodSelected(fiatPaymentMethod);
@@ -307,7 +309,9 @@ export function PaymentSelection({
             country={country}
             client={client}
             onProviderSelected={handleOnrampProviderSelected}
-            toAddress={receiverAddress || ""}
+            toAddress={
+              receiverAddress || payerWallet?.getAccount()?.address || ""
+            }
             toAmount={destinationAmount}
             toChainId={destinationToken.chainId}
             toTokenAddress={destinationToken.address}

package/src/react/web/ui/ConnectWallet/screens/Buy/swap/FiatValue.tsx

@@ -36,6 +36,7 @@ export function FiatValue(
       props.chain.id,
       getTokenAddress(props.token),
       deferredTokenAmount,
+      props.currency,
     ],
   });
 

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.105.45";
+export const version = "5.105.47";

package/src/wallets/create-wallet.ts

@@ -483,6 +483,8 @@ export function createWallet<const ID extends WalletId>(
         id,
         subscribe: emitter.subscribe,
         switchChain: async (c) => {
+          // TODO: this should actually throw an error if the chain switch fails
+          // but our useSwitchActiveWalletChain hook currently doesn't handle this
           try {
             await handleSwitchChain(c);
             chain = c;

package/src/wallets/in-app/core/authentication/siwe.ts

@@ -1,6 +1,6 @@
 import { signLoginPayload } from "../../../../auth/core/sign-login-payload.js";
 import type { LoginPayload } from "../../../../auth/core/types.js";
-import type { Chain } from "../../../../chains/types.js";
+import { getCachedChain } from "../../../../chains/utils.js";
 import type { ThirdwebClient } from "../../../../client/client.js";
 import { getClientFetch } from "../../../../utils/fetch.js";
 import { stringify } from "../../../../utils/json.js";
@@ -14,14 +14,14 @@ import type { AuthStoredTokenWithCookieReturnType } from "./types.js";
  */
 export async function siweAuthenticate(args: {
   wallet: Wallet;
-  chain: Chain;
   client: ThirdwebClient;
   ecosystem?: Ecosystem;
 }): Promise<AuthStoredTokenWithCookieReturnType> {
-  const { wallet, chain, client, ecosystem } = args;
+  const { wallet, client, ecosystem } = args;
+  const siweChain = getCachedChain(1); // always use mainnet for SIWE for wide wallet compatibility
   // only connect if the wallet doesn't already have an account
   const account =
-    wallet.getAccount() || (await wallet.connect({ chain, client }));
+    wallet.getAccount() || (await wallet.connect({ chain: siweChain, client }));
   const clientFetch = getClientFetch(client, ecosystem);
 
   const payload = await (async () => {
@@ -31,7 +31,7 @@ export async function siweAuthenticate(args: {
       ecosystem: args.ecosystem,
     });
     const res = await clientFetch(
-      `${path}&address=${account.address}&chainId=${chain.id}`,
+      `${path}&address=${account.address}&chainId=${siweChain.id}`,
     );
 
     if (!res.ok) throw new Error("Failed to generate SIWE login payload");

package/src/wallets/in-app/native/native-connector.ts

@@ -183,7 +183,6 @@ export class InAppNativeConnector implements InAppConnector {
           "../core/authentication/siwe.js"
         );
         return siweAuthenticate({
-          chain: params.chain,
           client: this.client,
           ecosystem: params.ecosystem,
           wallet: params.wallet,

package/src/wallets/in-app/web/lib/web-connector.test.ts

@@ -104,7 +104,6 @@ describe("InAppWebConnector.connect", () => {
     });
 
     expect(siweAuthenticate).toHaveBeenCalledWith({
-      chain: ethereum,
       client: TEST_CLIENT,
       ecosystem: undefined,
       wallet: mockWallet,

package/src/wallets/in-app/web/lib/web-connector.ts

@@ -365,7 +365,6 @@ export class InAppWebConnector implements InAppConnector {
       }
       case "wallet": {
         return siweAuthenticate({
-          chain: args.chain,
           client: this.client,
           ecosystem: this.ecosystem,
           wallet: args.wallet,

package/src/wallets/wallet-connect/controller.ts

@@ -132,7 +132,7 @@ export async function connectWC(
     ...(wcOptions?.pairingTopic
       ? { pairingTopic: wcOptions?.pairingTopic }
       : {}),
-    namespaces: {
+    optionalNamespaces: {
       [NAMESPACE]: {
         chains: chainsToRequest,
         events: ["chainChanged", "accountsChanged"],
@@ -157,14 +157,8 @@ export async function connectWC(
   );
   const currentChainId = chainsToRequest[0]?.split(":")[1] || 1;
   const providerChainId = normalizeChainId(currentChainId);
-  const accounts: string[] = await provider.request(
-    {
-      method: "eth_requestAccounts",
-      params: [],
-    },
-    `eip155:${providerChainId}`,
-  );
-  const address = accounts[0];
+  const account = firstAccountOn(provider.session, `eip155:1`); // grab the address from mainnet
+  const address = account;
   if (!address) {
     throw new Error("No accounts found on provider.");
   }
@@ -202,6 +196,109 @@ export async function connectWC(
   );
 }
 
+async function ensureTargetChain(
+  provider: Awaited<ReturnType<typeof initProvider>>,
+  chain: Chain,
+  walletInfo: WalletInfo,
+) {
+  if (!provider.session) {
+    throw new Error("No session found on provider.");
+  }
+  const TARGET_CAIP = `eip155:${chain.id}`;
+  const TARGET_HEX = numberToHex(chain.id);
+
+  // Fast path: already enabled
+  if (hasChainEnabled(provider.session, TARGET_CAIP)) {
+    provider.setDefaultChain(TARGET_CAIP);
+    return;
+  }
+
+  // 1) Try switch
+  try {
+    await requestAndOpenWallet({
+      provider,
+      payload: {
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId: TARGET_HEX }],
+      },
+      chain: TARGET_CAIP, // route to target
+      walletInfo,
+    });
+    provider.setDefaultChain(TARGET_CAIP);
+    return;
+  } catch (err: any) {
+    const code = err?.code ?? err?.data?.originalError?.code;
+    // 4001 user rejected; stop
+    if (code === 4001) throw new Error("User rejected chain switch");
+    // fall through on 4902 or unknown -> try add
+  }
+
+  // 2) Add the chain via any chain we already have
+  const routeChain = anyRoutableChain(provider.session);
+  if (!routeChain)
+    throw new Error("No routable chain to send wallet_addEthereumChain");
+
+  try {
+    await requestAndOpenWallet({
+      provider,
+      payload: {
+        method: "wallet_addEthereumChain",
+        params: [
+          {
+            chainId: TARGET_HEX,
+            chainName: chain.name,
+            nativeCurrency: chain.nativeCurrency,
+            rpcUrls: [chain.rpc],
+            blockExplorerUrls: [chain.blockExplorers?.[0]?.url ?? ""],
+          },
+        ],
+      },
+      chain: routeChain, // route via known-good chain, not the target
+      walletInfo,
+    });
+  } catch (err: any) {
+    const code = err?.code ?? err?.data?.originalError?.code;
+    if (code === 4001) throw new Error("User rejected add chain");
+    throw new Error(`Add chain failed: ${err?.message || String(err)}`);
+  }
+
+  // 3) Re-try switch after add
+  await requestAndOpenWallet({
+    provider,
+    payload: {
+      method: "wallet_switchEthereumChain",
+      params: [{ chainId: TARGET_HEX }],
+    },
+    chain: TARGET_CAIP,
+    walletInfo,
+  });
+  provider.setDefaultChain(TARGET_CAIP);
+
+  // 4) Verify enablement
+  if (!hasChainEnabled(provider.session, TARGET_CAIP)) {
+    throw new Error("Target chain still not enabled by wallet");
+  }
+}
+
+type WCSession = Awaited<ReturnType<typeof UniversalProvider.init>>["session"];
+
+function getNS(session: WCSession) {
+  return session?.namespaces?.eip155;
+}
+function hasChainEnabled(session: WCSession, caip: string) {
+  const ns = getNS(session);
+  return !!ns?.accounts?.some((a) => a.startsWith(`${caip}:`));
+}
+function firstAccountOn(session: WCSession, caip: string): string | null {
+  const ns = getNS(session);
+  const hit = ns?.accounts?.find((a) => a.startsWith(`${caip}:`));
+  return hit ? (hit.split(":")[2] ?? null) : null;
+}
+function anyRoutableChain(session: WCSession): string | null {
+  const ns = getNS(session);
+  return ns?.accounts?.[0]?.split(":")?.slice(0, 2)?.join(":") ?? null; // e.g. "eip155:1"
+}
+
 /**
  * Auto connect to already connected wallet connect session.
  * @internal
@@ -545,14 +642,17 @@ function onConnect(
     account,
     chain,
     disconnect,
-    (newChain) => switchChainWC(provider, newChain),
+    (newChain) => switchChainWC(provider, newChain, walletInfo),
   ];
 }
 
-async function switchChainWC(provider: WCProvider, chain: Chain) {
-  const chainId = chain.id;
+async function switchChainWC(
+  provider: WCProvider,
+  chain: Chain,
+  walletInfo: WalletInfo,
+) {
   try {
-    provider.setDefaultChain(`eip155:${chainId}`);
+    await ensureTargetChain(provider, chain, walletInfo);
   } catch (error) {
     const message =
       typeof error === "string" ? error : (error as ProviderRpcError)?.message;
@@ -605,7 +705,10 @@ function getChainsToRequest(options: {
     chainIds.push(chain.id);
   }
 
-  if (!options.chain && optionalChains.length === 0) {
+  // always include mainnet
+  // many wallets only support a handful of chains, but mainnet is always supported
+  // we will add additional chains in switchChain if needed
+  if (!chainIds.includes(1)) {
     rpcMap[1] = getCachedChain(1).rpc;
     chainIds.push(1);
   }