thirdweb 5.80.1-nightly-a3f59e50e249d8b4fac765e025fc2cd102093e9c-20250105000328 → 5.81.0

package/src/wallets/in-app/core/wallet/in-app-core.ts

@@ -48,6 +48,7 @@ export function createInAppWallet(args: {
   const emitter = createWalletEmitter<"inApp">();
   let createOptions = _createOptions;
   let account: Account | undefined = undefined;
+  let adminAccount: Account | undefined = undefined; // Admin account if smartAccountOptions were provided with connection
   let chain: Chain | undefined = undefined;
   let client: ThirdwebClient | undefined;
 
@@ -98,15 +99,16 @@ export function createInAppWallet(args: {
         }
       }
 
-      const [connectedAccount, connectedChain] = await autoConnectInAppWallet(
-        options,
-        createOptions,
-        connector,
-      );
+      const {
+        account: connectedAccount,
+        chain: connectedChain,
+        adminAccount: _adminAccount,
+      } = await autoConnectInAppWallet(options, createOptions, connector);
 
       // set the states
       client = options.client;
       account = connectedAccount;
+      adminAccount = _adminAccount;
       chain = connectedChain;
       trackConnect({
         client: options.client,
@@ -151,14 +153,16 @@ export function createInAppWallet(args: {
         }
       }
 
-      const [connectedAccount, connectedChain] = await connectInAppWallet(
-        options,
-        createOptions,
-        connector,
-      );
+      const {
+        account: connectedAccount,
+        chain: connectedChain,
+        adminAccount: _adminAccount,
+      } = await connectInAppWallet(options, createOptions, connector);
+
       // set the states
       client = options.client;
       account = connectedAccount;
+      adminAccount = _adminAccount;
       chain = connectedChain;
       trackConnect({
         client: options.client,
@@ -184,6 +188,7 @@ export function createInAppWallet(args: {
         }
       }
       account = undefined;
+      adminAccount = undefined;
       chain = undefined;
       emitter.emit("disconnect", undefined);
     },
@@ -212,7 +217,11 @@ export function createInAppWallet(args: {
           }
         }
 
-        const [connectedAccount, connectedChain] = await autoConnectInAppWallet(
+        const {
+          account: connectedAccount,
+          chain: connectedChain,
+          adminAccount: _adminAccount,
+        } = await autoConnectInAppWallet(
           {
             chain: newChain,
             client,
@@ -220,6 +229,7 @@ export function createInAppWallet(args: {
           createOptions,
           connector,
         );
+        adminAccount = _adminAccount;
         account = connectedAccount;
         chain = connectedChain;
       } else {
@@ -228,5 +238,6 @@ export function createInAppWallet(args: {
       }
       emitter.emit("chainChanged", newChain);
     },
+    getAdminAccount: () => adminAccount,
   };
 }

package/src/wallets/in-app/core/wallet/index.ts

@@ -37,7 +37,7 @@ export async function connectInAppWallet(
     | CreateWalletArgs<"inApp">[1]
     | CreateWalletArgs<EcosystemWalletId>[1],
   connector: InAppConnector,
-): Promise<[Account, Chain]> {
+): Promise<{ account: Account; chain: Chain; adminAccount?: Account }> {
   if (
     // if auth mode is not specified, the default is popup
     createOptions?.auth?.mode !== "popup" &&
@@ -65,15 +65,16 @@ export async function connectInAppWallet(
     "smartAccount" in createOptions &&
     createOptions?.smartAccount
   ) {
-    return convertToSmartAccount({
+    const [account, chain] = await convertToSmartAccount({
       client: options.client,
       authAccount,
       smartAccountOptions: createOptions.smartAccount,
       chain: options.chain,
     });
+    return { account, chain, adminAccount: authAccount };
   }
 
-  return [authAccount, options.chain || ethereum] as const;
+  return { account: authAccount, chain: options.chain || ethereum } as const;
 }
 
 /**
@@ -87,7 +88,7 @@ export async function autoConnectInAppWallet(
     | CreateWalletArgs<"inApp">[1]
     | CreateWalletArgs<EcosystemWalletId>[1],
   connector: InAppConnector,
-): Promise<[Account, Chain]> {
+): Promise<{ account: Account; chain: Chain; adminAccount?: Account }> {
   if (options.authResult && connector.loginWithAuthToken) {
     await connector.loginWithAuthToken(options.authResult);
   }
@@ -104,15 +105,16 @@ export async function autoConnectInAppWallet(
     "smartAccount" in createOptions &&
     createOptions?.smartAccount
   ) {
-    return convertToSmartAccount({
+    const [account, chain] = await convertToSmartAccount({
       client: options.client,
       authAccount,
       smartAccountOptions: createOptions.smartAccount,
       chain: options.chain,
     });
+    return { account, chain, adminAccount: authAccount };
   }
 
-  return [authAccount, options.chain || ethereum] as const;
+  return { account: authAccount, chain: options.chain || ethereum } as const;
 }
 
 async function convertToSmartAccount(options: {
@@ -121,14 +123,9 @@ async function convertToSmartAccount(options: {
   smartAccountOptions: CreateWalletArgs<"smart">[1];
   chain?: Chain;
 }) {
-  const [{ smartWallet }, { connectSmartWallet }] = await Promise.all([
-    import("../../../smart/smart-wallet.js"),
-    import("../../../smart/index.js"),
-  ]);
+  const { connectSmartAccount } = await import("../../../smart/index.js");
 
-  const sa = smartWallet(options.smartAccountOptions);
-  return connectSmartWallet(
-    sa,
+  return connectSmartAccount(
     {
       client: options.client,
       personalAccount: options.authAccount,

package/src/wallets/in-app/web/lib/get-url-token.test.tsx

@@ -0,0 +1,92 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { getUrlToken } from "./get-url-token.js";
+
+describe("getUrlToken", () => {
+  let originalLocation: Location;
+
+  beforeEach(() => {
+    originalLocation = window.location;
+
+    Object.defineProperty(window, "location", {
+      value: {
+        ...originalLocation,
+        search: "",
+      },
+      writable: true,
+    });
+  });
+
+  afterEach(() => {
+    // Restore the original location object after each test
+    Object.defineProperty(window, "location", {
+      value: originalLocation,
+      writable: true,
+    });
+  });
+
+  it("should return an empty object if not in web context", () => {
+    const originalWindow = window;
+    // biome-ignore lint/suspicious/noExplicitAny: Test
+    (global as any).window = undefined;
+
+    const result = getUrlToken();
+    // biome-ignore lint/suspicious/noExplicitAny: Test
+    (global as any).window = originalWindow;
+
+    expect(result).toEqual({});
+  });
+
+  it("should return an empty object if no parameters are present", () => {
+    const result = getUrlToken();
+    expect(result).toEqual({});
+  });
+
+  it("should parse walletId and authResult correctly", () => {
+    window.location.search =
+      "?walletId=123&authResult=%7B%22token%22%3A%22abc%22%7D";
+
+    const result = getUrlToken();
+
+    expect(result).toEqual({
+      walletId: "123",
+      authResult: { token: "abc" },
+      authProvider: null,
+      authCookie: null,
+    });
+  });
+
+  it("should handle authCookie and update URL correctly", () => {
+    window.location.search = "?walletId=123&authCookie=myCookie";
+
+    const result = getUrlToken();
+
+    expect(result).toEqual({
+      walletId: "123",
+      authResult: undefined,
+      authProvider: null,
+      authCookie: "myCookie",
+    });
+
+    // Check if URL has been updated correctly
+    expect(window.location.search).toBe("?walletId=123&authCookie=myCookie");
+  });
+
+  it("should handle all parameters correctly", () => {
+    window.location.search =
+      "?walletId=123&authResult=%7B%22token%22%3A%22xyz%22%7D&authProvider=provider1&authCookie=myCookie";
+
+    const result = getUrlToken();
+
+    expect(result).toEqual({
+      walletId: "123",
+      authResult: { token: "xyz" },
+      authProvider: "provider1",
+      authCookie: "myCookie",
+    });
+
+    // Check if URL has been updated correctly
+    expect(window.location.search).toBe(
+      "?walletId=123&authResult=%7B%22token%22%3A%22xyz%22%7D&authProvider=provider1&authCookie=myCookie",
+    );
+  });
+});

package/src/wallets/injected/index.ts

@@ -85,7 +85,8 @@ export async function connectEip1193Wallet({
     chain && chain.id === chainId ? chain : getCachedChain(chainId);
 
   // if we want a specific chainId and it is not the same as the provider chainId, trigger switchChain
-  if (chain && chain.id !== chainId) {
+  // we check for undefined chain ID since some chain-specific wallets like Abstract will not send a chain ID on connection
+  if (chain && typeof chain.id !== "undefined" && chain.id !== chainId) {
     await switchChain(provider, chain);
     connectedChain = chain;
   }

package/src/wallets/smart/index.ts

@@ -69,28 +69,26 @@ export function isSmartWallet(
 }
 
 /**
- * We can get the personal account for given smart account but not the other way around - this map gives us the reverse lookup
+ * For in-app wallets, the smart wallet creation is implicit so we track these to be able to retrieve the personal account for a smart account on the wallet API.
+ * Note: We have to go account to account here and NOT wallet to account because the smart wallet itself is never exposed to the in-app wallet, only the account.
  * @internal
  */
-const personalAccountToSmartAccountMap = new WeakMap<
-  Account,
-  Wallet<"smart">
->();
-
-const smartWalletToPersonalAccountMap = new WeakMap<Wallet<"smart">, Account>();
+const adminAccountToSmartAccountMap = new WeakMap<Account, Account>();
+const smartAccountToAdminAccountMap = new WeakMap<Account, Account>();
 
 /**
  * @internal
  */
-export async function connectSmartWallet(
-  wallet: Wallet<"smart">,
+export async function connectSmartAccount(
   connectionOptions: SmartWalletConnectionOptions,
   creationOptions: SmartWalletOptions,
 ): Promise<[Account, Chain]> {
   const { personalAccount, client, chain: connectChain } = connectionOptions;
 
   if (!personalAccount) {
-    throw new Error("Personal wallet does not have an account");
+    throw new Error(
+      "No personal account provided for smart account connection",
+    );
   }
 
   const options = creationOptions;
@@ -177,8 +175,8 @@ export async function connectSmartWallet(
     client,
   });
 
-  personalAccountToSmartAccountMap.set(personalAccount, wallet);
-  smartWalletToPersonalAccountMap.set(wallet, personalAccount);
+  adminAccountToSmartAccountMap.set(personalAccount, account);
+  smartAccountToAdminAccountMap.set(account, personalAccount);
 
   return [account, chain] as const;
 }
@@ -186,15 +184,13 @@ export async function connectSmartWallet(
 /**
  * @internal
  */
-export async function disconnectSmartWallet(
-  wallet: Wallet<"smart">,
-): Promise<void> {
+export async function disconnectSmartAccount(account: Account): Promise<void> {
   // look up the personalAccount for the smart wallet
-  const personalAccount = smartWalletToPersonalAccountMap.get(wallet);
+  const personalAccount = smartAccountToAdminAccountMap.get(account);
   if (personalAccount) {
     // remove the mappings
-    personalAccountToSmartAccountMap.delete(personalAccount);
-    smartWalletToPersonalAccountMap.delete(wallet);
+    adminAccountToSmartAccountMap.delete(personalAccount);
+    smartAccountToAdminAccountMap.delete(account);
   }
 }
 

package/src/wallets/smart/smart-wallet.ts

@@ -137,7 +137,7 @@ export function smartWallet(
   let chain: Chain | undefined = undefined;
   let lastConnectOptions: WalletConnectionOption<"smart"> | undefined;
 
-  const _smartWallet: Wallet<"smart"> = {
+  return {
     id: "smart",
     subscribe: emitter.subscribe,
     getChain() {
@@ -152,9 +152,10 @@ export function smartWallet(
     getAccount: () => account,
     getAdminAccount: () => adminAccount,
     autoConnect: async (options) => {
-      const { connectSmartWallet } = await import("./index.js");
+      const { connectSmartAccount: connectSmartWallet } = await import(
+        "./index.js"
+      );
       const [connectedAccount, connectedChain] = await connectSmartWallet(
-        _smartWallet,
         options,
         createOptions,
       );
@@ -172,9 +173,8 @@ export function smartWallet(
       return account;
     },
     connect: async (options) => {
-      const { connectSmartWallet } = await import("./index.js");
-      const [connectedAccount, connectedChain] = await connectSmartWallet(
-        _smartWallet,
+      const { connectSmartAccount } = await import("./index.js");
+      const [connectedAccount, connectedChain] = await connectSmartAccount(
         options,
         createOptions,
       );
@@ -194,10 +194,13 @@ export function smartWallet(
       return account;
     },
     disconnect: async () => {
+      if (account) {
+        const { disconnectSmartAccount } = await import("./index.js");
+        await disconnectSmartAccount(account);
+      }
       account = undefined;
+      adminAccount = undefined;
       chain = undefined;
-      const { disconnectSmartWallet } = await import("./index.js");
-      await disconnectSmartWallet(_smartWallet);
       emitter.emit("disconnect", undefined);
     },
     switchChain: async (newChain: Chain) => {
@@ -223,9 +226,8 @@ export function smartWallet(
           );
         }
       }
-      const { connectSmartWallet } = await import("./index.js");
-      const [connectedAccount, connectedChain] = await connectSmartWallet(
-        _smartWallet,
+      const { connectSmartAccount } = await import("./index.js");
+      const [connectedAccount, connectedChain] = await connectSmartAccount(
         { ...lastConnectOptions, chain: newChain },
         createOptions,
       );
@@ -235,6 +237,4 @@ export function smartWallet(
       emitter.emit("chainChanged", newChain);
     },
   };
-
-  return _smartWallet;
 }

package/src/wallets/smart/smart.test.ts

@@ -2,7 +2,6 @@ import { describe, expect, it } from "vitest";
 import { TEST_CLIENT } from "../../../test/src/test-clients.js";
 import { defineChain } from "../../chains/utils.js";
 import { generateAccount } from "../utils/generateAccount.js";
-import { connectSmartWallet, disconnectSmartWallet } from "./index.js";
 import { smartWallet } from "./smart-wallet.js";
 
 describe.runIf(process.env.TW_SECRET_KEY)("Smart Wallet Index", () => {
@@ -17,67 +16,48 @@ describe.runIf(process.env.TW_SECRET_KEY)("Smart Wallet Index", () => {
         gasless: true,
       });
 
-      const [account, connectedChain] = await connectSmartWallet(
-        wallet,
-        {
-          client,
-          personalAccount,
-        },
-        {
-          chain,
-          gasless: true,
-        },
-      );
+      await wallet.connect({
+        client,
+        personalAccount,
+      });
 
-      expect(account.address).toBeDefined();
-      expect(account.address).toMatch(/^0x[a-fA-F0-9]{40}$/);
-      expect(connectedChain.id).toBe(chain.id);
+      expect(wallet.getAccount()?.address).toBeDefined();
+      expect(wallet.getAccount()?.address).toMatch(/^0x[a-fA-F0-9]{40}$/);
+      expect(wallet.getChain()?.id).toBe(chain.id);
     });
   });
 
   describe("disconnectSmartWallet", () => {
     it("should disconnect a smart wallet", async () => {
       const personalAccount = await generateAccount({ client });
+
       const wallet = smartWallet({
         chain,
         gasless: true,
       });
 
-      await connectSmartWallet(
-        wallet,
-        {
-          client,
-          personalAccount,
-        },
-        {
-          chain,
-          gasless: true,
-        },
-      );
+      await wallet.connect({
+        client,
+        personalAccount,
+      });
 
-      await expect(disconnectSmartWallet(wallet)).resolves.not.toThrow();
+      await expect(wallet.disconnect()).resolves.not.toThrow();
     });
 
     it("should clear wallet mappings on disconnect", async () => {
       const personalAccount = await generateAccount({ client });
+
       const wallet = smartWallet({
         chain,
         gasless: true,
       });
 
-      await connectSmartWallet(
-        wallet,
-        {
-          client,
-          personalAccount,
-        },
-        {
-          chain,
-          gasless: true,
-        },
-      );
+      await wallet.connect({
+        client,
+        personalAccount,
+      });
 
-      await disconnectSmartWallet(wallet);
+      await wallet.disconnect();
 
       // Verify wallet state is cleared
       expect(wallet.getAccount()).toBeUndefined();