thirdweb 5.73.0 → 5.74.0

package/src/wallets/in-app/core/users/getUser.test.ts

@@ -0,0 +1,216 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createThirdwebClient } from "../../../../client/client.js";
+import { getClientFetch } from "../../../../utils/fetch.js";
+import { getUser } from "./getUser.js";
+
+vi.mock("../../../../utils/fetch.js", () => ({
+  getClientFetch: vi.fn(),
+}));
+
+describe("getUser", () => {
+  const mockClient = createThirdwebClient({
+    secretKey: "secret",
+  });
+
+  const mockFetch = vi.fn();
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(getClientFetch).mockReturnValue(mockFetch);
+  });
+
+  it("should throw an error if no secret key is provided", async () => {
+    await expect(
+      getUser({
+        client: { ...mockClient, secretKey: undefined },
+        walletAddress: "0x123",
+      }),
+    ).rejects.toThrow(
+      "A secret key is required to query for users. If you're making this request from the server, please add a secret key to your client.",
+    );
+  });
+
+  it("should throw an error if no query parameter is provided", async () => {
+    await expect(
+      getUser({
+        client: mockClient,
+      }),
+    ).rejects.toThrow(
+      "Please provide a walletAddress, email, phone, id, or externalWalletAddress to query for users.",
+    );
+  });
+
+  it("should call the correct URL with email", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => [
+        {
+          userId: "user1",
+          walletAddress: "0x123",
+          email: "test@test.com",
+          createdAt: "2023-01-01T00:00:00Z",
+          linkedAccounts: [],
+        },
+      ],
+    });
+
+    const result = await getUser({
+      client: mockClient,
+      email: "test@test.com",
+    });
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      "https://embedded-wallet.thirdweb.com/api/2023-11-30/embedded-wallet/user-details?queryBy=email&email=test%40test.com",
+    );
+    expect(result).toEqual({
+      userId: "user1",
+      walletAddress: "0x123",
+      email: "test@test.com",
+      createdAt: "2023-01-01T00:00:00Z",
+      profiles: [],
+    });
+  });
+
+  it("should call the correct URL with phone", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => [
+        {
+          userId: "user1",
+          walletAddress: "0x123",
+          phone: "+1234567890",
+          createdAt: "2023-01-01T00:00:00Z",
+          linkedAccounts: [],
+        },
+      ],
+    });
+
+    const result = await getUser({
+      client: mockClient,
+      phone: "+1234567890",
+    });
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      "https://embedded-wallet.thirdweb.com/api/2023-11-30/embedded-wallet/user-details?queryBy=phone&phone=%2B1234567890",
+    );
+    expect(result).toEqual({
+      userId: "user1",
+      walletAddress: "0x123",
+      phone: "+1234567890",
+      createdAt: "2023-01-01T00:00:00Z",
+      profiles: [],
+    });
+  });
+
+  it("should call the correct URL with id", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => [
+        {
+          userId: "user1",
+          walletAddress: "0x123",
+          createdAt: "2023-01-01T00:00:00Z",
+          linkedAccounts: [
+            {
+              type: "id",
+              details: {
+                id: "0x456",
+              },
+            },
+          ],
+        },
+      ],
+    });
+
+    const result = await getUser({
+      client: mockClient,
+      id: "user1",
+    });
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      "https://embedded-wallet.thirdweb.com/api/2023-11-30/embedded-wallet/user-details?queryBy=id&id=user1",
+    );
+    expect(result).toEqual({
+      userId: "user1",
+      walletAddress: "0x123",
+      createdAt: "2023-01-01T00:00:00Z",
+      profiles: [
+        {
+          type: "id",
+          details: {
+            id: "0x456",
+          },
+        },
+      ],
+    });
+  });
+
+  it("should call the correct URL with externalWalletAddress", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => [
+        {
+          userId: "user1",
+          walletAddress: "0x123",
+          createdAt: "2023-01-01T00:00:00Z",
+          linkedAccounts: [
+            {
+              type: "siwe",
+              details: {
+                address: "0x456",
+              },
+            },
+          ],
+        },
+      ],
+    });
+
+    const result = await getUser({
+      client: mockClient,
+      externalWalletAddress: "0x456",
+    });
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      "https://embedded-wallet.thirdweb.com/api/2023-11-30/embedded-wallet/user-details?queryBy=externalWalletAddress&externalWalletAddress=0x456",
+    );
+    expect(result).toEqual({
+      userId: "user1",
+      walletAddress: "0x123",
+      createdAt: "2023-01-01T00:00:00Z",
+      profiles: [
+        {
+          type: "wallet",
+          details: {
+            address: "0x456",
+          },
+        },
+      ],
+    });
+  });
+
+  it("should handle fetch errors", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+    });
+
+    await expect(
+      getUser({
+        client: mockClient,
+        walletAddress: "0x123",
+      }),
+    ).rejects.toThrow("Failed to get profiles");
+  });
+
+  it("should return null if no user is found", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => [],
+    });
+
+    const result = await getUser({
+      client: mockClient,
+      walletAddress: "0x123",
+    });
+
+    expect(result).toBeNull();
+  });
+});

