thirdweb 5.57.3 → 5.58.0-nightly-3229e1f03c3cbb62ddc8dccf22ad8a8feb0a95f0-20240920000335

package/src/react/web/wallets/shared/oauthSignIn.ts

@@ -41,10 +41,11 @@ function getOauthLoginPath(
     case "line":
     case "x":
     case "guest":
+    case "coinbase":
     case "discord":
       return getLoginUrl({ authOption, client, ecosystem });
     default:
-      return "";
+      throw new Error(`Unsupported auth option: ${authOption}`);
   }
 }
 

package/src/utils/fetch.ts

@@ -32,19 +32,26 @@ export function getClientFetch(client: ThirdwebClient, ecosystem?: Ecosystem) {
       if (!headers) {
         headers = new Headers();
       }
+      // auth token if secret key === jwt
       const authToken =
         client.secretKey && isJWT(client.secretKey)
           ? client.secretKey
           : undefined;
+      // secret key if secret key !== jwt
+      const secretKey =
+        client.secretKey && !isJWT(client.secretKey)
+          ? client.secretKey
+          : undefined;
+      const clientId = client.clientId;
 
       // if we have an auth token set, use that (thirdweb.com/dashboard sets this for the user)
       // pay urls should never send the auth token, because we always want the "developer" to be the one making the request, not the "end user"
       if (authToken && !isPayUrl(url)) {
         headers.set("authorization", `Bearer ${authToken}`);
-      } else if (client.secretKey) {
-        headers.set("x-secret-key", client.secretKey);
-      } else if (client.clientId) {
-        headers.set("x-client-id", client.clientId);
+      } else if (secretKey) {
+        headers.set("x-secret-key", secretKey);
+      } else if (clientId) {
+        headers.set("x-client-id", clientId);
       }
 
       if (ecosystem) {

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.57.3";
+export const version = "5.58.0-nightly-3229e1f03c3cbb62ddc8dccf22ad8a8feb0a95f0-20240920000335";

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

@@ -67,6 +67,7 @@ export type AuthArgsType = (MultiStepAuthArgsType | SingleStepAuthArgsType) & {
 export enum RecoveryShareManagement {
   USER_MANAGED = "USER_MANAGED",
   CLOUD_MANAGED = "AWS_MANAGED",
+  ENCLAVE = "ENCLAVE",
 }
 
 // TODO: remove usage of enums, instead use object with as const
@@ -81,6 +82,7 @@ export enum AuthProvider {
   APPLE = "Apple",
   PASSKEY = "Passkey",
   DISCORD = "Discord",
+  COINBASE = "Coinbase",
   X = "X",
   LINE = "Line",
   FARCASTER = "Farcaster",
@@ -133,7 +135,8 @@ export type AuthStoredTokenWithCookieReturnType = {
   };
 };
 export type AuthAndWalletRpcReturnType = AuthStoredTokenWithCookieReturnType & {
-  walletDetails: SetUpWalletRpcReturnType;
+  // Will just be WalletAddressObjectType for enclave wallets
+  walletDetails: SetUpWalletRpcReturnType | WalletAddressObjectType;
 };
 
 export type AuthLoginReturnType = { user: InitializedUser };
@@ -151,6 +154,7 @@ export type AuthDetails = (
   encryptionKey?: string;
   backupRecoveryCodes?: string[];
   recoveryShareManagement: RecoveryShareManagement;
+  walletType?: "sharded" | "enclave";
 };
 
 export type InitializedUser = {

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

@@ -158,6 +158,7 @@ export class InAppNativeConnector implements InAppConnector {
       case "x":
       case "farcaster":
       case "telegram":
+      case "coinbase":
       case "apple": {
         const ExpoLinking = require("expo-linking");
         const redirectUrl =

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

@@ -15,6 +15,7 @@ import { createInAppWallet } from "../core/wallet/in-app-core.js";
  * - Apple
  * - Facebook
  * - Discord
+ * - Coinbase
  * - Telegram
  * - LINE
  * - X

package/src/wallets/in-app/web/lib/actions/generate-wallet.enclave.ts

@@ -0,0 +1,44 @@
+import type { ThirdwebClient } from "../../../../../client/client.js";
+import { getThirdwebBaseUrl } from "../../../../../utils/domains.js";
+import { getClientFetch } from "../../../../../utils/fetch.js";
+import type { Ecosystem } from "../../types.js";
+
+/**
+ * Generate a new enclave wallet using an auth token
+ * @internal
+ */
+export async function generateWallet({
+  authToken,
+  client,
+  ecosystem,
+}: {
+  client: ThirdwebClient;
+  ecosystem: Ecosystem;
+  authToken: string;
+}) {
+  const clientFetch = getClientFetch(client, ecosystem);
+  const response = await clientFetch(
+    `${getThirdwebBaseUrl("inAppWallet")}/api/v1/enclave-wallet/generate`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-thirdweb-client-id": client.clientId,
+        Authorization: `Bearer embedded-wallet-token:${authToken}`,
+      },
+    },
+  );
+
+  if (!response.ok) {
+    throw new Error("Failed to generate wallet");
+  }
+
+  const { wallet } = (await response.json()) as {
+    wallet: {
+      address: string;
+      type: "enclave";
+    };
+  };
+
+  return wallet;
+}

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

@@ -0,0 +1,44 @@
+import type { ThirdwebClient } from "../../../../../client/client.js";
+import { getThirdwebBaseUrl } from "../../../../../utils/domains.js";
+import { getClientFetch } from "../../../../../utils/fetch.js";
+import type { UserStatus } from "../../lib/enclave-wallet.js";
+import type { Ecosystem } from "../../types.js";
+
+/**
+ * Gets the user's status from the backend.
+ *
+ * @internal
+ */
+export async function getEnclaveUserStatus({
+  authToken,
+  client,
+  ecosystem,
+}: {
+  authToken: string;
+  client: ThirdwebClient;
+  ecosystem?: Ecosystem;
+}): Promise<UserStatus | undefined> {
+  const clientFetch = getClientFetch(client, ecosystem);
+  const response = await clientFetch(
+    `${getThirdwebBaseUrl("inAppWallet")}/api/2024-05-05/accounts`,
+    {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        "x-thirdweb-client-id": client.clientId,
+        Authorization: `Bearer embedded-wallet-token:${authToken}`,
+      },
+    },
+  );
+
+  if (!response.ok) {
+    if (response.status === 401) {
+      // 401 response indicates there is no user logged in, so we return undefined
+      return undefined;
+    }
+    const result = await response.json();
+    throw new Error(`Failed to get user status: ${result.error}`);
+  }
+
+  return (await response.json()) as UserStatus;
+}

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

@@ -0,0 +1,52 @@
+import type { ThirdwebClient } from "../../../../../client/client.js";
+import { getThirdwebBaseUrl } from "../../../../../utils/domains.js";
+import { getClientFetch } from "../../../../../utils/fetch.js";
+import type { Ecosystem } from "../../types.js";
+import { getAuthToken } from "../get-auth-token.js";
+
+export async function signMessage({
+  client,
+  ecosystem,
+  payload: { message, isRaw },
+}: {
+  client: ThirdwebClient;
+  ecosystem?: Ecosystem;
+  payload: {
+    message: string;
+    isRaw: boolean;
+  };
+}) {
+  const clientFetch = getClientFetch(client, ecosystem);
+  const authToken = await getAuthToken(client, ecosystem);
+
+  const response = await clientFetch(
+    `${getThirdwebBaseUrl("inAppWallet")}/api/v1/enclave-wallet/sign-message`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-thirdweb-client-id": client.clientId,
+        Authorization: `Bearer embedded-wallet-token:${authToken}`,
+      },
+      body: JSON.stringify({
+        messagePayload: {
+          message,
+          isRaw,
+        },
+      }),
+    },
+  );
+
+  if (!response.ok) {
+    throw new Error("Failed to sign message");
+  }
+
+  const signedMessage = (await response.json()) as {
+    r: string;
+    s: string;
+    v: number;
+    signature: string;
+    hash: string;
+  };
+  return signedMessage;
+}

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

@@ -0,0 +1,48 @@
+import type { ThirdwebClient } from "../../../../../client/client.js";
+import { getThirdwebBaseUrl } from "../../../../../utils/domains.js";
+import type { Hex } from "../../../../../utils/encoding/hex.js";
+import { getClientFetch } from "../../../../../utils/fetch.js";
+import type { Ecosystem } from "../../types.js";
+import { getAuthToken } from "../get-auth-token.js";
+
+export async function signTransaction({
+  client,
+  ecosystem,
+  payload,
+}: {
+  client: ThirdwebClient;
+  ecosystem?: Ecosystem;
+  payload: Record<string, Hex | number | undefined>;
+}) {
+  console.log("payload", payload);
+  const clientFetch = getClientFetch(client, ecosystem);
+  const authToken = await getAuthToken(client, ecosystem);
+
+  const response = await clientFetch(
+    `${getThirdwebBaseUrl("inAppWallet")}/api/v1/enclave-wallet/sign-transaction`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-thirdweb-client-id": client.clientId,
+        Authorization: `Bearer embedded-wallet-token:${authToken}`,
+      },
+      body: JSON.stringify({
+        transactionPayload: payload,
+      }),
+    },
+  );
+
+  if (!response.ok) {
+    throw new Error("Failed to sign transaction");
+  }
+
+  const signedTransaction = (await response.json()) as {
+    r: string;
+    s: string;
+    v: number;
+    signature: string;
+    hash: string;
+  };
+  return signedTransaction.signature as Hex;
+}

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

