thirdweb 5.105.45-nightly-dc1f7ab2ee820be512776a413f7de362ff6b98ef-20250912000326 → 5.105.46

package/src/extensions/erc721/drops/write/updateMetadata.ts

@@ -1,4 +1,7 @@
-import type { BaseTransactionOptions } from "../../../../transaction/types.js";
+import type {
+  BaseTransactionOptions,
+  WithOverrides,
+} from "../../../../transaction/types.js";
 import type { NFT, NFTInput } from "../../../../utils/nft/parseNft.js";
 import * as BatchBaseURI from "../../__generated__/DropERC721/write/updateBatchBaseURI.js";
 import * as BaseURICount from "../../__generated__/IBatchMintMetadata/read/getBaseURICount.js";
@@ -128,12 +131,13 @@ async function getUpdateMetadataParams(
  * ```
  */
 export function updateMetadata(
-  options: BaseTransactionOptions<UpdateMetadataParams>,
+  options: BaseTransactionOptions<WithOverrides<UpdateMetadataParams>>,
 ) {
   const { contract } = options;
   return BatchBaseURI.updateBatchBaseURI({
     asyncParams: async () => getUpdateMetadataParams(options),
     contract,
+    overrides: options.overrides,
   });
 }
 

package/src/extensions/erc721/read/getNFT.test.ts

@@ -93,7 +93,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("erc721.getNFT", () => {
           "name": "Doodle #1",
           "uri": "ipfs://QmPMc4tcBsMqLRuCQtPmPe84bpSjrC3Ky7t3JWuHXYB4aS/1",
         },
-        "owner": "0x620b70123fB810F6C653DA7644b5dD0b6312e4D8",
+        "owner": null,
         "tokenAddress": "0x8a90cab2b38dba80c64b7734e58ee1db38b8992e",
         "tokenURI": "ipfs://QmPMc4tcBsMqLRuCQtPmPe84bpSjrC3Ky7t3JWuHXYB4aS/1",
         "type": "ERC721",

package/src/extensions/erc721/write/lazyMint.ts

@@ -1,4 +1,7 @@
-import type { BaseTransactionOptions } from "../../../transaction/types.js";
+import type {
+  BaseTransactionOptions,
+  WithOverrides,
+} from "../../../transaction/types.js";
 import {
   getBaseUriFromBatch,
   uploadOrExtractURIs,
@@ -13,9 +16,9 @@ import * as LazyMint from "../__generated__/ILazyMint/write/lazyMint.js";
 /**
  * @extension ERC721
  */
-export type LazyMintParams = {
+export type LazyMintParams = WithOverrides<{
   nfts: (NFTInput | string)[];
-};
+}>;
 
 /**
  * Lazily mints ERC721 tokens.
@@ -66,6 +69,7 @@ export function lazyMint(options: BaseTransactionOptions<LazyMintParams>) {
       } as const;
     },
     contract: options.contract,
+    overrides: options.overrides,
   });
 }
 

package/src/extensions/erc721/write/setSharedMetadata.ts

@@ -1,4 +1,7 @@
-import type { BaseTransactionOptions } from "../../../transaction/types.js";
+import type {
+  BaseTransactionOptions,
+  WithOverrides,
+} from "../../../transaction/types.js";
 import type { NFTInput } from "../../../utils/nft/parseNft.js";
 import { setSharedMetadata as generatedSharedMetadata } from "../__generated__/ISharedMetadata/write/setSharedMetadata.js";
 
@@ -7,9 +10,9 @@ export { isSetSharedMetadataSupported } from "../__generated__/ISharedMetadata/w
 /**
  * @extension ERC721
  */
-export type SetSharedMetadataParams = {
+export type SetSharedMetadataParams = WithOverrides<{
   nft: NFTInput;
-};
+}>;
 
 /**
  * Sets the shared metadata for a OpenEdition contract.
@@ -69,6 +72,7 @@ export function setSharedMetadata(
       };
     },
     contract: options.contract,
+    overrides: options.overrides,
   });
 }
 

package/src/extensions/erc721/write/updateTokenURI.ts

@@ -1,5 +1,8 @@
 import { upload } from "../../../storage/upload.js";
-import type { BaseTransactionOptions } from "../../../transaction/types.js";
+import type {
+  BaseTransactionOptions,
+  WithOverrides,
+} from "../../../transaction/types.js";
 import type { NFTInput } from "../../../utils/nft/parseNft.js";
 import {
   type SetTokenURIParams,
@@ -11,10 +14,10 @@ export { isSetTokenURISupported as isUpdateTokenURISupported } from "../../erc72
 /**
  * @extension ERC721
  */
-export type UpdateTokenURIParams = {
+export type UpdateTokenURIParams = WithOverrides<{
   tokenId: bigint;
   newMetadata: NFTInput;
-};
+}>;
 
 /**
  * This function is an abstracted layer of the [`setTokenURI` extension](https://portal.thirdweb.com/references/typescript/v5/erc721/setTokenURI),
@@ -48,6 +51,7 @@ export function updateTokenURI(
   return setTokenURI({
     asyncParams: async () => getUpdateTokenParams(options),
     contract,
+    overrides: options.overrides,
   });
 }
 

package/src/extensions/erc7702/account/createSessionKey.ts

@@ -1,4 +1,7 @@
-import type { BaseTransactionOptions } from "../../../transaction/types.js";
+import type {
+  BaseTransactionOptions,
+  WithOverrides,
+} from "../../../transaction/types.js";
 import { randomBytesHex } from "../../../utils/random.js";
 import type { Account } from "../../../wallets/interfaces/wallet.js";
 import {
@@ -68,7 +71,7 @@ export type CreateSessionKeyOptions = {
  * @extension ERC7702
  */
 export function createSessionKey(
-  options: BaseTransactionOptions<CreateSessionKeyOptions>,
+  options: BaseTransactionOptions<WithOverrides<CreateSessionKeyOptions>>,
 ) {
   const {
     contract,
@@ -161,6 +164,7 @@ export function createSessionKey(
       return { sessionSpec: req, signature };
     },
     contract,
+    overrides: options.overrides,
   });
 }
 

package/src/react/core/hooks/transaction/useSendTransaction.ts

@@ -154,6 +154,11 @@ export function useSendTransactionCore(args: {
         await switchChain(tx.chain);
         // in smart wallet case, account may change after chain switch
         _account = wallet.getAccount();
+
+        // ensure that the account has switched to the correct chain
+        if (wallet.getChain()?.id !== tx.chain.id) {
+          throw new Error(`Could not switch to chain ${tx.chain.id}`);
+        }
       }
 
       const account = _account;

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.105.45-nightly-dc1f7ab2ee820be512776a413f7de362ff6b98ef-20250912000326";
+export const version = "5.105.46";

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/core/eip7702/minimal-account.ts

@@ -180,36 +180,49 @@ export const create7702MinimalAccount = (args: {
       abi: MinimalAccountAbi,
     });
     // check if account has been delegated already
-    let authorization: SignedAuthorization | undefined;
+    let authorization: SignedAuthorization | undefined =
+      firstTx.authorizationList?.[0];
     const delegationContractAddress = await getDelegationContractAddress({
       client,
       chain,
     });
-    const isMinimalAccount = await is7702MinimalAccount(
-      eoaContract,
-      delegationContractAddress,
-    );
-    if (!isMinimalAccount) {
-      // if not, sign authorization
-      let nonce = firstTx.nonce
-        ? BigInt(firstTx.nonce)
-        : BigInt(
-            await getNonce({
-              client,
-              address: adminAccount.address,
-              chain,
-            }),
-          );
-      nonce += sponsorGas ? 0n : 1n;
-      const auth = await adminAccount.signAuthorization?.({
-        address: getAddress(delegationContractAddress),
-        chainId: firstTx.chainId,
-        nonce,
-      });
-      if (!auth) {
-        throw new Error("Failed to sign authorization");
+    if (
+      authorization &&
+      authorization.address?.toLowerCase() !==
+        delegationContractAddress.toLowerCase()
+    ) {
+      throw new Error(
+        `Authorization address does not match expected delegation contract address. Expected ${delegationContractAddress} but got ${authorization.address}`,
+      );
+    }
+    // if the tx already has an authorization, use it, otherwise sign one
+    if (!authorization) {
+      const isMinimalAccount = await is7702MinimalAccount(
+        eoaContract,
+        delegationContractAddress,
+      );
+      if (!isMinimalAccount) {
+        // if not, sign authorization
+        let nonce = firstTx.nonce
+          ? BigInt(firstTx.nonce)
+          : BigInt(
+              await getNonce({
+                client,
+                address: adminAccount.address,
+                chain,
+              }),
+            );
+        nonce += sponsorGas ? 0n : 1n;
+        const auth = await adminAccount.signAuthorization?.({
+          address: getAddress(delegationContractAddress),
+          chainId: firstTx.chainId,
+          nonce,
+        });
+        if (!auth) {
+          throw new Error("Failed to sign authorization");
+        }
+        authorization = auth;
       }
-      authorization = auth;
     }
     if (sponsorGas) {
       // send transaction from executor, needs signature

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/injected/index.ts

@@ -1,6 +1,7 @@
 import * as ox__Authorization from "ox/Authorization";
-import type { EIP1193Provider } from "viem";
+import * as ox__Signature from "ox/Signature";
 import {
+  type EIP1193Provider,
   getTypesForEIP712Domain,
   type SignTypedDataParameters,
   serializeTypedData,
@@ -188,7 +189,7 @@ function createAccount({
     async sendTransaction(tx: SendTransactionOption) {
       const gasFees = tx.gasPrice
         ? {
-            gasPrice: tx.gasPrice ? numberToHex(tx.gasPrice) : undefined,
+            gasPrice: numberToHex(tx.gasPrice),
           }
         : {
             maxFeePerGas: tx.maxFeePerGas
@@ -201,6 +202,9 @@ function createAccount({
       const params = [
         {
           ...tx,
+          authorizationList: tx.authorizationList
+            ? ox__Authorization.toRpcList(tx.authorizationList)
+            : undefined,
           ...gasFees,
           from: this.address,
           gas: tx.gas ? numberToHex(tx.gas) : undefined,
@@ -269,10 +273,25 @@ function createAccount({
     },
     async signAuthorization(authorization: AuthorizationRequest) {
       const payload = ox__Authorization.getSignPayload(authorization);
-      return await provider.request({
-        method: "eth_sign",
-        params: [getAddress(account.address), payload],
-      });
+      let signature: Hex | undefined;
+      try {
+        signature = await provider.request({
+          method: "eth_sign",
+          params: [getAddress(account.address), payload],
+        });
+      } catch {
+        // fallback to secp256k1_sign, some providers don't support eth_sign
+        signature = await provider.request({
+          // @ts-expect-error - overriding types here
+          method: "secp256k1_sign",
+          params: [payload],
+        });
+      }
+      if (!signature) {
+        throw new Error("Failed to sign authorization");
+      }
+      const parsedSignature = ox__Signature.fromHex(signature as Hex);
+      return { ...authorization, ...parsedSignature };
     },
     async signTypedData(typedData) {
       if (!provider || !account.address) {

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);
   }