package/src/wallets/in-app/core/users/getUser.ts

@@ -113,7 +113,12 @@ export async function getUser({
       email: item.email,
       phone: item.phone,
       createdAt: item.createdAt,
-      profiles: item.linkedAccounts,
+      profiles: item.linkedAccounts.map((profile) => {
+        return {
+          type: (profile.type as string) === "siwe" ? "wallet" : profile.type,
+          details: profile.details,
+        };
+      }),
     }))[0] || null
   );
 }

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

@@ -0,0 +1,270 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { baseSepolia } from "../../../../chains/chain-definitions/base-sepolia.js";
+import { createThirdwebClient } from "../../../../client/client.js";
+import { getEcosystemInfo } from "../../../ecosystem/get-ecosystem-wallet-auth-options.js";
+import type { Account } from "../../../interfaces/wallet.js";
+import type { InAppConnector } from "../interfaces/connector.js";
+import { createInAppWallet } from "./in-app-core.js";
+import { autoConnectInAppWallet, connectInAppWallet } from "./index.js";
+
+vi.mock("../../../../analytics/track/connect.js", () => ({
+  trackConnect: vi.fn(),
+}));
+
+vi.mock("./index.js", () => ({
+  autoConnectInAppWallet: vi.fn(),
+  connectInAppWallet: vi.fn(),
+}));
+
+vi.mock("../../../ecosystem/get-ecosystem-wallet-auth-options.js", () => ({
+  getEcosystemInfo: vi.fn(),
+}));
+
+describe("createInAppWallet", () => {
+  const mockClient = createThirdwebClient({
+    clientId: "test-client",
+  });
+  const mockChain = baseSepolia;
+  const mockAccount = { address: "0x123" } as Account;
+
+  const mockConnectorFactory = vi.fn(() =>
+    Promise.resolve({
+      connect: vi.fn(),
+      logout: vi.fn(() => Promise.resolve({ success: true })),
+      authenticate: vi.fn(),
+      getAccounts: vi.fn(),
+      getAccount: vi.fn(),
+      getProfiles: vi.fn(),
+      getUser: vi.fn(),
+      linkProfile: vi.fn(),
+      preAuthenticate: vi.fn(),
+    } as InAppConnector),
+  );
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should connect successfully", async () => {
+    vi.mocked(connectInAppWallet).mockResolvedValue([mockAccount, mockChain]);
+
+    const wallet = createInAppWallet({
+      connectorFactory: mockConnectorFactory,
+    });
+
+    const result = await wallet.connect({
+      client: mockClient,
+      chain: mockChain,
+      strategy: "email",
+      email: "",
+      verificationCode: "",
+    });
+
+    expect(result).toBe(mockAccount);
+    expect(connectInAppWallet).toHaveBeenCalledWith(
+      expect.objectContaining({
+        client: mockClient,
+        chain: mockChain,
+      }),
+      undefined,
+      expect.any(Object),
+    );
+  });
+
+  it("should auto connect successfully", async () => {
+    vi.mocked(autoConnectInAppWallet).mockResolvedValue([
+      mockAccount,
+      mockChain,
+    ]);
+
+    const wallet = createInAppWallet({
+      connectorFactory: mockConnectorFactory,
+    });
+
+    const result = await wallet.autoConnect({
+      client: mockClient,
+      chain: mockChain,
+    });
+
+    expect(result).toBe(mockAccount);
+    expect(autoConnectInAppWallet).toHaveBeenCalledWith(
+      expect.objectContaining({
+        client: mockClient,
+        chain: mockChain,
+      }),
+      undefined,
+      expect.any(Object),
+    );
+  });
+
+  it("should handle ecosystem wallet connection with smart account settings", async () => {
+    vi.mocked(getEcosystemInfo).mockResolvedValue({
+      smartAccountOptions: {
+        defaultChainId: mockChain.id,
+        sponsorGas: true,
+        accountFactoryAddress: "0x456",
+      },
+      authOptions: [],
+      name: "hello world",
+      slug: "test-ecosystem",
+    });
+
+    vi.mocked(connectInAppWallet).mockResolvedValue([mockAccount, mockChain]);
+
+    const wallet = createInAppWallet({
+      connectorFactory: mockConnectorFactory,
+      ecosystem: { id: "ecosystem.test-ecosystem" },
+    });
+
+    const result = await wallet.connect({
+      client: mockClient,
+      chain: mockChain,
+      strategy: "email",
+      email: "",
+      verificationCode: "",
+    });
+
+    expect(result).toBe(mockAccount);
+    expect(connectInAppWallet).toHaveBeenCalledWith(
+      expect.objectContaining({
+        client: mockClient,
+        chain: mockChain,
+      }),
+      expect.objectContaining({
+        smartAccount: expect.objectContaining({
+          chain: mockChain,
+          sponsorGas: true,
+          factoryAddress: "0x456",
+        }),
+      }),
+      expect.any(Object),
+    );
+  });
+  it("should handle ecosystem wallet connection with smart account settings even when no chain is set", async () => {
+    vi.mocked(getEcosystemInfo).mockResolvedValue({
+      smartAccountOptions: {
+        defaultChainId: mockChain.id,
+        sponsorGas: true,
+        accountFactoryAddress: "0x456",
+      },
+      authOptions: [],
+      name: "hello world",
+      slug: "test-ecosystem",
+    });
+
+    vi.mocked(connectInAppWallet).mockResolvedValue([mockAccount, mockChain]);
+
+    const wallet = createInAppWallet({
+      connectorFactory: mockConnectorFactory,
+      ecosystem: { id: "ecosystem.test-ecosystem" },
+    });
+
+    const result = await wallet.connect({
+      client: mockClient,
+      strategy: "email",
+      email: "",
+      verificationCode: "",
+    });
+
+    expect(result).toBe(mockAccount);
+    expect(connectInAppWallet).toHaveBeenCalledWith(
+      expect.objectContaining({
+        client: mockClient,
+      }),
+      expect.objectContaining({
+        smartAccount: expect.objectContaining({
+          chain: mockChain,
+          sponsorGas: true,
+          factoryAddress: "0x456",
+        }),
+      }),
+      expect.any(Object),
+    );
+  });
+
+  it("should handle ecosystem wallet auto connection with smart account settings", async () => {
+    vi.mocked(getEcosystemInfo).mockResolvedValue({
+      smartAccountOptions: {
+        defaultChainId: mockChain.id,
+        sponsorGas: true,
+        accountFactoryAddress: "0x456",
+      },
+      authOptions: [],
+      name: "hello world",
+      slug: "test-ecosystem",
+    });
+
+    vi.mocked(autoConnectInAppWallet).mockResolvedValue([
+      mockAccount,
+      mockChain,
+    ]);
+
+    const wallet = createInAppWallet({
+      connectorFactory: mockConnectorFactory,
+      ecosystem: { id: "ecosystem.test-ecosystem" },
+    });
+
+    const result = await wallet.autoConnect({
+      client: mockClient,
+      chain: mockChain,
+    });
+
+    expect(result).toBe(mockAccount);
+    expect(autoConnectInAppWallet).toHaveBeenCalledWith(
+      expect.objectContaining({
+        client: mockClient,
+        chain: mockChain,
+      }),
+      expect.objectContaining({
+        smartAccount: expect.objectContaining({
+          chain: mockChain,
+          sponsorGas: true,
+          factoryAddress: "0x456",
+        }),
+      }),
+      expect.any(Object),
+    );
+  });
+
+  it("should handle ecosystem wallet auto connection with smart account settings even when no chain is set", async () => {
+    vi.mocked(getEcosystemInfo).mockResolvedValue({
+      smartAccountOptions: {
+        defaultChainId: mockChain.id,
+        sponsorGas: true,
+        accountFactoryAddress: "0x456",
+      },
+      authOptions: [],
+      name: "hello world",
+      slug: "test-ecosystem",
+    });
+
+    vi.mocked(autoConnectInAppWallet).mockResolvedValue([
+      mockAccount,
+      mockChain,
+    ]);
+
+    const wallet = createInAppWallet({
+      connectorFactory: mockConnectorFactory,
+      ecosystem: { id: "ecosystem.test-ecosystem" },
+    });
+
+    const result = await wallet.autoConnect({
+      client: mockClient,
+    });
+
+    expect(result).toBe(mockAccount);
+    expect(autoConnectInAppWallet).toHaveBeenCalledWith(
+      expect.objectContaining({
+        client: mockClient,
+      }),
+      expect.objectContaining({
+        smartAccount: expect.objectContaining({
+          chain: mockChain,
+          sponsorGas: true,
+          factoryAddress: "0x456",
+        }),
+      }),
+      expect.any(Object),
+    );
+  });
+});

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