@@ -0,0 +1,51 @@
+import type { TypedData } from "abitype";
+import type { TypedDataDefinition } from "viem";
+import type { ThirdwebClient } from "../../../../../client/client.js";
+import { getThirdwebBaseUrl } from "../../../../../utils/domains.js";
+import { getClientFetch } from "../../../../../utils/fetch.js";
+import type { Ecosystem } from "../../types.js";
+import { getAuthToken } from "../get-auth-token.js";
+
+export async function signTypedData<
+  const typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
+>({
+  client,
+  ecosystem,
+  payload,
+}: {
+  client: ThirdwebClient;
+  ecosystem?: Ecosystem;
+  payload: TypedDataDefinition<typedData, primaryType>;
+}) {
+  const clientFetch = getClientFetch(client, ecosystem);
+  const authToken = await getAuthToken(client, ecosystem);
+
+  const response = await clientFetch(
+    `${getThirdwebBaseUrl("inAppWallet")}/api/v1/enclave-wallet/sign-typed-data`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-thirdweb-client-id": client.clientId,
+        Authorization: `Bearer embedded-wallet-token:${authToken}`,
+      },
+      body: JSON.stringify({
+        ...payload,
+      }),
+    },
+  );
+
+  if (!response.ok) {
+    throw new Error("Failed to sign typed data");
+  }
+
+  const signedTypedData = (await response.json()) as {
+    r: string;
+    s: string;
+    v: number;
+    signature: string;
+    hash: string;
+  };
+  return signedTypedData;
+}

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

