thirdweb 5.48.1-nightly-7ef1c721ef693584d153554d46f2e70e8015b261-20240822000343 → 5.48.2-nightly-1405598e7e51e4d415fd57f8169012823db0cedf-20240824000351

package/src/stories/utils.tsx

@@ -0,0 +1,29 @@
+import { generatePrivateKey } from "viem/accounts";
+import { createWalletAdapter } from "../adapters/wallet-adapter.js";
+import { ethereum } from "../chains/chain-definitions/ethereum.js";
+import { createThirdwebClient } from "../client/client.js";
+import type { Account } from "../wallets/interfaces/wallet.js";
+import { privateKeyToAccount } from "../wallets/private-key.js";
+
+const clientId = process.env.STORYBOOK_CLIENT_ID;
+
+if (!clientId) {
+  throw new Error("STORYBOOK_CLIENT_ID env is not configured");
+}
+
+export const storyClient = createThirdwebClient({
+  clientId: clientId,
+});
+
+export const storyAccount: Account = privateKeyToAccount({
+  client: storyClient,
+  privateKey: process.env.STORYBOOK_ACCOUNT_PRIVATE_KEY || generatePrivateKey(),
+});
+
+export const storyWallet = createWalletAdapter({
+  adaptedAccount: storyAccount,
+  client: storyClient,
+  chain: ethereum,
+  onDisconnect: () => {},
+  switchChain: () => {},
+});

package/src/transaction/actions/send-transaction.ts

@@ -5,13 +5,22 @@ import type { GaslessOptions } from "./gasless/types.js";
 import { toSerializableTransaction } from "./to-serializable-transaction.js";
 import type { WaitForReceiptOptions } from "./wait-for-tx-receipt.js";
 
