thirdweb 5.48.1-nightly-7ef1c721ef693584d153554d46f2e70e8015b261-20240822000343 → 5.48.1

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);
+    });
+  },
+);