thirdweb 5.82.1-nightly-5e2eec3b178bcad0988ba7086e31514a3fb7b5d5-20250108000440 → 5.83.0

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

@@ -0,0 +1,163 @@
+import { describe, expect, it, vi } from "vitest";
+import { TEST_CLIENT } from "~test/test-clients.js";
+import { TEST_ACCOUNT_A } from "~test/test-wallets.js";
+import { createWalletAdapter } from "../../../../adapters/wallet-adapter.js";
+import { ethereum } from "../../../../chains/chain-definitions/ethereum.js";
+import { backendAuthenticate } from "../../core/authentication/backend.js";
+import { guestAuthenticate } from "../../core/authentication/guest.js";
+import { siweAuthenticate } from "../../core/authentication/siwe.js";
+import { loginWithOauth } from "./auth/oauth.js";
+import { verifyOtp } from "./auth/otp.js";
+import { InAppWebConnector } from "./web-connector.js";
+
+vi.mock("./auth/oauth");
+vi.mock("./auth/iframe-auth.ts", () => {
+  const Auth = vi.fn();
+  Auth.prototype.loginWithAuthToken = vi.fn(() => {
+    return Promise.resolve({
+      user: {
+        authDetails: {
+          recoveryShareManagement: "ENCLAVE",
+          userWalletId: "123",
+        },
+        status: "Logged In, Wallet Initialized",
+        walletAddress: "0x123",
+      },
+    });
+  });
+  return { Auth };
+});
+vi.mock("../../core/authentication/siwe");
+vi.mock("../../core/authentication/guest");
+vi.mock("../../core/authentication/backend");
+vi.mock("./auth/otp");
+vi.mock("../../core/authentication/authEndpoint");
+vi.mock("../../core/authentication/jwt");
+vi.mock("../../web/utils/iFrameCommunication/InAppWalletIframeCommunicator");
+
+describe("InAppWebConnector.connect", () => {
+  const mockAuthToken = {
+    storedToken: {
+      authDetails: {
+        userWalletId: "123",
+        recoveryShareManagement: "ENCLAVE" as const,
+      },
+      authProvider: "EmailOtp" as const,
+      cookieString: "mock-cookie",
+      developerClientId: TEST_CLIENT.clientId,
+      isNewUser: false,
+      jwtToken: "mock-jwt-token",
+      shouldStoreCookieString: true,
+    },
+  };
+
+  const connector = new InAppWebConnector({
+    client: TEST_CLIENT,
+  });
+  const mockWallet = createWalletAdapter({
+    adaptedAccount: TEST_ACCOUNT_A,
+    client: TEST_CLIENT,
+    chain: ethereum,
+    onDisconnect: () => {},
+    switchChain: () => {},
+  });
+  const mockAccount = mockWallet.getAccount();
+  if (!mockAccount) {
+    throw new Error("mockAccount is undefined");
+  }
+
+  it("should handle email authentication", async () => {
+    vi.mocked(verifyOtp).mockResolvedValueOnce(mockAuthToken);
+
+    const result = await connector.connect({
+      strategy: "email",
+      email: "test@example.com",
+      verificationCode: "123456",
+    });
+
+    expect(verifyOtp).toHaveBeenCalledWith({
+      strategy: "email",
+      email: "test@example.com",
+      verificationCode: "123456",
+      client: TEST_CLIENT,
+      ecosystem: undefined,
+    });
+
+    expect(result).toBeDefined();
+  });
+
+  it("should handle wallet authentication", async () => {
+    vi.mocked(siweAuthenticate).mockResolvedValueOnce(mockAuthToken);
+
+    const mockWallet = createWalletAdapter({
+      adaptedAccount: TEST_ACCOUNT_A,
+      client: TEST_CLIENT,
+      chain: ethereum,
+      onDisconnect: () => {},
+      switchChain: () => {},
+    });
+
+    await connector.connect({
+      strategy: "wallet",
+      chain: ethereum,
+      wallet: mockWallet,
+    });
+
+    expect(siweAuthenticate).toHaveBeenCalledWith({
+      wallet: mockWallet,
+      chain: ethereum,
+      client: TEST_CLIENT,
+      ecosystem: undefined,
+    });
+  });
+
+  it("should handle guest authentication", async () => {
+    vi.mocked(guestAuthenticate).mockResolvedValueOnce(mockAuthToken);
+
+    await connector.connect({
+      strategy: "guest",
+    });
+
+    expect(guestAuthenticate).toHaveBeenCalled();
+  });
+
+  it("should handle backend authentication", async () => {
+    vi.mocked(backendAuthenticate).mockResolvedValueOnce(mockAuthToken);
+
+    await connector.connect({
+      strategy: "backend",
+      walletSecret: "secret123",
+    });
+
+    expect(backendAuthenticate).toHaveBeenCalledWith({
+      walletSecret: "secret123",
+      client: TEST_CLIENT,
+      ecosystem: undefined,
+    });
+  });
+
+  it("should handle oauth authentication", async () => {
+    vi.mocked(loginWithOauth).mockResolvedValueOnce(mockAuthToken);
+
+    await connector.connect({
+      strategy: "google",
+    });
+
+    expect(loginWithOauth).toHaveBeenCalledWith({
+      authOption: "google",
+      client: TEST_CLIENT,
+      ecosystem: undefined,
+      closeOpenedWindow: undefined,
+      openedWindow: undefined,
+    });
+  });
+
+  it("should throw error for invalid strategy", async () => {
+    await expect(
+      connector.connect({
+        // @ts-expect-error invalid strategy
+        strategy: "invalid",
+      }),
+    ).rejects.toThrow("Invalid param: invalid");
+  });
+});

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

@@ -5,6 +5,7 @@ import type { SocialAuthOption } from "../../../../wallets/types.js";
 import type { Account } from "../../../interfaces/wallet.js";
 import { getUserStatus } from "../../core/actions/get-enclave-user-status.js";
 import { authEndpoint } from "../../core/authentication/authEndpoint.js";
+import { backendAuthenticate } from "../../core/authentication/backend.js";
 import { ClientScopedStorage } from "../../core/authentication/client-scoped-storage.js";
 import { guestAuthenticate } from "../../core/authentication/guest.js";
 import { customJwt } from "../../core/authentication/jwt.js";
@@ -351,6 +352,13 @@ export class InAppWebConnector implements InAppConnector {
           storage: webLocalStorage,
         });
       }
+      case "backend": {
+        return backendAuthenticate({
+          client: this.client,
+          walletSecret: args.walletSecret,
+          ecosystem: this.ecosystem,
+        });
+      }
       case "wallet": {
         return siweAuthenticate({
           ecosystem: this.ecosystem,
@@ -387,6 +395,7 @@ export class InAppWebConnector implements InAppConnector {
         const authToken = await this.passkeyAuth(args);
         return this.loginWithAuthToken(authToken);
       }
+      case "backend":
       case "phone":
       case "email":
       case "wallet":

package/src/wallets/types.ts

@@ -39,6 +39,7 @@ export type OAuthOption = SocialAuthOption | "guest";
 export const authOptions = [
   ...socialAuthOptions,
   "guest",
+  "backend",
   "email",
   "phone",
   "passkey",