-export type SendTransactionOptions = {
+/** Send transaction options */
+export interface SendTransactionOptions {
+  /**
+   * The account to send the transaction with
+   */
   account: Account;
-  // TODO: update this to `Transaction<"prepared">` once the type is available to ensure only prepared transactions are accepted
+  /**
+   * The prepared transaction to send
+   */
   // biome-ignore lint/suspicious/noExplicitAny: library function that accepts any prepared transaction type
   transaction: PreparedTransaction<any>;
+  /**
+   * Gasless options for the transaction, if applicable
+   */
   gasless?: GaslessOptions;
-};
+}
 
 /**
  * Sends a transaction using the provided account.

package/src/utils/fetch.ts

@@ -111,7 +111,10 @@ export function isThirdwebUrl(url: string): boolean {
 
     try {
       // special case for localhost in development only
-      if (process.env.NODE_ENV === "development") {
+      if (
+        process.env.NODE_ENV === "development" ||
+        process.env.NODE_ENV === "test"
+      ) {
         if (hostname === "localhost") {
           IS_THIRDWEB_URL_CACHE.set(url, true);
           return true;

package/src/utils/signatures/sign-message.test.ts

@@ -1,57 +1,85 @@
-import { expect, test } from "vitest";
+import { describe, expect, test } from "vitest";
 
-import { ANVIL_PKEY_A } from "~test/test-wallets.js";
+import { ANVIL_PKEY_A, TEST_ACCOUNT_A } from "~test/test-wallets.js";
 import { signMessage } from "./sign-message.js";
 
-test("default", async () => {
-  expect(
-    signMessage({
+describe("signMessage", async () => {
+  test("privateKey", async () => {
+    expect(
+      signMessage({
+        message: "hello world",
+        privateKey: ANVIL_PKEY_A,
+      }),
+    ).toMatchInlineSnapshot(
+      '"0xa461f509887bd19e312c0c58467ce8ff8e300d3c1a90b608a760c5b80318eaf15fe57c96f9175d6cd4daad4663763baa7e78836e067d0163e9a2ccf2ff753f5b1b"',
+    );
+
+    expect(
+      signMessage({
+        message: "🤯",
+        privateKey: ANVIL_PKEY_A,
+      }),
+    ).toMatchInlineSnapshot(
+      '"0xc0cd7599731c37aa4c0815a89dc8dcb4ce479f83df7ee8ffc606a9ef29323e814b54bb8935b56e7c690f1ee4c6290da5c2f6df6fc3443fbe96bb1846a2c4fefc1c"',
+    );
+
+    expect(
+      signMessage({
+        message: "0x787037Ba5b7eA8a8737627FfB67d35FdCaAd9A18",
+        privateKey: ANVIL_PKEY_A,
+      }),
+    ).toMatchInlineSnapshot(
+      '"0x151436da0ef734f06ae71f4b907a062fa5683b40af4221e86dfe5f2fc9f09ffa40c90fee4a0e48311506b84dc6f20e513dc4dc434f0f70a03af6ff3e22c7b7591c"',
+    );
+  });
+
+  test("raw", async () => {
+    expect(
+      signMessage({
+        message: { raw: "0x68656c6c6f20776f726c64" },
+        privateKey: ANVIL_PKEY_A,
+      }),
+    ).toMatchInlineSnapshot(
+      '"0xa461f509887bd19e312c0c58467ce8ff8e300d3c1a90b608a760c5b80318eaf15fe57c96f9175d6cd4daad4663763baa7e78836e067d0163e9a2ccf2ff753f5b1b"',
+    );
+
+    expect(
+      signMessage({
+        message: {
+          raw: Uint8Array.from([
+            104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100,
+          ]),
+        },
+        privateKey: ANVIL_PKEY_A,
+      }),
+    ).toMatchInlineSnapshot(
+      '"0xa461f509887bd19e312c0c58467ce8ff8e300d3c1a90b608a760c5b80318eaf15fe57c96f9175d6cd4daad4663763baa7e78836e067d0163e9a2ccf2ff753f5b1b"',
+    );
+  });
+
+  test("account", async () => {
+    const basicSignature = await signMessage({
       message: "hello world",
-      privateKey: ANVIL_PKEY_A,
-    }),
-  ).toMatchInlineSnapshot(
-    '"0xa461f509887bd19e312c0c58467ce8ff8e300d3c1a90b608a760c5b80318eaf15fe57c96f9175d6cd4daad4663763baa7e78836e067d0163e9a2ccf2ff753f5b1b"',
-  );
-
-  expect(
-    signMessage({
+      account: TEST_ACCOUNT_A,
+    });
+    expect(basicSignature).toMatchInlineSnapshot(
+      '"0xa461f509887bd19e312c0c58467ce8ff8e300d3c1a90b608a760c5b80318eaf15fe57c96f9175d6cd4daad4663763baa7e78836e067d0163e9a2ccf2ff753f5b1b"',
+    );
+
+    const emojiSignature = await signMessage({
       message: "🤯",
-      privateKey: ANVIL_PKEY_A,
-    }),
-  ).toMatchInlineSnapshot(
-    '"0xc0cd7599731c37aa4c0815a89dc8dcb4ce479f83df7ee8ffc606a9ef29323e814b54bb8935b56e7c690f1ee4c6290da5c2f6df6fc3443fbe96bb1846a2c4fefc1c"',
-  );
-
-  expect(
-    signMessage({
-      message: "0x787037Ba5b7eA8a8737627FfB67d35FdCaAd9A18",
-      privateKey: ANVIL_PKEY_A,
-    }),
-  ).toMatchInlineSnapshot(
-    '"0x151436da0ef734f06ae71f4b907a062fa5683b40af4221e86dfe5f2fc9f09ffa40c90fee4a0e48311506b84dc6f20e513dc4dc434f0f70a03af6ff3e22c7b7591c"',
-  );
-});
+      account: TEST_ACCOUNT_A,
+    });
+    expect(emojiSignature).toMatchInlineSnapshot(
+      '"0xc0cd7599731c37aa4c0815a89dc8dcb4ce479f83df7ee8ffc606a9ef29323e814b54bb8935b56e7c690f1ee4c6290da5c2f6df6fc3443fbe96bb1846a2c4fefc1c"',
+    );
 
-test("raw", async () => {
-  expect(
-    signMessage({
-      message: { raw: "0x68656c6c6f20776f726c64" },
-      privateKey: ANVIL_PKEY_A,
-    }),
-  ).toMatchInlineSnapshot(
-    '"0xa461f509887bd19e312c0c58467ce8ff8e300d3c1a90b608a760c5b80318eaf15fe57c96f9175d6cd4daad4663763baa7e78836e067d0163e9a2ccf2ff753f5b1b"',
-  );
-
-  expect(
-    signMessage({
-      message: {
-        raw: Uint8Array.from([
-          104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100,
-        ]),
-      },
-      privateKey: ANVIL_PKEY_A,
-    }),
-  ).toMatchInlineSnapshot(
-    '"0xa461f509887bd19e312c0c58467ce8ff8e300d3c1a90b608a760c5b80318eaf15fe57c96f9175d6cd4daad4663763baa7e78836e067d0163e9a2ccf2ff753f5b1b"',
-  );
+    const addressSignature = await signMessage({
+      message: "0x787037Ba5b7eA8a8737627FfB67d35FdCaAd9A18",
+      account: TEST_ACCOUNT_A,
+    });
+    expect(addressSignature).toMatchInlineSnapshot(
+      '"0x151436da0ef734f06ae71f4b907a062fa5683b40af4221e86dfe5f2fc9f09ffa40c90fee4a0e48311506b84dc6f20e513dc4dc434f0f70a03af6ff3e22c7b7591c"',
+    );
+  });
 });

package/src/utils/signatures/sign-message.ts

@@ -1,16 +1,18 @@
+import type { Account } from "../../wallets/interfaces/wallet.js";
 import type { Hex } from "../encoding/hex.js";
 import { hashMessage } from "../hashing/hashMessage.js";
 import type { Prettify } from "../type-utils.js";
 import { sign } from "./sign.js";
 import { signatureToHex } from "./signature-to-hex.js";
 
+type Message = Prettify<
+  | string
+  | {
+      raw: Hex | Uint8Array;
+    }
+>;
 export type SignMessageOptions = {
-  message: Prettify<
-    | string
-    | {
-        raw: Hex | Uint8Array;
-      }
-  >;
+  message: Message;
   privateKey: Hex;
 };
 
@@ -30,7 +32,40 @@ export type SignMessageOptions = {
  * ```
  * @utils
  */
