thirdweb 5.59.0-nightly-e2b3484764275560aa899f3f894b767faedaa9a1-20240925000331 → 5.59.0

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

@@ -1,10 +1,11 @@
-import type { Chain } from "../../../chains/types.js";
 import type { ThirdwebClient } from "../../../client/client.js";
 import { stringify } from "../../../utils/json.js";
 import { nativeLocalStorage } from "../../../utils/storage/nativeStorage.js";
-import type { Account, Wallet } from "../../interfaces/wallet.js";
+import type { Account } from "../../interfaces/wallet.js";
+import { authEndpoint } from "../core/authentication/authEndpoint.js";
 import { ClientScopedStorage } from "../core/authentication/client-scoped-storage.js";
 import { guestAuthenticate } from "../core/authentication/guest.js";
+import { customJwt } from "../core/authentication/jwt.js";
 import {
   getLinkedProfilesInternal,
   linkAccount,
@@ -14,35 +15,25 @@ import {
   registerPasskey,
 } from "../core/authentication/passkeys.js";
 import { siweAuthenticate } from "../core/authentication/siwe.js";
-import {
-  type AuthArgsType,
-  type AuthLoginReturnType,
-  type AuthStoredTokenWithCookieReturnType,
-  type GetUser,
-  type LogoutReturnType,
-  type MultiStepAuthArgsType,
-  type MultiStepAuthProviderType,
-  type OAuthRedirectObject,
-  UserWalletStatus,
+import type {
+  AuthArgsType,
+  AuthLoginReturnType,
+  AuthStoredTokenWithCookieReturnType,
+  GetUser,
+  LogoutReturnType,
+  MultiStepAuthArgsType,
+  MultiStepAuthProviderType,
+  SingleStepAuthArgsType,
 } from "../core/authentication/types.js";
 import type { InAppConnector } from "../core/interfaces/connector.js";
+import { EnclaveWallet } from "../core/wallet/enclave-wallet.js";
 import type { Ecosystem } from "../core/wallet/types.js";
+import type { IWebWallet } from "../core/wallet/web-wallet.js";
+import { getUserStatus } from "../web/lib/actions/get-enclave-user-status.js";
 import { sendOtp, verifyOtp } from "../web/lib/auth/otp.js";
-import {
-  authEndpoint,
-  authenticate,
-  customJwt,
-  deleteActiveAccount,
-  guestLogin,
-  otpLogin,
-  siweLogin,
-  socialLogin,
-} from "./auth/native-auth.js";
-import { fetchUserDetails } from "./helpers/api/fetchers.js";
+import { deleteActiveAccount, socialAuth } from "./auth/native-auth.js";
 import { logoutUser } from "./helpers/auth/logout.js";
-import { postAuth } from "./helpers/auth/middleware.js";
-import { getWalletUserDetails } from "./helpers/storage/local.js";
-import { getExistingUserAccount } from "./helpers/wallet/retrieval.js";
+import { ShardedWallet } from "./helpers/wallet/sharded-wallet.js";
 
 type NativeConnectorOptions = {
   client: ThirdwebClient;
@@ -55,6 +46,7 @@ export class InAppNativeConnector implements InAppConnector {
   private ecosystem?: Ecosystem;
   private passkeyDomain?: string;
   private localStorage: ClientScopedStorage;
+  private wallet?: IWebWallet;
 
   constructor(options: NativeConnectorOptions) {
     this.client = options.client;
@@ -67,37 +59,57 @@ export class InAppNativeConnector implements InAppConnector {
     });
   }
 
-  async getUser(): Promise<GetUser> {
-    const localData = await getWalletUserDetails(this.client.clientId);
-    const userStatus = await fetchUserDetails({
+  async initializeWallet(authToken?: string) {
+    const storedAuthToken = await this.localStorage.getAuthCookie();
+    if (!authToken && storedAuthToken === null) {
+      throw new Error(
+        "No auth token provided and no stored auth token found to initialize the wallet",
+      );
+    }
+    const user = await getUserStatus({
+      authToken: authToken || (storedAuthToken as string),
       client: this.client,
-      email: localData?.email,
+      ecosystem: this.ecosystem,
     });
-    if (userStatus.status === UserWalletStatus.LOGGED_IN_WALLET_INITIALIZED) {
-      return {
-        status: userStatus.status,
-        authDetails: userStatus.storedToken.authDetails,
-        walletAddress: userStatus.walletAddress,
-        account: await this.getAccount(),
-      };
+    if (!user) {
+      throw new Error("Cannot initialize wallet, no user logged in");
+    }
+    const wallet = user.wallets[0];
+    // TODO (enclaves): Migration to enclave wallet if sharded
+    if (wallet && wallet.type === "enclave") {
+      this.wallet = new EnclaveWallet({
+        client: this.client,
+        ecosystem: this.ecosystem,
+        address: wallet.address,
+        storage: this.localStorage,
+      });
+    } else {
+      this.wallet = new ShardedWallet({
+        client: this.client,
+        storage: this.localStorage,
+      });
     }
-    if (userStatus.status === UserWalletStatus.LOGGED_IN_NEW_DEVICE) {
-      return {
-        status: UserWalletStatus.LOGGED_IN_WALLET_UNINITIALIZED,
-        authDetails: userStatus.storedToken.authDetails,
-      };
+  }
+
+  async getUser(): Promise<GetUser> {
+    if (!this.wallet) {
+      const localAuthToken = await this.localStorage.getAuthCookie();
+      if (!localAuthToken) {
+        return { status: "Logged Out" };
+      }
+      await this.initializeWallet(localAuthToken);
     }
-    if (userStatus.status === UserWalletStatus.LOGGED_IN_WALLET_UNINITIALIZED) {
-      return {
-        status: UserWalletStatus.LOGGED_IN_WALLET_UNINITIALIZED,
-        authDetails: userStatus.storedToken.authDetails,
-      };
+    if (!this.wallet) {
+      throw new Error("Wallet not initialized");
     }
-    // Logged out
-    return { status: UserWalletStatus.LOGGED_OUT };
+    return this.wallet.getUserWalletStatus();
   }
+
   getAccount(): Promise<Account> {
-    return getExistingUserAccount({ client: this.client });
+    if (!this.wallet) {
+      throw new Error("Wallet not initialized");
+    }
+    return this.wallet.getAccount();
   }
 
   preAuthenticate(args: MultiStepAuthProviderType): Promise<void> {
@@ -128,6 +140,7 @@ export class InAppNativeConnector implements InAppConnector {
           client: this.client,
           wallet: params.wallet,
           chain: params.chain,
+          ecosystem: params.ecosystem,
         });
       }
       case "google":
@@ -139,95 +152,63 @@ export class InAppNativeConnector implements InAppConnector {
         const ExpoLinking = require("expo-linking");
         const redirectUrl =
           params.redirectUrl || (ExpoLinking.createURL("") as string);
-        return authenticate({ strategy, redirectUrl }, this.client);
-      }
-      case "passkey":
-        return this.passkeyAuth(params);
-      default:
-        throw new Error(`Unsupported authentication type: ${strategy}`);
-    }
-  }
-
-  async connect(params: AuthArgsType): Promise<AuthLoginReturnType> {
-    const strategy = params.strategy;
-    switch (strategy) {
-      case "email": {
-        return await this.validateOtp({
-          email: params.email,
-          verificationCode: params.verificationCode,
-          strategy: "email",
+        return socialAuth({
+          auth: { strategy, redirectUrl },
           client: this.client,
+          ecosystem: this.ecosystem,
         });
       }
-      case "phone": {
-        return await this.validateOtp({
-          phoneNumber: params.phoneNumber,
-          verificationCode: params.verificationCode,
-          strategy: "phone",
-          client: this.client,
-        });
-      }
-      case "google":
-      case "facebook":
-      case "discord":
-      case "line":
-      case "x":
-      case "farcaster":
-      case "telegram":
-      case "coinbase":
-      case "apple": {
-        const ExpoLinking = require("expo-linking");
-        const redirectUrl =
-          params.redirectUrl || (ExpoLinking.createURL("") as string); // Will default to the app scheme
-        return this.socialLogin({
-          strategy,
-          redirectUrl,
-        });
-      }
-      case "guest": {
-        return this.guestLogin({
-          ecosystem: params.ecosystem,
-        });
-      }
-      case "wallet": {
-        return this.siweLogin({
-          wallet: params.wallet,
-          chain: params.chain,
-        });
-      }
-      case "jwt": {
-        return this.customJwt({
+      case "passkey":
+        return this.passkeyAuth(params);
+      case "jwt":
+        return customJwt({
           jwt: params.jwt,
-          password: params.encryptionKey,
+          client: this.client,
+          storage: this.localStorage,
         });
-      }
-      case "auth_endpoint": {
-        return this.authEndpoint({
+      case "auth_endpoint":
+        return authEndpoint({
           payload: params.payload,
-          encryptionKey: params.encryptionKey,
+          client: this.client,
+          storage: this.localStorage,
         });
-      }
-      case "passkey": {
-        const authToken = await this.passkeyAuth(params);
-        const account = await this.getAccount();
-        return {
-          user: {
-            status: UserWalletStatus.LOGGED_IN_WALLET_INITIALIZED,
-            account,
-            authDetails: authToken.storedToken.authDetails,
-            walletAddress: account.address,
-          },
-        };
-      }
-      case "iframe": {
-        throw new Error("iframe_email_verification is not supported in native");
-      }
-      case "iframe_email_verification": {
-        throw new Error("iframe_email_verification is not supported in native");
-      }
       default:
-        assertUnreachable(strategy);
+        throw new Error(`Unsupported authentication type: ${strategy}`);
+    }
+  }
+
+  async connect(
+    params: MultiStepAuthArgsType | SingleStepAuthArgsType,
+  ): Promise<AuthLoginReturnType> {
+    const authResult = await this.authenticate({
+      ...params,
+      client: this.client,
+      ecosystem: this.ecosystem,
+    });
+    await this.initializeWallet(authResult.storedToken.cookieString);
+    if (!this.wallet) {
+      throw new Error("Wallet not initialized");
     }
+    const encryptionKey =
+      params.strategy === "jwt"
+        ? params.encryptionKey
+        : params.strategy === "auth_endpoint"
+          ? params.encryptionKey
+          : undefined;
+
+    await this.wallet.postWalletSetUp({
+      ...authResult,
+      encryptionKey,
+    });
+    const account = await this.getAccount();
+    return {
+      user: {
+        status: "Logged In, Wallet Initialized",
+        account,
+        authDetails: authResult.storedToken.authDetails,
+        walletAddress: account.address,
+      },
+    };
   }
 
   private async passkeyAuth(args: {
@@ -238,6 +219,7 @@ export class InAppNativeConnector implements InAppConnector {
   }): Promise<AuthStoredTokenWithCookieReturnType> {
     const { type, passkeyName, client, ecosystem } = args;
     const domain = this.passkeyDomain;
+    const storage = this.localStorage;
     if (!domain) {
       throw new Error(
         "Passkey domain is required for native platforms. Please pass it in the 'auth' options when creating the inAppWallet().",
@@ -246,7 +228,6 @@ export class InAppNativeConnector implements InAppConnector {
     try {
       const { PasskeyNativeClient } = await import("./auth/passkeys.js");
       const passkeyClient = new PasskeyNativeClient();
-      const storage = nativeLocalStorage;
       let authToken: AuthStoredTokenWithCookieReturnType;
 
       if (type === "sign-up") {
@@ -274,19 +255,6 @@ export class InAppNativeConnector implements InAppConnector {
         });
       }
 
-      const toStoreToken: AuthStoredTokenWithCookieReturnType["storedToken"] = {
-        jwtToken: authToken.storedToken.jwtToken,
-        authDetails: authToken.storedToken.authDetails,
-        authProvider: authToken.storedToken.authProvider,
-        developerClientId: authToken.storedToken.developerClientId,
-        cookieString: authToken.storedToken.cookieString,
-        // we should always store the jwt cookie since there's no concept of cookie in react native
-        shouldStoreCookieString: true,
-        isNewUser: authToken.storedToken.isNewUser,
-      };
-
-      await postAuth({ storedToken: toStoreToken, client });
-
       return authToken;
     } catch (error) {
       console.error(
@@ -299,160 +267,19 @@ export class InAppNativeConnector implements InAppConnector {
     }
   }
 
-  private async validateOtp(
-    options: MultiStepAuthArgsType & {
-      client: ThirdwebClient;
-      ecosystem?: Ecosystem;
-    },
-  ): Promise<AuthLoginReturnType> {
-    try {
-      const { storedToken } = await otpLogin(options);
-      const account = await this.getAccount();
-      return {
-        user: {
-          status: UserWalletStatus.LOGGED_IN_WALLET_INITIALIZED,
-          account,
-          authDetails: storedToken.authDetails,
-          walletAddress: account.address,
-        },
-      };
-    } catch (error) {
-      console.error(`Error while validating OTP: ${error}`);
-      if (error instanceof Error) {
-        throw new Error(`Error while validating otp: ${error.message}`);
-      }
-      throw new Error("An unknown error occurred while validating otp");
-    }
-  }
-
   // TODO (rn) expose in the interface
   async deleteActiveAccount() {
-    return deleteActiveAccount({ client: this.client });
-  }
-
-  private async socialLogin(
-    auth: OAuthRedirectObject,
-  ): Promise<AuthLoginReturnType> {
-    try {
-      const { storedToken } = await socialLogin(auth, this.client);
-      const account = await this.getAccount();
-      return {
-        user: {
-          status: UserWalletStatus.LOGGED_IN_WALLET_INITIALIZED,
-          account,
-          authDetails: storedToken.authDetails,
-          walletAddress: account.address,
-        },
-      };
-    } catch (error) {
-      console.error(`Error while signing in with: ${auth}. ${error}`);
-      if (error instanceof Error) {
-        throw new Error(`Error signing in with ${auth}: ${error.message}`);
-      }
-      throw new Error(`An unknown error occurred signing in with ${auth}`);
-    }
-  }
-
-  private async siweLogin(options: {
-    wallet: Wallet;
-    chain: Chain;
-  }): Promise<AuthLoginReturnType> {
-    try {
-      const { storedToken } = await siweLogin(
-        this.client,
-        options.wallet,
-        options.chain,
-      );
-      const account = await this.getAccount();
-      return {
-        user: {
-          status: UserWalletStatus.LOGGED_IN_WALLET_INITIALIZED,
-          account,
-          authDetails: storedToken.authDetails,
-          walletAddress: account.address,
-        },
-      };
-    } catch (error) {
-      console.error(
-        `Error while signing in with: ${options.wallet.id}. ${error}`,
-      );
-      if (error instanceof Error) {
-        throw new Error(
-          `Error signing in with ${options.wallet.id}: ${error.message}`,
-        );
-      }
-      throw new Error(
-        `An unknown error occurred signing in with ${options.wallet.id}`,
-      );
-    }
-  }
-
-  private async guestLogin(options: {
-    ecosystem?: Ecosystem;
-  }): Promise<AuthLoginReturnType> {
-    try {
-      const { storedToken } = await guestLogin(this.client, options.ecosystem);
-      const account = await this.getAccount();
-      return {
-        user: {
-          status: UserWalletStatus.LOGGED_IN_WALLET_INITIALIZED,
-          account,
-          authDetails: storedToken.authDetails,
-          walletAddress: account.address,
-        },
-      };
-    } catch (error) {
-      if (error instanceof Error) {
-        throw new Error(`Error generating guest account: ${error.message}`);
-      }
-      throw new Error("An unknown error occurred generating guest account");
-    }
-  }
-
-  private async customJwt(authOptions: {
-    jwt: string;
-    password: string;
-  }): Promise<AuthLoginReturnType> {
-    try {
-      const { storedToken } = await customJwt(authOptions, this.client);
-      const account = await this.getAccount();
-      return {
-        user: {
-          status: UserWalletStatus.LOGGED_IN_WALLET_INITIALIZED,
-          account,
-          authDetails: storedToken.authDetails,
-          walletAddress: account.address,
-        },
-      };
-    } catch (error) {
-      console.error(`Error while verifying auth: ${error}`);
-      throw error;
-    }
-  }
-
-  private async authEndpoint(authOptions: {
-    payload: string;
-    encryptionKey: string;
-  }): Promise<AuthLoginReturnType> {
-    try {
-      const { storedToken } = await authEndpoint(authOptions, this.client);
-      const account = await this.getAccount();
-      return {
-        user: {
-          status: UserWalletStatus.LOGGED_IN_WALLET_INITIALIZED,
-          account,
-          authDetails: storedToken.authDetails,
-          walletAddress: account.address,
-        },
-      };
-    } catch (error) {
-      console.error(`Error while verifying auth_endpoint auth: ${error}`);
-      throw error;
-    }
+    return deleteActiveAccount({
+      client: this.client,
+      storage: this.localStorage,
+    });
   }
 
   logout(): Promise<LogoutReturnType> {
-    return logoutUser(this.client.clientId);
+    return logoutUser({
+      client: this.client,
+      storage: this.localStorage,
+    });
   }
 
   async linkProfile(args: AuthArgsType) {
@@ -472,7 +299,3 @@ export class InAppNativeConnector implements InAppConnector {
     });
   }
 }
-
-function assertUnreachable(x: never): never {
-  throw new Error(`Invalid param: ${x}`);
-}

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

@@ -4,7 +4,7 @@ import type {
   CreateWalletArgs,
   EcosystemWalletId,
 } from "../../wallet-types.js";
-import { createEcosystemWallet } from "../core/wallet/ecosystem-core.js";
+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.
@@ -65,18 +65,24 @@ export function ecosystemWallet(
   ...args: CreateWalletArgs<EcosystemWalletId>
 ): Wallet<EcosystemWalletId> {
   const [ecosystemId, createOptions] = args;
-  return createEcosystemWallet({
+  const ecosystem = {
     id: ecosystemId,
-    createOptions,
+    partnerId: createOptions?.partnerId,
+  };
+  return createInAppWallet({
+    ecosystem,
+    createOptions: {
+      auth: {
+        ...createOptions?.auth,
+        options: [], // controlled by ecosystem
+      },
+    },
     connectorFactory: async (client: ThirdwebClient) => {
       const { InAppWebConnector } = await import("./lib/web-connector.js");
       return new InAppWebConnector({
         client,
-        ecosystem: {
-          id: ecosystemId,
-          partnerId: createOptions?.partnerId,
-        },
+        ecosystem,
       });
     },
-  });
+  }) as Wallet<EcosystemWalletId>;
 }

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

@@ -206,5 +206,5 @@ export function inAppWallet(
         passkeyDomain: createOptions?.auth?.passkeyDomain,
       });
     },
-  });
+  }) as Wallet<"inApp">;
 }

package/src/wallets/in-app/web/lib/actions/get-enclave-user-status.ts

@@ -1,8 +1,8 @@
 import type { ThirdwebClient } from "../../../../../client/client.js";
 import { getThirdwebBaseUrl } from "../../../../../utils/domains.js";
 import { getClientFetch } from "../../../../../utils/fetch.js";
+import type { UserStatus } from "../../../core/wallet/enclave-wallet.js";
 import type { Ecosystem } from "../../../core/wallet/types.js";
-import type { UserStatus } from "../../lib/enclave-wallet.js";
 
 /**
  * Gets the user's status from the backend.
@@ -32,11 +32,13 @@ export async function getUserStatus({
   );
 
   if (!response.ok) {
+    console.log("response", response.status);
     if (response.status === 401) {
       // 401 response indicates there is no user logged in, so we return undefined
       return undefined;
     }
     const result = await response.json();
+    console.log("result", result);
     throw new Error(`Failed to get user status: ${result.error}`);
   }
 

package/src/wallets/in-app/web/lib/actions/sign-message.enclave.ts

@@ -2,13 +2,14 @@ import type { ThirdwebClient } from "../../../../../client/client.js";
 import { getThirdwebBaseUrl } from "../../../../../utils/domains.js";
 import { getClientFetch } from "../../../../../utils/fetch.js";
 import { stringify } from "../../../../../utils/json.js";
+import type { ClientScopedStorage } from "../../../core/authentication/client-scoped-storage.js";
 import type { Ecosystem } from "../../../core/wallet/types.js";
-import { getAuthToken } from "../get-auth-token.js";
 
 export async function signMessage({
   client,
   ecosystem,
   payload: { message, isRaw },
+  storage,
 }: {
   client: ThirdwebClient;
   ecosystem?: Ecosystem;
@@ -16,9 +17,10 @@ export async function signMessage({
     message: string;
     isRaw: boolean;
   };
+  storage: ClientScopedStorage;
 }) {
   const clientFetch = getClientFetch(client, ecosystem);
-  const authToken = await getAuthToken(client, ecosystem); // TODO (enclave): pass storage from web/native
+  const authToken = await storage.getAuthCookie();
 
   const response = await clientFetch(
     `${getThirdwebBaseUrl("inAppWallet")}/api/v1/enclave-wallet/sign-message`,

package/src/wallets/in-app/web/lib/actions/sign-transaction.enclave.ts

@@ -3,21 +3,23 @@ import { getThirdwebBaseUrl } from "../../../../../utils/domains.js";
 import type { Hex } from "../../../../../utils/encoding/hex.js";
 import { getClientFetch } from "../../../../../utils/fetch.js";
 import { stringify } from "../../../../../utils/json.js";
+import type { ClientScopedStorage } from "../../../core/authentication/client-scoped-storage.js";
 import type { Ecosystem } from "../../../core/wallet/types.js";
-import { getAuthToken } from "../get-auth-token.js";
 
 export async function signTransaction({
   client,
   ecosystem,
   payload,
+  storage,
 }: {
   client: ThirdwebClient;
   ecosystem?: Ecosystem;
   payload: Record<string, Hex | number | undefined>;
+  storage: ClientScopedStorage;
 }) {
   console.log("payload", payload);
   const clientFetch = getClientFetch(client, ecosystem);
-  const authToken = await getAuthToken(client, ecosystem); // TODO (enclave): pass storage from web/native
+  const authToken = await storage.getAuthCookie();
 
   const response = await clientFetch(
     `${getThirdwebBaseUrl("inAppWallet")}/api/v1/enclave-wallet/sign-transaction`,

package/src/wallets/in-app/web/lib/actions/sign-typed-data.enclave.ts

@@ -4,8 +4,8 @@ import type { ThirdwebClient } from "../../../../../client/client.js";
 import { getThirdwebBaseUrl } from "../../../../../utils/domains.js";
 import { getClientFetch } from "../../../../../utils/fetch.js";
 import { stringify } from "../../../../../utils/json.js";
+import type { ClientScopedStorage } from "../../../core/authentication/client-scoped-storage.js";
 import type { Ecosystem } from "../../../core/wallet/types.js";
-import { getAuthToken } from "../get-auth-token.js";
 
 export async function signTypedData<
   const typedData extends TypedData | Record<string, unknown>,
@@ -14,13 +14,15 @@ export async function signTypedData<
   client,
   ecosystem,
   payload,
+  storage,
 }: {
   client: ThirdwebClient;
   ecosystem?: Ecosystem;
   payload: TypedDataDefinition<typedData, primaryType>;
+  storage: ClientScopedStorage;
 }) {
   const clientFetch = getClientFetch(client, ecosystem);
-  const authToken = await getAuthToken(client, ecosystem); // TODO (enclave): pass storage from web/native
+  const authToken = await storage.getAuthCookie();
 
   const response = await clientFetch(
     `${getThirdwebBaseUrl("inAppWallet")}/api/v1/enclave-wallet/sign-typed-data`,

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

@@ -321,6 +321,13 @@ export class Auth {
    * @internal
    */
   async logout(): Promise<LogoutReturnType> {
+    if (this.AuthQuerier) {
+      await this.AuthQuerier.call<LogoutReturnType>({
+        procedureName: "logout",
+        params: undefined,
+      });
+    }
+
     const isRemoveAuthCookie = await this.localStorage.removeAuthCookie();
     const isRemoveUserId = await this.localStorage.removeWalletUserId();