thirdweb 5.36.1-nightly-af4acc4319fdfb323778694bd8843bd695e52d6b-20240719161043 → 5.37.0

package/src/transaction/prepare-contract-call.test.ts

@@ -1,13 +1,11 @@
-import { describe, expect, test } from "vitest";
-
+import { describe, expect, it } from "vitest";
 import { TEST_WALLET_B } from "../../test/src/addresses.js";
-
 import { USDT_CONTRACT_WITH_ABI } from "../../test/src/test-contracts.js";
 import { toWei } from "../utils/units.js";
 import { prepareContractCall } from "./prepare-contract-call.js";
 
-describe("prepareContractCall", () => {
-  test("should prepare a contract call with ABI", () => {
+describe.runIf(process.env.TW_SECRET_KEY)("prepareContractCall", () => {
+  it("should prepare a contract call with ABI", () => {
     const preparedTx = prepareContractCall({
       contract: USDT_CONTRACT_WITH_ABI,
       method: "transfer",

package/src/transaction/prepare-contract-call.ts

@@ -121,6 +121,23 @@ export type PrepareContractCallOptions<
  *  params: [to, value],
  * });
  * ```
+ *
+ * @example
+ * Passing extra call data to the transaction
+ * ```ts
+ * import { getContract, prepareContractCall } from "thirdweb";
+ * const contract = getContract({
+ *   ..., // chain, address, client
+ * });
+ *
+ * const transaction = prepareContractCall({
+ *   contract,
+ *   method: "function transfer(address to, uint256 value)",
+ *   params: [...],
+ *   // The extra call data MUST be encoded to hex before passing
+ *   extraCallData: "0x......."
+ * });
+ * ```
  */
 export function prepareContractCall<
   const TAbi extends Abi,

package/src/transaction/prepare-transaction.ts

@@ -24,6 +24,7 @@ export type StaticPrepareTransactionOptions = {
   chain: Chain;
   client: ThirdwebClient;
   // extras
+  extraCallData?: Hex;
   erc20Value?: {
     amountWei: bigint;
     tokenAddress: Address;

package/src/utils/promise/wait.test.ts

@@ -8,6 +8,6 @@ describe("wait", () => {
     await wait(ms);
     const end = Date.now();
     const elapsed = end - start;
-    expect(elapsed).toBeGreaterThanOrEqual(ms);
+    expect(Math.abs(elapsed - ms)).toBeLessThan(10);
   });
 });

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.36.1-nightly-af4acc4319fdfb323778694bd8843bd695e52d6b-20240719161043";
+export const version = "5.37.0";

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

@@ -0,0 +1,18 @@
+import type { ThirdwebClient } from "../../../../client/client.js";
+import { getThirdwebBaseUrl } from "../../../../utils/domains.js";
+import type { Ecosystem } from "../../web/types.js";
+
+// TODO: make this generic for all auth providers
+export const getDiscordLoginPath = (
+  client: ThirdwebClient,
+  ecosystem?: Ecosystem,
+) => {
+  const baseUrl = `${getThirdwebBaseUrl("inAppWallet")}/api/2024-05-05/login/discord?clientId=${client.clientId}`;
+  if (ecosystem?.partnerId) {
+    return `${baseUrl}&ecosystemId=${ecosystem.id}&ecosystemPartnerId=${ecosystem.partnerId}`;
+  }
+  if (ecosystem) {
+    return `${baseUrl}&ecosystemId=${ecosystem.id}`;
+  }
+  return baseUrl;
+};

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

@@ -61,6 +61,7 @@ export enum AuthProvider {
   FACEBOOK = "Facebook",
   APPLE = "Apple",
   PASSKEY = "Passkey",
+  DISCORD = "Discord",
 }
 
 export type OauthOption = {
@@ -208,10 +209,11 @@ export type GetAuthenticatedUserParams = {
 };
 
 export const oauthStrategyToAuthProvider: Record<
-  "google" | "facebook" | "apple",
+  SocialAuthOption,
   AuthProvider
 > = {
   google: AuthProvider.GOOGLE,
   facebook: AuthProvider.FACEBOOK,
   apple: AuthProvider.APPLE,
+  discord: AuthProvider.DISCORD,
 };

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

@@ -3,6 +3,7 @@ import type { CognitoUser } from "amazon-cognito-identity-js";
 import { Auth } from "aws-amplify";
 import * as WebBrowser from "expo-web-browser";
 import type { ThirdwebClient } from "../../../../client/client.js";
+import { getDiscordLoginPath } from "../../core/authentication/getLoginPath.js";
 import {
   AuthProvider,
   type AuthStoredTokenWithCookieReturnType,
@@ -229,15 +230,24 @@ export async function socialLogin(
 
   const { platformLoginLink } = json;
 
-  const completeLoginUrl = `${platformLoginLink}?developerClientId=${encodeURIComponent(
-    client.clientId,
-  )}&platform=${encodeURIComponent("mobile")}&redirectUrl=${encodeURIComponent(
-    oauthOptions.redirectUrl,
-  )}&authOption=${encodedProvider}`;
+  // Temporary fork for discord until we migrate all methods to the new auth flow
+  const loginUrl = (() => {
+    if (oauthOptions.provider === AuthProvider.DISCORD) {
+      return `${getDiscordLoginPath(client)}&redirectUrl=${encodeURIComponent(
+        oauthOptions.redirectUrl,
+      )}`;
+    } else {
+      return `${platformLoginLink}?developerClientId=${encodeURIComponent(
+        client.clientId,
+      )}&platform=${encodeURIComponent("mobile")}&redirectUrl=${encodeURIComponent(
+        oauthOptions.redirectUrl,
+      )}&authOption=${encodedProvider}`;
+    }
+  })();
 
   // TODO platform specific code should be extracted out
   const result = await WebBrowser.openAuthSessionAsync(
-    completeLoginUrl,
+    loginUrl,
     oauthOptions.redirectUrl,
     {
       preferEphemeralSession: false,

package/src/wallets/in-app/native/helpers/auth/middleware.ts

@@ -11,7 +11,10 @@ import {
   setWallerUserDetails,
 } from "../storage/local.js";
 import { setUpNewUserWallet } from "../wallet/creation.js";
-import { getCognitoRecoveryPassword } from "../wallet/recoveryCode.js";
+import {
+  getCognitoRecoveryPasswordV1,
+  getCognitoRecoveryPasswordV2,
+} from "../wallet/recoveryCode.js";
 import { setUpShareForNewDevice } from "../wallet/retrieval.js";
 
 export async function preAuth(args: {
@@ -151,7 +154,10 @@ async function getRecoveryCode(
       return recoveryCode;
     } else {
       try {
-        const code = await getCognitoRecoveryPassword(client);
+        // temporary fork for discord until we migrate all methods to the new auth flow
+        const code = await (storedToken.authProvider === AuthProvider.DISCORD
+          ? getCognitoRecoveryPasswordV2(client)
+          : getCognitoRecoveryPasswordV1(client));
         return code;
       } catch (e) {
         throw new Error("Something went wrong getting cognito recovery code");

package/src/wallets/in-app/native/helpers/constants.ts

@@ -1,3 +1,5 @@
+import { getThirdwebBaseUrl } from "../../../../utils/domains.js";
+
 export const AUTH_SHARE_ID = 3;
 export const AUTH_SHARE_INDEX = AUTH_SHARE_ID - 1;
 export const NO_EXISTING_WALLET_FOUND_FOR_USER =
@@ -19,13 +21,18 @@ export const COGNITO_USER_POOL_ID = "us-west-2_UFwLcZIpq";
 export const COGNITO_APP_CLIENT_ID = "2e02ha2ce6du13ldk8pai4h3d0";
 export const COGNITO_IDENTITY_POOL_ID =
   "us-west-2:2ad7ab1e-f48b-48a6-adfa-ac1090689c26";
-export const GENERATE_RECOVERY_PASSWORD_LAMBDA_FUNCTION =
+export const GENERATE_RECOVERY_PASSWORD_LAMBDA_FUNCTION_V1 =
   "arn:aws:lambda:us-west-2:324457261097:function:recovery-share-password-GenerateRecoverySharePassw-bbE5ZbVAToil";
+export const GENERATE_RECOVERY_PASSWORD_LAMBDA_FUNCTION_V2 =
+  "arn:aws:lambda:us-west-2:324457261097:function:lambda-thirdweb-auth-enc-key-prod-ThirdwebAuthEncKeyFunction";
+export const GENERATE_RECOVERY_PASSWORD_LAMBDA_FUNCTION =
+  GENERATE_RECOVERY_PASSWORD_LAMBDA_FUNCTION_V2;
 
 // TODO allow overriding domain
-export const DOMAIN_URL_2023 = "https://embedded-wallet.thirdweb.com";
+export const DOMAIN_URL_2023 = getThirdwebBaseUrl("inAppWallet");
 const BASE_URL_2023 = `${DOMAIN_URL_2023}/`;
 const ROUTE_2023_10_20_API_BASE_PATH = `${BASE_URL_2023}api/2023-10-20`;
+const ROUTE_2024_05_05_API_BASE_PATH = `${BASE_URL_2023}api/2024-05-05`;
 
 export const ROUTE_EMBEDDED_WALLET_DETAILS = `${ROUTE_2023_10_20_API_BASE_PATH}/embedded-wallet/embedded-wallet-user-details`;
 export const ROUTE_VERIFY_COGNITO_OTP = `${ROUTE_2023_10_20_API_BASE_PATH}/embedded-wallet/validate-cognito-email-otp`;
@@ -43,4 +50,6 @@ export const ROUTE_IS_VALID_USER_MANAGED_OTP = `${ROUTE_2023_10_20_API_BASE_PATH
 
 export const ROUTE_HEADLESS_OAUTH_LOGIN = `${ROUTE_2023_10_20_API_BASE_PATH}/embedded-wallet/headless-oauth-login-link`;
 
-export const ROUTE_AUTH_COGNITO_ID_TOKEN = `${ROUTE_2023_10_20_API_BASE_PATH}/embedded-wallet/cognito-id-token`;
+export const ROUTE_AUTH_COGNITO_ID_TOKEN_V1 = `${ROUTE_2023_10_20_API_BASE_PATH}/embedded-wallet/cognito-id-token`;
+export const ROUTE_AUTH_COGNITO_ID_TOKEN_V2 = `${ROUTE_2024_05_05_API_BASE_PATH}/login/web-token-exchange`;
+export const ROUTE_AUTH_COGNITO_ID_TOKEN = ROUTE_AUTH_COGNITO_ID_TOKEN_V2;

package/src/wallets/in-app/native/helpers/wallet/recoveryCode.ts

@@ -1,20 +1,25 @@
 import { InvokeCommand, LambdaClient } from "@aws-sdk/client-lambda";
-import { fromCognitoIdentityPool } from "@aws-sdk/credential-providers";
+import {
+  fromCognitoIdentity,
+  fromCognitoIdentityPool,
+} from "@aws-sdk/credential-providers";
 import type { ThirdwebClient } from "../../../../../client/client.js";
 import { stringToBytes } from "../../../../../utils/encoding/to-bytes.js";
 import { authFetchEmbeddedWalletUser } from "../api/fetchers.js";
 import {
   AWS_REGION,
   COGNITO_IDENTITY_POOL_ID,
-  GENERATE_RECOVERY_PASSWORD_LAMBDA_FUNCTION,
-  ROUTE_AUTH_COGNITO_ID_TOKEN,
+  GENERATE_RECOVERY_PASSWORD_LAMBDA_FUNCTION_V1,
+  GENERATE_RECOVERY_PASSWORD_LAMBDA_FUNCTION_V2,
+  ROUTE_AUTH_COGNITO_ID_TOKEN_V1,
+  ROUTE_AUTH_COGNITO_ID_TOKEN_V2,
   ROUTE_COGNITO_IDENTITY_POOL_URL,
 } from "../constants.js";
 
-export async function getCognitoRecoveryPassword(client: ThirdwebClient) {
+export async function getCognitoRecoveryPasswordV1(client: ThirdwebClient) {
   const idTokenResponse = await authFetchEmbeddedWalletUser(
     client,
-    ROUTE_AUTH_COGNITO_ID_TOKEN,
+    ROUTE_AUTH_COGNITO_ID_TOKEN_V1,
     {
       method: "GET",
     },
@@ -48,10 +53,8 @@ export async function getCognitoRecoveryPassword(client: ThirdwebClient) {
     credentials: credentials,
   });
 
-  const functionName = GENERATE_RECOVERY_PASSWORD_LAMBDA_FUNCTION;
-
   const params = {
-    FunctionName: functionName,
+    FunctionName: GENERATE_RECOVERY_PASSWORD_LAMBDA_FUNCTION_V1,
     Payload: stringToBytes(
       JSON.stringify({
         accessToken,
@@ -69,3 +72,67 @@ export async function getCognitoRecoveryPassword(client: ThirdwebClient) {
 
   return result;
 }
+
+export async function getCognitoRecoveryPasswordV2(client: ThirdwebClient) {
+  const idTokenResponse = await authFetchEmbeddedWalletUser(
+    client,
+    ROUTE_AUTH_COGNITO_ID_TOKEN_V2,
+    {
+      method: "GET",
+    },
+  );
+  if (!idTokenResponse.ok) {
+    throw new Error(
+      `Failed to fetch id token from Cognito: ${JSON.stringify(
+        await idTokenResponse.json(),
+        null,
+        2,
+      )}`,
+    );
+  }
+  const idTokenResult = await idTokenResponse.json();
+  const { token, identityId, lambdaToken } = idTokenResult;
+
+  const cognitoIdentity = fromCognitoIdentity({
+    clientConfig: {
+      region: AWS_REGION,
+    },
+    identityId,
+    logins: {
+      "cognito-identity.amazonaws.com": token,
+    },
+  });
+
+  // ? Figure out how to potentially route things through API Gateway
+  const lambdaClient = new LambdaClient({
+    region: AWS_REGION,
+    credentials: cognitoIdentity,
+  });
+
+  const params = {
+    FunctionName: GENERATE_RECOVERY_PASSWORD_LAMBDA_FUNCTION_V2,
+    Payload: stringToBytes(
+      JSON.stringify({
+        token: lambdaToken,
+      }),
+    ),
+  };
+
+  const data = await lambdaClient.send(new InvokeCommand(params));
+
+  if (!data.Payload) {
+    throw new Error("No payload");
+  }
+  const encKeyResult = JSON.parse(data.Payload.transformToString());
+
+  if (encKeyResult.statusCode !== 200) {
+    throw new Error(
+      "Failed to get recovery code",
+      JSON.parse(encKeyResult.body).message,
+    );
+  }
+
+  return (JSON.parse(encKeyResult.body) as { recoveryShareEncKey: string })
+    .recoveryShareEncKey;
+}
+export const getCognitoRecoveryPassword = getCognitoRecoveryPasswordV2;

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

@@ -109,6 +109,7 @@ export class InAppNativeConnector implements InAppConnector {
       }
       case "google":
       case "facebook":
+      case "discord":
       case "apple": {
         const ExpoLinking = require("expo-linking");
         const redirectUrl =

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

@@ -0,0 +1 @@
+export const DEFAULT_POP_UP_SIZE = "width=350, height=500";

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

@@ -0,0 +1,92 @@
+import type { ThirdwebClient } from "../../../../../client/client.js";
+import { getThirdwebBaseUrl } from "../../../../../utils/domains.js";
+import type { AuthStoredTokenWithCookieReturnType } from "../../../../../wallets/in-app/core/authentication/type.js";
+import { getDiscordLoginPath } from "../../../core/authentication/getLoginPath.js";
+import type { Ecosystem } from "../../types.js";
+import { DEFAULT_POP_UP_SIZE } from "./constants.js";
+import { closeWindow } from "./utils.js";
+
+export async function loginWithDiscord(options: {
+  client: ThirdwebClient;
+  ecosystem?: Ecosystem;
+  openedWindow?: Window | null | undefined;
+  closeOpenedWindow?: ((openedWindow: Window) => void) | undefined;
+}): Promise<AuthStoredTokenWithCookieReturnType> {
+  let win = options.openedWindow;
+  let isWindowOpenedByFn = false;
+  if (!win) {
+    win = window.open(
+      getDiscordLoginPath(options.client, options.ecosystem),
+      "Login to discord",
+      DEFAULT_POP_UP_SIZE,
+    );
+    isWindowOpenedByFn = true;
+  }
+  if (!win) {
+    throw new Error("Something went wrong opening pop-up");
+  }
+
+  const result = await new Promise<AuthStoredTokenWithCookieReturnType>(
+    (resolve, reject) => {
+      // detect when the user closes the login window
+      const pollTimer = window.setInterval(async () => {
+        if (!win) {
+          return;
+        }
+        if (win.closed) {
+          clearInterval(pollTimer);
+          window.removeEventListener("message", messageListener);
+          reject(new Error("User closed login window"));
+        }
+      }, 1000);
+
+      const messageListener = async (
+        event: MessageEvent<{
+          eventType: string;
+          authResult?: AuthStoredTokenWithCookieReturnType;
+          errorString?: string;
+        }>,
+      ) => {
+        if (event.origin !== getThirdwebBaseUrl("inAppWallet")) {
+          return;
+        }
+        if (typeof event.data !== "object") {
+          reject(new Error("Invalid event data"));
+          return;
+        }
+
+        switch (event.data.eventType) {
+          case "oauthSuccessResult": {
+            window.removeEventListener("message", messageListener);
+            clearInterval(pollTimer);
+            closeWindow({
+              isWindowOpenedByFn,
+              win,
+              closeOpenedWindow: options.closeOpenedWindow,
+            });
+            if (event.data.authResult) {
+              resolve(event.data.authResult);
+            }
+            break;
+          }
+          case "oauthFailureResult": {
+            window.removeEventListener("message", messageListener);
+            clearInterval(pollTimer);
+            closeWindow({
+              isWindowOpenedByFn,
+              win,
+              closeOpenedWindow: options.closeOpenedWindow,
+            });
+            reject(new Error(event.data.errorString));
+            break;
+          }
+          default: {
+            reject(new Error(`Invalid event type: ${event.data.eventType}`));
+          }
+        }
+      };
+      window.addEventListener("message", messageListener);
+    },
+  );
+  return result;
+}

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

@@ -0,0 +1,19 @@
+export const closeWindow = ({
+  isWindowOpenedByFn,
+  win,
+  closeOpenedWindow,
+}: {
+  win?: Window | null;
+  isWindowOpenedByFn: boolean;
+  closeOpenedWindow?: (openedWindow: Window) => void;
+}) => {
+  if (isWindowOpenedByFn) {
+    win?.close();
+  } else {
+    if (win && closeOpenedWindow) {
+      closeOpenedWindow(win);
+    } else if (win) {
+      win.close();
+    }
+  }
+};

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

@@ -15,6 +15,7 @@ import {
 import type { InAppConnector } from "../../core/interfaces/connector.js";
 import type { InAppWalletConstructorType } from "../types.js";
 import { InAppWalletIframeCommunicator } from "../utils/iFrameCommunication/InAppWalletIframeCommunicator.js";
+import { loginWithDiscord } from "./auth/discord.js";
 import { Auth, type AuthQuerierTypes } from "./auth/iframe-auth.js";
 import { loginWithPasskey, registerPasskey } from "./auth/passkeys.js";
 import { IFrameWallet } from "./in-app-account.js";
@@ -215,6 +216,16 @@ export class InAppWebConnector implements InAppConnector {
         });
         return this.auth.loginWithAuthToken(authToken);
       }
+      case "discord": {
+        const authToken = await loginWithDiscord({
+          client: this.wallet.client,
+          ecosystem: this.wallet.ecosystem,
+          closeOpenedWindow: args.closeOpenedWindow,
+          openedWindow: args.openedWindow,
+        });
+        return this.auth.loginWithAuthToken(authToken);
+      }
+
       default:
         assertUnreachable(strategy);
     }

package/src/wallets/types.ts

@@ -19,7 +19,13 @@ export type AppMetadata = {
   logoUrl?: string;
 };
 
-export type SocialAuthOption = "google" | "apple" | "facebook";
+export const socialAuthOptions = [
+  "google",
+  "apple",
+  "facebook",
+  "discord",
+] as const;
+export type SocialAuthOption = (typeof socialAuthOptions)[number];
 
 export type AuthOption = "email" | "phone" | "passkey" | SocialAuthOption;