thirdweb 5.82.0 → 5.83.0

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

@@ -4,6 +4,7 @@ import { nativeLocalStorage } from "../../../utils/storage/nativeStorage.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";
@@ -171,6 +172,13 @@ export class InAppNativeConnector implements InAppConnector {
           storage: nativeLocalStorage,
         });
       }
+      case "backend": {
+        return backendAuthenticate({
+          client: this.client,
+          walletSecret: params.walletSecret,
+          ecosystem: params.ecosystem,
+        });
+      }
       case "wallet": {
         return siweAuthenticate({
           client: this.client,
@@ -179,6 +187,11 @@ export class InAppNativeConnector implements InAppConnector {
           ecosystem: params.ecosystem,
         });
       }
+      case "github":
+      case "twitch":
+      case "steam":
+      case "farcaster":
+      case "telegram":
       case "google":
       case "facebook":
       case "discord":

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

@@ -139,6 +139,20 @@ import { createInAppWallet } from "../core/wallet/in-app-core.js";
  * });
  * ```
  *
+ * ### Connect to a backend account
+ *
+ * ```ts
+ * import { inAppWallet } from "thirdweb/wallets";
+ *
+ * const wallet = inAppWallet();
+ *
+ * const account = await wallet.connect({
+ *   client,
+ *   strategy: "backend",
+ *   walletSecret: "...", // Provided by your app
+ * });
+ * ```
+ *
  * ### Connect with custom JWT (any OIDC provider)
  *
  * You can use any OIDC provider to authenticate your users. Make sure to configure it in your dashboard under in-app wallet settings.

package/src/wallets/in-app/web/lib/auth/index.ts

@@ -140,6 +140,17 @@ export async function preAuthenticate(args: PreAuthArgsType) {
  *  verificationCode: "123456",
  * });
  * ```
+ *
+ * Authenticate to a backend account (only do this on your backend):
+ * ```ts
+ * import { authenticate } from "thirdweb/wallets/in-app";
+ *
+ * const result = await authenticate({
+ *  client,
+ *  strategy: "backend",
+ *  walletSecret: "...", // Provided by your app
+ * });
+ * ```
  * @wallet
  */
 export async function authenticate(args: AuthArgsType) {

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",