@@ -10,6 +10,8 @@ import type {
 } from "../../../core/authentication/types.js";
 import type { ClientIdWithQuerierType, Ecosystem } from "../../types.js";
 import type { InAppWalletIframeCommunicator } from "../../utils/iFrameCommunication/InAppWalletIframeCommunicator.js";
+import { generateWallet } from "../actions/generate-wallet.enclave.js";
+import { getEnclaveUserStatus } from "../actions/get-enclave-user-status.js";
 import { BaseLogin } from "./base-login.js";
 
 export type AuthQuerierTypes = {
@@ -20,7 +22,7 @@ export type AuthQuerierTypes = {
     clientId: string;
     authCookie: string;
     walletUserId: string;
-    deviceShareStored: string;
+    deviceShareStored: string | null;
   };
   loginWithStoredTokenDetails: {
     storedToken: AuthStoredTokenWithCookieReturnType["storedToken"];
@@ -33,6 +35,7 @@ export type AuthQuerierTypes = {
  */
 export class Auth {
   protected client: ThirdwebClient;
+  protected ecosystem?: Ecosystem;
   protected AuthQuerier: InAppWalletIframeCommunicator<AuthQuerierTypes>;
   protected localStorage: ClientScopedStorage;
   protected onAuthSuccess: (
@@ -58,6 +61,7 @@ export class Auth {
     ) => Promise<AuthLoginReturnType>;
   }) {
     this.client = client;
+    this.ecosystem = ecosystem;
 
     this.AuthQuerier = querier;
     this.localStorage = new ClientScopedStorage({
@@ -103,6 +107,42 @@ export class Auth {
     recoveryCode?: string,
   ): Promise<AuthLoginReturnType> {
     await this.preLogin();
+
+    const user = await getEnclaveUserStatus({
+      authToken: authToken.storedToken.cookieString,
+      client: this.client,
+      ecosystem: this.ecosystem,
+    });
+    if (!user) {
+      throw new Error("Cannot login, no user found for auth token");
+    }
+
+    // If they're already an enclave wallet, proceed to login
+    if (user.wallets.length > 0 && user.wallets[0]?.type === "enclave") {
+      return this.postLogin({
+        storedToken: authToken.storedToken,
+        walletDetails: {
+          walletAddress: user.wallets[0].address,
+        },
+      });
+    }
+
+    if (user.wallets.length === 0 && this.ecosystem) {
+      // If this is a new ecosystem wallet without an enclave yet, we'll generate an enclave
+      const result = await generateWallet({
+        authToken: authToken.storedToken.cookieString,
+        client: this.client,
+        ecosystem: this.ecosystem,
+      });
+      return this.postLogin({
+        storedToken: authToken.storedToken,
+        walletDetails: {
+          walletAddress: result.address,
+        },
+      });
+    }
+
+    // If this is an existing sharded wallet or in-app wallet, we'll login with the sharded wallet
     const result = await this.AuthQuerier.call<AuthAndWalletRpcReturnType>({
       procedureName: "loginWithStoredTokenDetails",
       params: {
@@ -280,15 +320,11 @@ export class Auth {
    * @internal
    */
   async logout(): Promise<LogoutReturnType> {
-    const { success } = await this.AuthQuerier.call<LogoutReturnType>({
-      procedureName: "logout",
-      params: undefined,
-    });
     const isRemoveAuthCookie = await this.localStorage.removeAuthCookie();
     const isRemoveUserId = await this.localStorage.removeWalletUserId();
 
     return {
-      success: success || isRemoveAuthCookie || isRemoveUserId,
+      success: isRemoveAuthCookie || isRemoveUserId,
     };
   }
 }

package/src/wallets/in-app/web/lib/enclave-wallet.ts

@@ -0,0 +1,244 @@
+import { bytesToHex } from "viem";
+import { getCachedChain } from "../../../../chains/utils.js";
+import type { ThirdwebClient } from "../../../../client/client.js";
+import { eth_sendRawTransaction } from "../../../../rpc/actions/eth_sendRawTransaction.js";
+import { getRpcClient } from "../../../../rpc/rpc.js";
+import { getAddress } from "../../../../utils/address.js";
+import { type Hex, toHex } from "../../../../utils/encoding/hex.js";
+import { parseTypedData } from "../../../../utils/signatures/helpers/parseTypedData.js";
+import { webLocalStorage } from "../../../../utils/storage/webStorage.js";
+import type { Prettify } from "../../../../utils/type-utils.js";
+import type {
+  Account,
+  SendTransactionOption,
+} from "../../../interfaces/wallet.js";
+import { ClientScopedStorage } from "../../core/authentication/client-scoped-storage.js";
+import {
+  type GetUser,
+  RecoveryShareManagement,
+  UserWalletStatus,
+  type WalletAddressObjectType,
+} from "../../core/authentication/types.js";
+import type { Ecosystem } from "../types.js";
+import { getEnclaveUserStatus } from "./actions/get-enclave-user-status.js";
+import { signMessage as signEnclaveMessage } from "./actions/sign-message.enclave.js";
+import { signTransaction as signEnclaveTransaction } from "./actions/sign-transaction.enclave.js";
+import { signTypedData as signEnclaveTypedData } from "./actions/sign-typed-data.enclave.js";
+import type { IWebWallet, PostWalletSetup } from "./web-wallet.js";
+
+export type UserStatus = {
+  linkedAccounts: {
+    type: string;
+    details:
+      | { email: string; [key: string]: string }
+      | { phone: string; [key: string]: string }
+      | { address: string; [key: string]: string }
+      | { id: string; [key: string]: string };
+  }[];
+  wallets:
+    | [
+        {
+          address: string;
+          createdAt: string;
+          type: "sharded" | "enclave";
+        },
+      ]
+    | [];
+  id: string;
+};
+
+export class EnclaveWallet implements IWebWallet {
+  public client: ThirdwebClient;
+  public ecosystem?: Ecosystem;
+  public address: string;
+  protected localStorage: ClientScopedStorage;
+
+  constructor({
+    client,
+    ecosystem,
+    address,
+  }: Prettify<{
+    client: ThirdwebClient;
+    ecosystem?: Ecosystem;
+    address: string;
+  }>) {
+    this.client = client;
+    this.ecosystem = ecosystem;
+    this.address = address;
+
+    this.localStorage = new ClientScopedStorage({
+      storage: webLocalStorage,
+      clientId: client.clientId,
+      ecosystemId: ecosystem?.id,
+    });
+  }
+
+  /**
+   * Store the auth token for use
+   * @returns `{walletAddress: string }` The user's wallet details
+   * @internal
+   */
+  async postWalletSetUp({
+    walletAddress,
+    authToken,
+  }: PostWalletSetup): Promise<WalletAddressObjectType> {
+    await this.localStorage.saveAuthCookie(authToken);
+    return { walletAddress };
+  }
+
+  /**
+   * Gets the current user's details
+   * @internal
+   */
+  async getUserWalletStatus(): Promise<GetUser> {
+    const token = await this.localStorage.getAuthCookie();
+    if (!token) {
+      return { status: UserWalletStatus.LOGGED_OUT };
+    }
+
+    const userStatus = await getEnclaveUserStatus({
+      authToken: token,
+      client: this.client,
+      ecosystem: this.ecosystem,
+    });
+    if (!userStatus) {
+      return { status: UserWalletStatus.LOGGED_OUT };
+    }
+    const wallet = userStatus.wallets[0];
+
+    const authDetails = {
+      email: userStatus.linkedAccounts.find(
+        (account) => account.type === "email",
+      )?.details.email,
+      phoneNumber: userStatus.linkedAccounts.find(
+        (account) => account.type === "phone",
+      )?.details.phone,
+      userWalletId: userStatus.id || "",
+      recoveryShareManagement: RecoveryShareManagement.ENCLAVE,
+    };
+
+    if (!wallet) {
+      return {
+        status: UserWalletStatus.LOGGED_IN_WALLET_UNINITIALIZED,
+        authDetails,
+      };
+    }
+
+    return {
+      status: UserWalletStatus.LOGGED_IN_WALLET_INITIALIZED,
+      walletAddress: wallet.address,
+      authDetails,
+      account: await this.getAccount(),
+    };
+  }
+
+  /**
+   * Returns an account to perform wallet operations
+   * @internal
+   */
+  async getAccount(): Promise<Account> {
+    const client = this.client;
+    const ecosystem = this.ecosystem;
+
+    const _signTransaction = async (tx: SendTransactionOption) => {
+      const rpcRequest = getRpcClient({
+        client,
+        chain: getCachedChain(tx.chainId),
+      });
+      const transaction: Record<string, Hex | number | undefined> = {
+        to: (tx.to as Hex) ?? undefined,
+        data: tx.data ? toHex(tx.data) : undefined,
+        value: tx.value ? toHex(tx.value) : undefined,
+        gas: tx.gas ? toHex(tx.gas + tx.gas / BigInt(10)) : undefined, // Add a 10% buffer to gas
+        nonce: tx.nonce
+          ? toHex(tx.nonce)
+          : toHex(
+              await import(
+                "../../../../rpc/actions/eth_getTransactionCount.js"
+              ).then(({ eth_getTransactionCount }) =>
+                eth_getTransactionCount(rpcRequest, {
+                  address: this.address,
+                  blockTag: "pending",
+                }),
+              ),
+            ),
+        chainId: toHex(tx.chainId),
+      };
+
+      if (tx.maxFeePerGas) {
+        transaction.maxFeePerGas = toHex(tx.maxFeePerGas);
+        transaction.maxPriorityFeePerGas = tx.maxPriorityFeePerGas
+          ? toHex(tx.maxPriorityFeePerGas)
+          : undefined;
+        transaction.type = 2;
+      } else {
+        transaction.gasPrice = tx.gasPrice ? toHex(tx.gasPrice) : undefined;
+        transaction.type = 0;
+      }
+
+      return signEnclaveTransaction({
+        client,
+        ecosystem,
+        payload: transaction,
+      });
+    };
+    return {
+      address: getAddress(this.address),
+      async signTransaction(tx) {
+        if (!tx.chainId) {
+          throw new Error("chainId required in tx to sign");
+        }
+
+        return _signTransaction({
+          chainId: tx.chainId,
+          ...tx,
+        });
+      },
+      async sendTransaction(tx) {
+        const rpcRequest = getRpcClient({
+          client,
+          chain: getCachedChain(tx.chainId),
+        });
+        const signedTx = await _signTransaction(tx);
+        const transactionHash = await eth_sendRawTransaction(
+          rpcRequest,
+          signedTx,
+        );
+        return {
+          transactionHash,
+        };
+      },
+      async signMessage({ message }) {
+        const messagePayload = (() => {
+          if (typeof message === "string") {
+            return { message, isRaw: false };
+          }
+          return {
+            message:
+              typeof message.raw === "string"
+                ? message.raw
+                : bytesToHex(message.raw),
+            isRaw: true,
+          };
+        })();
+
+        const { signature } = await signEnclaveMessage({
+          client,
+          ecosystem,
+          payload: messagePayload,
+        });
+        return signature as Hex;
+      },
+      async signTypedData(_typedData) {
+        const parsedTypedData = parseTypedData(_typedData);
+        const { signature } = await signEnclaveTypedData({
+          client,
+          ecosystem,
+          payload: parsedTypedData,
+        });
+
+        return signature as Hex;
+      },
+    };
+  }
+}