@@ -1,6 +1,9 @@
 import { trackConnect } from "../../../../analytics/track/connect.js";
 import type { Chain } from "../../../../chains/types.js";
-import { getCachedChainIfExists } from "../../../../chains/utils.js";
+import {
+  getCachedChain,
+  getCachedChainIfExists,
+} from "../../../../chains/utils.js";
 import type { ThirdwebClient } from "../../../../client/client.js";
 import { stringify } from "../../../../utils/json.js";
 import { getEcosystemInfo } from "../../../ecosystem/get-ecosystem-wallet-auth-options.js";
@@ -74,12 +77,16 @@ export function createInAppWallet(args: {
         const ecosystemOptions = await getEcosystemInfo(ecosystem.id);
         const smartAccountOptions = ecosystemOptions?.smartAccountOptions;
         if (smartAccountOptions) {
-          const preferredChain = options.chain;
+          const { defaultChainId } = ecosystemOptions.smartAccountOptions;
+          const preferredChain =
+            options.chain ??
+            (defaultChainId ? getCachedChain(defaultChainId) : undefined);
           if (!preferredChain) {
             throw new Error(
-              "Chain is required for ecosystem smart accounts, pass it via connect() or via UI components",
+              `A chain must be provided either via 'chain' in connect options or 'defaultChainId' in ecosystem configuration. Please pass it via connect() or update the ecosystem configuration.`,
             );
           }
+
           createOptions = {
             ...createOptions,
             smartAccount: {
@@ -123,12 +130,16 @@ export function createInAppWallet(args: {
         const ecosystemOptions = await getEcosystemInfo(ecosystem.id);
         const smartAccountOptions = ecosystemOptions?.smartAccountOptions;
         if (smartAccountOptions) {
-          const preferredChain = options.chain;
+          const { defaultChainId } = ecosystemOptions.smartAccountOptions;
+          const preferredChain =
+            options.chain ??
+            (defaultChainId ? getCachedChain(defaultChainId) : undefined);
           if (!preferredChain) {
             throw new Error(
-              "Chain is required for ecosystem smart accounts, pass it via connect() or via UI components",
+              `A chain must be provided either via 'chain' in connect options or 'defaultChainId' in ecosystem configuration. Please pass it via connect() or update the ecosystem configuration.`,
             );
           }
+
           createOptions = {
             ...createOptions,
             smartAccount: {

package/src/wallets/in-app/web/ecosystem.ts

@@ -7,7 +7,7 @@ import type {
 import { createInAppWallet } from "../core/wallet/in-app-core.js";
 
 /**
- * Creates an [Ecosystem Wallet](https://portal.thirdweb.com/connect/ecosystems/overview) based on various authentication methods. Full list of available authentication methods [here](/connect/wallet/sign-in-methods/overview).
+ * Creates an [Ecosystem Wallet](https://portal.thirdweb.com/connect/wallet/overview) based on various authentication methods. Full list of available authentication methods [here](/connect/wallet/sign-in-methods/configure).
  *
  * Can also be configured to use Account Abstraction to directly connect to a ERC4337 smart account based on those authentication methods.
  *

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

@@ -4,7 +4,7 @@ import type { CreateWalletArgs } from "../../wallet-types.js";
 import { createInAppWallet } from "../core/wallet/in-app-core.js";
 
 /**
- * Creates an app scoped wallet for users based on various authentication methods. Full list of available authentication methods [here](https://portal.thirdweb.com/connect/wallet/sign-in-methods/overview).
+ * Creates an app scoped wallet for users based on various authentication methods. Full list of available authentication methods [here](https://portal.thirdweb.com/connect/wallet/sign-in-methods/configure).
  *
  * Can also be configured to use Account Abstraction to directly connect to a ERC4337 smart account based on those authentication methods.
  *
@@ -27,7 +27,7 @@ import { createInAppWallet } from "../core/wallet/in-app-core.js";
  * });
  * ```
  *
- * [View all available social auth methods](https://portal.thirdweb.com/connect/wallet/sign-in-methods/overview)
+ * [View all available social auth methods](https://portal.thirdweb.com/connect/wallet/sign-in-methods/configure)
  *
  * ### Login with email
  *