-export function signMessage({ message, privateKey }: SignMessageOptions): Hex {
-  const signature = sign({ hash: hashMessage(message), privateKey });
-  return signatureToHex(signature);
+export function signMessage({ message, privateKey }: SignMessageOptions): Hex;
+
+/**
+ * Signs a string message with a given account.
+ * @param options The options for signing.
+ * @param options.message The message to be signed as a string or object containing raw hex or bytes
+ * @param options.account The account to be used
+ * @returns The signature as a hex string
+ * @example
+ * ```ts
+ * import { signMessage } from "thirdweb/utils";
+ * await signMessage({
+ *   message: "Hello, world!",
+ *   account
+ * });
+ * ```
+ * @walletUtils
+ */
+export function signMessage({
+  message,
+  account,
+}: { message: Message; account: Account }): Promise<Hex>;
+
+export function signMessage(
+  options: SignMessageOptions | { message: Message; account: Account },
+): Hex | Promise<Hex> {
+  if ("privateKey" in options) {
+    const { message, privateKey } = options;
+    const signature = sign({ hash: hashMessage(message), privateKey });
+    return signatureToHex(signature);
+  } else if ("account" in options) {
+    const { message, account } = options;
+    return account.signMessage({ message });
+  } else {
+    throw new Error("Either privateKey or account is required");
+  }
 }

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.48.1-nightly-7ef1c721ef693584d153554d46f2e70e8015b261-20240822000343";
+export const version = "5.48.2-nightly-1405598e7e51e4d415fd57f8169012823db0cedf-20240824000351";

package/src/wallets/ecosystem/types.ts

@@ -6,9 +6,8 @@ import type {
 export type EcosystemWalletCreationOptions = {
   partnerId?: string;
   auth?: {
-    mode?: "popup" | "redirect";
+    mode?: "popup" | "redirect" | "window";
     redirectUrl?: string;
-    redirectExternally?: boolean;
   };
 };
 

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

@@ -25,9 +25,17 @@ export const getLoginUrl = ({
   authOption: AuthOption | "wallet";
   client: ThirdwebClient;
   ecosystem?: Ecosystem;
-  mode?: "popup" | "redirect" | "mobile";
+  mode?: "popup" | "redirect" | "window";
   redirectUrl?: string;
 }) => {
+  if (mode === "popup" && redirectUrl) {
+    throw new Error("Redirect URL is not supported for popup mode");
+  }
+
+  if (mode === "window" && !redirectUrl) {
+    throw new Error("Redirect URL is required for window mode");
+  }
+
   const route = getLoginOptionRoute(authOption);
   let baseUrl = `${getThirdwebBaseUrl("inAppWallet")}/api/2024-05-05/login/${route}?clientId=${client.clientId}`;
   if (ecosystem?.partnerId) {
@@ -36,20 +44,14 @@ export const getLoginUrl = ({
     baseUrl = `${baseUrl}&ecosystemId=${ecosystem.id}`;
   }
 
-  if (mode === "redirect") {
+  // Always append redirectUrl to the baseUrl if mode is not popup
+  if (mode !== "popup") {
     const formattedRedirectUrl = new URL(redirectUrl || window.location.href);
     formattedRedirectUrl.searchParams.set("walletId", ecosystem?.id || "inApp");
     formattedRedirectUrl.searchParams.set("authProvider", authOption);
     baseUrl = `${baseUrl}&redirectUrl=${encodeURIComponent(formattedRedirectUrl.toString())}`;
   }
 
-  if (mode === "mobile") {
-    if (!redirectUrl) {
-      throw new Error("Redirect URL is required for mobile authentication");
-    }
-    baseUrl = `${baseUrl}&redirectUrl=${encodeURIComponent(redirectUrl)}`;
-  }
-
   return baseUrl;
 };
 

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

@@ -30,6 +30,7 @@ export type SingleStepAuthArgsType =
       openedWindow?: Window;
       closeOpenedWindow?: (window: Window) => void;
       redirectUrl?: string;
+      mode?: "redirect" | "popup" | "window";
     }
   | { strategy: "jwt"; jwt: string; encryptionKey: string }
   | { strategy: "auth_endpoint"; payload: string; encryptionKey: string }
@@ -46,14 +47,6 @@ export type SingleStepAuthArgsType =
        * Optional name of the passkey to create, defaults to a generated name
        */
       passkeyName?: string;
-      /**
-       * Optional domain, defaults to current window location.
-       * NOTE: this is required on native platforms.
-       */
-      domain?: {
-        displayName: string;
-        hostname: string;
-      };
     }
   | {
       strategy: "wallet";

package/src/wallets/in-app/core/interfaces/connector.ts

@@ -15,7 +15,11 @@ export interface InAppConnector {
   getAccount(): Promise<Account>;
   preAuthenticate(args: PreAuthArgsType): Promise<void>;
   // Authenticate generates an auth token, when redirecting it returns void as the user is redirected to a new page and the token is stored in the callback url
-  authenticateWithRedirect?(strategy: SocialAuthOption): void;
+  authenticateWithRedirect?(
+    strategy: SocialAuthOption,
+    mode?: "redirect" | "popup" | "window",
+    redirectUrl?: string,
+  ): void;
   // Login takes an auth token and connects a user with it
   loginWithAuthToken?(
     authResult: AuthStoredTokenWithCookieReturnType,

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

@@ -40,12 +40,16 @@ export async function connectInAppWallet(
   connector: InAppConnector,
 ): Promise<[Account, Chain]> {
   if (
-    createOptions?.auth?.mode === "redirect" &&
+    createOptions?.auth?.mode !== "popup" &&
     connector.authenticateWithRedirect
   ) {
     const strategy = options.strategy;
     if (socialAuthOptions.includes(strategy as SocialAuthOption)) {
-      connector.authenticateWithRedirect(strategy as SocialAuthOption);
+      connector.authenticateWithRedirect(
+        strategy as SocialAuthOption,
+        createOptions?.auth?.mode,
+        createOptions?.auth?.redirectUrl,
+      );
     }
   }
   // If we don't have authenticateWithRedirect then it's likely react native, so the default is to redirect and we can carry on

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

@@ -36,15 +36,11 @@ export type InAppWalletCreationOptions =
         /**
          * Whether to display the social auth prompt in a popup or redirect
          */
-        mode?: "popup" | "redirect";
+        mode?: "popup" | "redirect" | "window";
         /**
          * Optional url to redirect to after authentication
          */
         redirectUrl?: string;
-        /**
-         * Whether to handle the redirect in a new window
-         */
-        redirectExternally?: boolean;
         /**
          * The domain of the passkey to use for authentication
          */

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

@@ -59,7 +59,7 @@ export async function authenticate(
   const loginUrl = getLoginUrl({
     authOption: auth.strategy,
     client,
-    mode: "mobile",
+    mode: "window",
     redirectUrl: auth.redirectUrl,
   });
 

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

@@ -156,7 +156,12 @@ export async function authenticate(
   >,
 ) {
   const connector = await getInAppWalletConnector(args.client, args.ecosystem);
-  if (args.redirect && connector.authenticateWithRedirect)
-    return connector.authenticateWithRedirect(args.strategy);
+  const isRedirect = args.redirect || args.mode !== "popup";
+  if (isRedirect && connector.authenticateWithRedirect && args.strategy)
+    return connector.authenticateWithRedirect(
+      args.strategy as SocialAuthOption,
+      args.mode,
+      args.redirectUrl,
+    );
   return connector.connect(args);
 }

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

@@ -31,16 +31,16 @@ export const loginWithOauthRedirect = (options: {
   client: ThirdwebClient;
   ecosystem?: Ecosystem;
   redirectUrl?: string;
-  redirectExternally?: boolean;
+  mode?: "redirect" | "popup" | "window";
 }): void => {
   const loginUrl = getLoginUrl({
     ...options,
-    mode: "redirect",
+    mode: options.mode || "redirect",
   });
-  if (options.redirectExternally === true) {
-    window.open(loginUrl);
-  } else {
+  if (options.mode === "redirect") {
     window.location.href = loginUrl;
+  } else {
+    window.open(loginUrl);
   }
 };
 

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

@@ -150,11 +150,17 @@ export class InAppWebConnector implements InAppConnector {
     });
   }
 
-  authenticateWithRedirect(strategy: SocialAuthOption): void {
+  authenticateWithRedirect(
+    strategy: SocialAuthOption,
+    mode?: "redirect" | "popup" | "window",
+    redirectUrl?: string,
+  ): void {
     loginWithOauthRedirect({
       authOption: strategy,
       client: this.wallet.client,
       ecosystem: this.wallet.ecosystem,
+      redirectUrl,
+      mode,
     });
   }
 
@@ -308,8 +314,8 @@ export class InAppWebConnector implements InAppConnector {
       passkeyClient,
       storage,
       rp: {
-        id: args.domain?.hostname ?? window.location.hostname,
-        name: args.domain?.displayName ?? window.document.title,
+        id: this.passkeyDomain ?? window.location.hostname,
+        name: this.passkeyDomain ?? window.document.title,
       },
     });
   }

package/src/wallets/smart/lib/constants.ts

@@ -19,6 +19,9 @@ export const MANAGED_ACCOUNT_GAS_BUFFER = 50000n;
  */
 export const getDefaultBundlerUrl = (chain: Chain) => {
   const domain = getThirdwebDomains().bundler;
+  if (domain.startsWith("localhost:")) {
+    return `http://${domain}?chain=${chain.id}`;
+  }
   return `https://${chain.id}.${domain}/`;
 };
 
@@ -27,5 +30,8 @@ export const getDefaultBundlerUrl = (chain: Chain) => {
  */
 export const getDefaultPaymasterUrl = (chain: Chain) => {
   const domain = getThirdwebDomains().bundler;
+  if (domain.startsWith("localhost:")) {
+    return `http://${domain}?chain=${chain.id}`;
+  }
   return `https://${chain.id}.${domain}/`;
 };

package/src/wallets/smart/smart-wallet-dev.test.ts

@@ -0,0 +1,86 @@
+import { beforeAll, describe, expect, it } from "vitest";
+import { TEST_CLIENT } from "../../../test/src/test-clients.js";
+import { arbitrumSepolia } from "../../chains/chain-definitions/arbitrum-sepolia.js";
+import { type ThirdwebContract, getContract } from "../../contract/contract.js";
+
+import { balanceOf } from "../../extensions/erc1155/__generated__/IERC1155/read/balanceOf.js";
+import { claimTo } from "../../extensions/erc1155/drops/write/claimTo.js";
+import { sendAndConfirmTransaction } from "../../transaction/actions/send-and-confirm-transaction.js";
+import type { Address } from "../../utils/address.js";
+import { isContractDeployed } from "../../utils/bytecode/is-contract-deployed.js";
+import { setThirdwebDomains } from "../../utils/domains.js";
+import type { Account, Wallet } from "../interfaces/wallet.js";
+import { generateAccount } from "../utils/generateAccount.js";
+import { smartWallet } from "./smart-wallet.js";
+
+let wallet: Wallet;
+let smartAccount: Account;
+let smartWalletAddress: Address;
+let personalAccount: Account;
+let accountContract: ThirdwebContract;
+
+const chain = arbitrumSepolia;
+const client = TEST_CLIENT;
+const contract = getContract({
+  client,
+  chain,
+  address: "0x6A7a26c9a595E6893C255C9dF0b593e77518e0c3",
+});
+describe.runIf(process.env.TW_SECRET_KEY).skip.sequential(
+  "SmartWallet policy tests",
+  {
+    retry: 0,
+    timeout: 240_000,
+  },
+  () => {
+    beforeAll(async () => {
+      setThirdwebDomains({
+        rpc: "rpc.thirdweb-dev.com",
+        storage: "storage.thirdweb-dev.com",
+        bundler: "bundler.thirdweb-dev.com",
+      });
+      personalAccount = await generateAccount({
+        client,
+      });
+      wallet = smartWallet({
+        chain,
+        gasless: true,
+      });
+      smartAccount = await wallet.connect({
+        client: TEST_CLIENT,
+        personalAccount,
+      });
+      smartWalletAddress = smartAccount.address as Address;
+      accountContract = getContract({
+        address: smartWalletAddress,
+        chain,
+        client,
+      });
+    });
+
+    it("can connect", async () => {
+      expect(smartWalletAddress).toHaveLength(42);
+    });
+
+    it("can execute a tx", async () => {
+      const tx = await sendAndConfirmTransaction({
+        transaction: claimTo({
+          contract,
+          quantity: 1n,
+          to: smartWalletAddress,
+          tokenId: 0n,
+        }),
+        account: smartAccount,
+      });
+      expect(tx.transactionHash).toHaveLength(66);
+      const isDeployed = await isContractDeployed(accountContract);
+      expect(isDeployed).toEqual(true);
+      const balance = await balanceOf({
+        contract,
+        owner: smartWalletAddress,
+        tokenId: 0n,
+      });
+      expect(balance).toEqual(1n);
+    });
+  },
+);