thirdweb 5.30.0-nightly-33777df88fb190c2af8ad25e4930040884996f1e-20240620000630 → 5.30.0-nightly-d320777eea5404f596aa39b2b49b5165d3e1959a-20240621000551

package/src/wallets/create-wallet.ts

@@ -6,6 +6,7 @@ import type {
 import type { Account, Wallet } from "./interfaces/wallet.js";
 import type {
   CreateWalletArgs,
+  EcosystemWalletId,
   InjectedConnectOptions,
   WalletAutoConnectionOption,
   WalletId,
@@ -18,6 +19,8 @@ import { openWindow } from "../utils/web/openWindow.js";
 import { coinbaseWalletSDK } from "./coinbase/coinbase-wallet.js";
 import { getCoinbaseWebProvider } from "./coinbase/coinbaseWebSDK.js";
 import { COINBASE } from "./constants.js";
+import { isEcosystemWallet } from "./ecosystem/is-ecosystem-wallet.js";
+import { ecosystemWallet } from "./in-app/web/ecosystem.js";
 import { inAppWallet } from "./in-app/web/in-app.js";
 import { smartWallet } from "./smart/smart-wallet.js";
 import type { WCConnectOptions } from "./wallet-connect/types.js";
@@ -46,11 +49,11 @@ export function createWallet<const ID extends WalletId>(
 ): Wallet<ID> {
   const [id, creationOptions] = args;
 
-  switch (id) {
+  switch (true) {
     /**
      * SMART WALLET
      */
-    case "smart": {
+    case id === "smart": {
       return smartWallet(
         creationOptions as CreateWalletArgs<"smart">[1],
       ) as Wallet<ID>;
@@ -58,8 +61,7 @@ export function createWallet<const ID extends WalletId>(
     /**
      * IN-APP WALLET
      */
-    case "embedded":
-    case "inApp": {
+    case id === "embedded" || id === "inApp": {
       return inAppWallet(
         creationOptions as CreateWalletArgs<"inApp">[1],
       ) as Wallet<ID>;
@@ -69,7 +71,7 @@ export function createWallet<const ID extends WalletId>(
      * COINBASE WALLET VIA SDK
      * -> if no injected coinbase found, we'll use the coinbase SDK
      */
-    case COINBASE: {
+    case id === COINBASE: {
       const options = creationOptions as CreateWalletArgs<typeof COINBASE>[1];
       return coinbaseWalletSDK({
         createOptions: options,
@@ -84,6 +86,10 @@ export function createWallet<const ID extends WalletId>(
         },
       }) as Wallet<ID>;
     }
+    case isEcosystemWallet(id):
+      return ecosystemWallet(
+        ...(args as CreateWalletArgs<EcosystemWalletId>),
+      ) as Wallet<ID>;
 
     /**
      * WALLET CONNECT AND INJECTED WALLETS + walletConnect standalone

package/src/wallets/ecosystem/get-ecosystem-partner-permissions.ts

@@ -0,0 +1,24 @@
+import { getThirdwebBaseUrl } from "../../utils/domains.js";
+import type { EcosystemPermssions } from "../in-app/web/types.js";
+import type { EcosystemWalletId } from "../wallet-types.js";
+
+export const getEcosystemPartnerPermissions = async (
+  ecosystemId: EcosystemWalletId,
+  partnerId?: string,
+): Promise<EcosystemPermssions> => {
+  const headers = new Headers();
+  headers.set("x-ecosystem-id", ecosystemId);
+  headers.set("x-ecosystem-partner-id", partnerId || "");
+  const res = await fetch(
+    `${getThirdwebBaseUrl(
+      "inAppWallet",
+    )}/api/2024-05-05/ecosystem-wallet/${ecosystemId}/partner/${partnerId}`,
+    {
+      headers,
+    },
+  );
+
+  const data = (await res.json()) as EcosystemPermssions;
+
+  return data;
+};

package/src/wallets/ecosystem/get-ecosystem-wallet-info.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it, vi } from "vitest";
+import { getEcosystemWalletInfo } from "./get-ecosystem-wallet-info.js";
+
+const mocks = vi.hoisted(() => ({
+  getThirdwebBaseUrl: vi.fn(),
+}));
+
+vi.mock("../../utils/domains", () => ({
+  getThirdwebBaseUrl: mocks.getThirdwebBaseUrl,
+}));
+
+describe("getEcosystemWalletInfo", () => {
+  it("should fetch wallet metadata successfully", async () => {
+    const walletId = "ecosystem.123";
+    const mockResponse = {
+      name: "Test Wallet",
+      imageUrl: "http://example.com/image.png",
+      homepage: "http://example.com",
+    };
+    const fetchMock = vi.fn().mockResolvedValue({
+      json: () => Promise.resolve(mockResponse),
+    });
+    global.fetch = fetchMock;
+    mocks.getThirdwebBaseUrl.mockReturnValue("http://baseurl.com");
+
+    const result = await getEcosystemWalletInfo(walletId);
+
+    expect(fetchMock).toHaveBeenCalled();
+    expect(result).toEqual({
+      id: walletId,
+      name: "Test Wallet",
+      image_id: "http://example.com/image.png",
+      homepage: "http://example.com",
+      rdns: null,
+      app: {
+        browser: null,
+        ios: null,
+        android: null,
+        mac: null,
+        windows: null,
+        linux: null,
+        opera: null,
+        chrome: null,
+        firefox: null,
+        safari: null,
+        edge: null,
+      },
+      mobile: {
+        native: null,
+        universal: null,
+      },
+      desktop: {
+        native: null,
+        universal: null,
+      },
+    });
+  });
+});

package/src/wallets/ecosystem/get-ecosystem-wallet-info.ts

@@ -0,0 +1,63 @@
+import { getThirdwebBaseUrl } from "../../utils/domains.js";
+import type { Prettify } from "../../utils/type-utils.js";
+import type { WalletInfo } from "../wallet-info.js";
+import type { EcosystemWalletId } from "../wallet-types.js";
+
+/**
+ * Fetches metadata for a given ecosystem wallet.
+ *
+ * @param {EcosystemWalletId} walletId - The ecosystem wallet ID.
+ * @returns {Promise<{ imageUrl: string | undefined, name: string | undefined }>} A promise that resolves to an object containing the wallet's image URL and name.
+ * @throws {Error} Throws an error if no partner ID is provided in the wallet configuration.
+ * @internal
+ */
+export async function getEcosystemWalletInfo(
+  walletId: EcosystemWalletId,
+): Promise<Prettify<WalletInfo>> {
+  const headers = new Headers();
+  headers.set("x-ecosystem-id", walletId);
+  const res = await fetch(
+    `${getThirdwebBaseUrl("inAppWallet")}/api/2024-05-05/ecosystem-wallet`,
+    {
+      headers,
+    },
+  );
+
+  const data = await res.json();
+
+  if (!data || data.code === "UNAUTHORIZED") {
+    throw new Error(
+      data.message ||
+        `Could not find ecosystem wallet with id ${walletId}, please check your ecosystem wallet configuration.`,
+    );
+  }
+
+  return {
+    id: walletId,
+    name: data.name as string,
+    image_id: data.imageUrl as string,
+    homepage: data.homepage as string,
+    rdns: null,
+    app: {
+      browser: null,
+      ios: null,
+      android: null,
+      mac: null,
+      windows: null,
+      linux: null,
+      opera: null,
+      chrome: null,
+      firefox: null,
+      safari: null,
+      edge: null,
+    },
+    mobile: {
+      native: null,
+      universal: null,
+    },
+    desktop: {
+      native: null,
+      universal: null,
+    },
+  };
+}

package/src/wallets/ecosystem/is-ecosystem-wallet.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { createWallet } from "../create-wallet.js";
+import { isEcosystemWallet } from "./is-ecosystem-wallet.js";
+
+describe("isEcosystemWallet", () => {
+  it('should return true for wallet IDs starting with "ecosystem."', () => {
+    const walletId = "ecosystem.123";
+    expect(isEcosystemWallet(walletId)).toBe(true);
+  });
+
+  it('should return false for wallet IDs not starting with "ecosystem."', () => {
+    const walletId = "com.coinbase.wallet";
+    expect(isEcosystemWallet(walletId)).toBe(false);
+  });
+
+  it("should handle edge cases like empty wallet IDs", () => {
+    const walletId = "";
+    expect(isEcosystemWallet(walletId)).toBe(false);
+  });
+
+  it("should return true for ecosystem wallet objects", () => {
+    const walletId = "ecosystem.coinbase";
+    expect(isEcosystemWallet(createWallet(walletId))).toBe(true);
+  });
+
+  it("should return false for non-ecosystem wallets", () => {
+    const walletId = "com.coinbase.wallet";
+    expect(isEcosystemWallet(createWallet(walletId))).toBe(false);
+  });
+});

package/src/wallets/ecosystem/is-ecosystem-wallet.ts

@@ -0,0 +1,23 @@
+import type { Wallet } from "../interfaces/wallet.js";
+import type { EcosystemWalletId } from "../wallet-types.js";
+
+export function isEcosystemWallet(
+  wallet: Wallet,
+): wallet is Wallet<EcosystemWalletId>;
+
+export function isEcosystemWallet(wallet: string): wallet is EcosystemWalletId;
+
+/**
+ * Checks if the given wallet is an ecosystem wallet.
+ *
+ * @param {string} walletId - The wallet ID to check.
+ * @returns {boolean} True if the wallet is an ecosystem wallet, false otherwise.
+ * @internal
+ */
+export function isEcosystemWallet(
+  wallet: Wallet | string,
+): wallet is Wallet<EcosystemWalletId> {
+  return typeof wallet === "string"
+    ? wallet.startsWith("ecosystem.")
+    : wallet.id.startsWith("ecosystem.");
+}

package/src/wallets/ecosystem/types.ts

@@ -0,0 +1,15 @@
+import type {
+  InAppWalletAutoConnectOptions,
+  InAppWalletConnectionOptions,
+} from "../in-app/core/wallet/types.js";
+import type { Ecosystem } from "../in-app/web/types.js";
+
+export type EcosystemWalletCreationOptions = {
+  partnerId?: string;
+};
+
+export type EcosystemWalletConnectionOptions = InAppWalletConnectionOptions & {
+  ecosystem: Ecosystem;
+};
+export type EcosystemWalletAutoConnectOptions =
+  InAppWalletAutoConnectOptions & { ecosystem: Ecosystem };

package/src/wallets/in-app/core/authentication/type.ts

@@ -1,6 +1,8 @@
 import type { AuthType } from "@passwordless-id/webauthn/dist/esm/types.js";
 import type { ThirdwebClient } from "../../../../client/client.js";
 import type { Account } from "../../../interfaces/wallet.js";
+import type { SocialAuthOption } from "../../../types.js";
+import type { Ecosystem } from "../../web/types.js";
 
 export type MultiStepAuthProviderType =
   | {
@@ -13,6 +15,7 @@ export type MultiStepAuthProviderType =
     };
 export type PreAuthArgsType = MultiStepAuthProviderType & {
   client: ThirdwebClient;
+  ecosystem?: Ecosystem;
 };
 
 export type MultiStepAuthArgsType = MultiStepAuthProviderType & {
@@ -21,19 +24,7 @@ export type MultiStepAuthArgsType = MultiStepAuthProviderType & {
 
 export type SingleStepAuthArgsType =
   | {
-      strategy: "google";
-      openedWindow?: Window;
-      closeOpenedWindow?: (window: Window) => void;
-      redirectUrl?: string;
-    }
-  | {
-      strategy: "apple";
-      openedWindow?: Window;
-      closeOpenedWindow?: (window: Window) => void;
-      redirectUrl?: string;
-    }
-  | {
-      strategy: "facebook";
+      strategy: SocialAuthOption;
       openedWindow?: Window;
       closeOpenedWindow?: (window: Window) => void;
       redirectUrl?: string;
@@ -51,6 +42,7 @@ export type SingleStepAuthArgsType =
 
 export type AuthArgsType = (MultiStepAuthArgsType | SingleStepAuthArgsType) & {
   client: ThirdwebClient;
+  ecosystem?: Ecosystem;
 };
 
 // TODO: remove usage of enums, instead use object with as const

package/src/wallets/in-app/core/constants/settings.ts

@@ -19,14 +19,14 @@ export const BASE_IN_APP_WALLET_URL = "embedded-wallet.thirdweb.com";
 /**
  * @internal
  */
-export const WALLET_USER_DETAILS_LOCAL_STORAGE_NAME = (clientId: string) =>
-  `thirdwebEwsWalletUserDetails-${clientId}`;
+export const WALLET_USER_DETAILS_LOCAL_STORAGE_NAME = (key: string) =>
+  `thirdwebEwsWalletUserDetails-${key}`;
 
 /**
  * @internal
  */
-export const WALLET_USER_ID_LOCAL_STORAGE_NAME = (clientId: string) =>
-  `thirdwebEwsWalletUserId-${clientId}`;
+export const WALLET_USER_ID_LOCAL_STORAGE_NAME = (cliekeytId: string) =>
+  `thirdwebEwsWalletUserId-${cliekeytId}`;
 
 /**
  * @internal
@@ -36,15 +36,15 @@ const AUTH_TOKEN_LOCAL_STORAGE_PREFIX = "walletToken";
 /**
  * @internal
  */
-export const AUTH_TOKEN_LOCAL_STORAGE_NAME = (clientId: string) => {
-  return `${AUTH_TOKEN_LOCAL_STORAGE_PREFIX}-${clientId}`;
+export const AUTH_TOKEN_LOCAL_STORAGE_NAME = (key: string) => {
+  return `${AUTH_TOKEN_LOCAL_STORAGE_PREFIX}-${key}`;
 };
 
 /**
  * @internal
  */
-export const PASSKEY_CREDENTIAL_ID_LOCAL_STORAGE_NAME = (clientId: string) => {
-  return `passkey-credential-id-${clientId}`;
+export const PASSKEY_CREDENTIAL_ID_LOCAL_STORAGE_NAME = (key: string) => {
+  return `passkey-credential-id-${key}`;
 };
 
 /**
@@ -55,19 +55,17 @@ const DEVICE_SHARE_LOCAL_STORAGE_PREFIX = "a";
 /**
  * @internal
  */
-export const DEVICE_SHARE_LOCAL_STORAGE_NAME = (
-  clientId: string,
-  userId: string,
-) => `${DEVICE_SHARE_LOCAL_STORAGE_PREFIX}-${clientId}-${userId}`;
+export const DEVICE_SHARE_LOCAL_STORAGE_NAME = (key: string, userId: string) =>
+  `${DEVICE_SHARE_LOCAL_STORAGE_PREFIX}-${key}-${userId}`;
 
 /**
  * @internal
  */
-export const WALLET_CONNECT_SESSIONS_LOCAL_STORAGE_NAME = (clientId: string) =>
-  `walletConnectSessions-${clientId}`;
+export const WALLET_CONNECT_SESSIONS_LOCAL_STORAGE_NAME = (key: string) =>
+  `walletConnectSessions-${key}`;
 
 /**
  * @internal
  */
-export const DEVICE_SHARE_LOCAL_STORAGE_NAME_DEPRECATED = (clientId: string) =>
-  `${DEVICE_SHARE_LOCAL_STORAGE_PREFIX}-${clientId}`;
+export const DEVICE_SHARE_LOCAL_STORAGE_NAME_DEPRECATED = (key: string) =>
+  `${DEVICE_SHARE_LOCAL_STORAGE_PREFIX}-${key}`;

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

@@ -0,0 +1,117 @@
+import { trackConnect } from "../../../../analytics/track.js";
+import type { Chain } from "../../../../chains/types.js";
+import type { ThirdwebClient } from "../../../../client/client.js";
+import type { Account, Wallet } from "../../../interfaces/wallet.js";
+import { createWalletEmitter } from "../../../wallet-emitter.js";
+import type {
+  CreateWalletArgs,
+  EcosystemWalletId,
+} from "../../../wallet-types.js";
+import type { InAppConnector } from "../interfaces/connector.js";
+import { getOrCreateInAppWalletConnector } from "./in-app-core.js";
+
+/**
+ * @internal
+ */
+export function createEcosystemWallet(args: {
+  id: EcosystemWalletId;
+  createOptions: CreateWalletArgs<EcosystemWalletId>[1];
+  connectorFactory: (client: ThirdwebClient) => Promise<InAppConnector>;
+}): Wallet<EcosystemWalletId> {
+  // Under the hood, an ecosystem wallet wraps an in-app wallet
+  const { id, createOptions, connectorFactory } = args;
+  const emitter = createWalletEmitter<EcosystemWalletId>();
+  let account: Account | undefined = undefined;
+  let chain: Chain | undefined = undefined;
+  let client: ThirdwebClient | undefined;
+
+  return {
+    id,
+    subscribe: emitter.subscribe,
+    getChain: () => chain,
+    getConfig: () => createOptions,
+    getAccount: () => account,
+    autoConnect: async (options) => {
+      const { autoConnectInAppWallet } = await import("./index.js");
+
+      const connector = await getOrCreateInAppWalletConnector(
+        options.client,
+        connectorFactory,
+        {
+          id,
+          partnerId: createOptions?.partnerId,
+        },
+      );
+
+      const [connectedAccount, connectedChain] = await autoConnectInAppWallet(
+        options,
+        createOptions,
+        connector,
+      );
+      // set the states
+      client = options.client;
+      account = connectedAccount;
+      chain = connectedChain;
+      trackConnect({
+        client: options.client,
+        walletType: id,
+        walletAddress: account.address,
+      });
+      // return only the account
+      return account;
+    },
+    connect: async (options) => {
+      const { connectInAppWallet } = await import("./index.js");
+
+      const connector = await getOrCreateInAppWalletConnector(
+        options.client,
+        connectorFactory,
+        {
+          id,
+          partnerId: createOptions?.partnerId,
+        },
+      );
+
+      const [connectedAccount, connectedChain] = await connectInAppWallet(
+        options,
+        createOptions,
+        connector,
+      );
+      // set the states
+      client = options.client;
+      account = connectedAccount;
+      chain = connectedChain;
+      trackConnect({
+        client: options.client,
+        walletType: id,
+        walletAddress: account.address,
+      });
+      // return only the account
+      return account;
+    },
+    disconnect: async () => {
+      // If no client is assigned, we should be fine just unsetting the states
+      if (client) {
+        const connector = await getOrCreateInAppWalletConnector(
+          client,
+          connectorFactory,
+          {
+            id,
+            partnerId: createOptions?.partnerId,
+          },
+        );
+        const result = await connector.logout();
+        if (!result.success) {
+          throw new Error("Failed to logout");
+        }
+      }
+      account = undefined;
+      chain = undefined;
+      emitter.emit("disconnect", undefined);
+    },
+    switchChain: async (newChain) => {
+      chain = newChain;
+      emitter.emit("chainChanged", newChain);
+    },
+  };
+}

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

@@ -4,9 +4,13 @@ import type { ThirdwebClient } from "../../../../client/client.js";
 import type { Account, Wallet } from "../../../interfaces/wallet.js";
 import { createWalletEmitter } from "../../../wallet-emitter.js";
 import type { CreateWalletArgs } from "../../../wallet-types.js";
+import type { Ecosystem } from "../../web/types.js";
 import type { InAppConnector } from "../interfaces/connector.js";
 
-const connectorCache = new WeakMap<ThirdwebClient, InAppConnector>();
+const connectorCache = new WeakMap<
+  { client: ThirdwebClient; ecosystem?: Ecosystem },
+  InAppConnector
+>();
 
 /**
  * @internal
@@ -14,12 +18,14 @@ const connectorCache = new WeakMap<ThirdwebClient, InAppConnector>();
 export async function getOrCreateInAppWalletConnector(
   client: ThirdwebClient,
   connectorFactory: (client: ThirdwebClient) => Promise<InAppConnector>,
+  ecosystem?: Ecosystem,
 ) {
-  if (connectorCache.has(client)) {
-    return connectorCache.get(client) as InAppConnector;
+  const key = { client, ecosystem };
+  if (connectorCache.has(key)) {
+    return connectorCache.get(key) as InAppConnector;
   }
   const connector = await connectorFactory(client);
-  connectorCache.set(client, connector);
+  connectorCache.set(key, connector);
   return connector;
 }
 

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

@@ -2,7 +2,7 @@ import { ethereum } from "../../../../chains/chain-definitions/ethereum.js";
 import type { Chain } from "../../../../chains/types.js";
 import type { ThirdwebClient } from "../../../../client/client.js";
 import type { Account, Wallet } from "../../../interfaces/wallet.js";
-import type { WalletId } from "../../../wallet-types.js";
+import type { EcosystemWalletId, WalletId } from "../../../wallet-types.js";
 import type {
   CreateWalletArgs,
   WalletAutoConnectionOption,
@@ -27,14 +27,22 @@ export function isInAppWallet(
  * @internal
  */
 export async function connectInAppWallet(
-  options: WalletConnectionOption<"inApp">,
-  createOptions: CreateWalletArgs<"inApp">[1],
+  options:
+    | WalletConnectionOption<"inApp">
+    | WalletConnectionOption<EcosystemWalletId>,
+  createOptions:
+    | CreateWalletArgs<"inApp">[1]
+    | CreateWalletArgs<EcosystemWalletId>[1],
   connector: InAppConnector,
 ): Promise<[Account, Chain]> {
   const authResult = await connector.authenticate(options);
   const authAccount = authResult.user.account;
 
-  if (createOptions?.smartAccount) {
+  if (
+    createOptions &&
+    "smartAccount" in createOptions &&
+    createOptions?.smartAccount
+  ) {
     return convertToSmartAccount({
       client: options.client,
       authAccount,
@@ -43,28 +51,33 @@ export async function connectInAppWallet(
     });
   }
 
-  return [
-    authAccount,
-    options.chain || createOptions?.smartAccount?.chain || ethereum,
-  ] as const;
+  return [authAccount, options.chain || ethereum] as const;
 }
 
 /**
  * @internal
  */
 export async function autoConnectInAppWallet(
-  options: WalletAutoConnectionOption<"inApp">,
-  createOptions: CreateWalletArgs<"inApp">[1],
+  options:
+    | WalletAutoConnectionOption<"inApp">
+    | WalletAutoConnectionOption<EcosystemWalletId>,
+  createOptions:
+    | CreateWalletArgs<"inApp">[1]
+    | CreateWalletArgs<EcosystemWalletId>[1],
   connector: InAppConnector,
 ): Promise<[Account, Chain]> {
   const user = await getAuthenticatedUser(connector);
   if (!user) {
-    throw new Error("not authenticated");
+    throw new Error("Failed to authenticate user.");
   }
 
   const authAccount = user.account;
 
-  if (createOptions?.smartAccount) {
+  if (
+    createOptions &&
+    "smartAccount" in createOptions &&
+    createOptions?.smartAccount
+  ) {
     return convertToSmartAccount({
       client: options.client,
       authAccount,
@@ -73,10 +86,7 @@ export async function autoConnectInAppWallet(
     });
   }
 
-  return [
-    authAccount,
-    options.chain || createOptions?.smartAccount?.chain || ethereum,
-  ] as const;
+  return [authAccount, options.chain || ethereum] as const;
 }
 
 async function convertToSmartAccount(options: {

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

@@ -1,6 +1,7 @@
 import type { Chain } from "../../../../chains/types.js";
 import type { ThirdwebClient } from "../../../../client/client.js";
 import type { SmartWalletOptions } from "../../../smart/types.js";
+import type { AuthOption, SocialAuthOption } from "../../../types.js";
 import type {
   MultiStepAuthArgsType,
   SingleStepAuthArgsType,
@@ -19,13 +20,8 @@ export type InAppWalletAutoConnectOptions = {
   chain?: Chain;
 };
 
-export type InAppWalletSocialAuth = "google" | "apple" | "facebook";
-
-export type InAppWalletAuth =
-  | "email"
-  | "phone"
-  | "passkey"
-  | InAppWalletSocialAuth;
+export type InAppWalletSocialAuth = SocialAuthOption;
+export type InAppWalletAuth = AuthOption;
 
 export type InAppWalletCreationOptions =
   | {
@@ -40,6 +36,7 @@ export type InAppWalletCreationOptions =
           alt?: string;
         };
       };
+      partnerId?: string;
       smartAccount?: SmartWalletOptions;
       hidePrivateKeyExport?: boolean;
     }

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

@@ -28,6 +28,7 @@ import { getExistingUserAccount } from "./helpers/wallet/retrieval.js";
 
 export type NativeConnectorOptions = {
   client: ThirdwebClient;
+  partnerId?: string | undefined;
 };
 
 export class InAppNativeConnector implements InAppConnector {