thirdweb 5.48.1-nightly-886094fbac4f25735438a651cdb0747c6d5de6c5-20240821000347 → 5.48.1

package/src/react/web/wallets/shared/SocialLogin.tsx

@@ -48,10 +48,15 @@ export function SocialLogin(props: {
 
   const handleSocialLogin = async () => {
     const walletConfig = wallet.getConfig();
+    const authMode =
+      walletConfig && "auth" in walletConfig
+        ? walletConfig?.auth?.mode ?? "popup"
+        : "popup";
+
     if (
       walletConfig &&
       "auth" in walletConfig &&
-      walletConfig?.auth?.mode === "redirect" &&
+      authMode !== "popup" &&
       !props.isLinking // Redirect not supported for account linking (we need to maintain the aplication state)
     ) {
       return loginWithOauthRedirect({
@@ -64,7 +69,7 @@ export function SocialLogin(props: {
             }
           : undefined,
         redirectUrl: walletConfig?.auth?.redirectUrl,
-        redirectExternally: walletConfig?.auth?.redirectExternally,
+        mode: walletConfig?.auth?.mode,
       });
     }
 

package/src/storage/upload/mobile.ts

@@ -77,7 +77,7 @@ export async function uploadBatchMobile(
           let body: any;
           try {
             body = JSON.parse(xhr.responseText);
-          } catch (err) {
+          } catch {
             return reject(
               new Error("Failed to parse JSON from upload response"),
             );

package/src/transaction/read-contract.test.ts

@@ -31,4 +31,34 @@ describe.runIf(process.env.TW_SECRET_KEY)("transaction: read", () => {
       );
     }
   });
+
+  it("should work with string and number, not just bigint", async () => {
+    /**
+     * The following 3 readContracts all result in the same value because
+     * the param is still parsed and encoded properly downstream by `numberToHex`
+     * See this docs for more context: "../utils/encoding/hex.test.js"
+     */
+    const [bigintResult, numberResult, stringResult] = await Promise.all([
+      readContract({
+        contract: DOODLES_CONTRACT,
+        method: "function ownerOf(uint256 tokenId) view returns (address)",
+        params: [1n],
+      }),
+      readContract({
+        contract: DOODLES_CONTRACT,
+        method: "function ownerOf(uint256 tokenId) view returns (address)",
+        // @ts-ignore Intentional
+        params: [1], // <- supposed to be a bigint
+      }),
+      readContract({
+        contract: DOODLES_CONTRACT,
+        method: "function ownerOf(uint256 tokenId) view returns (address)",
+        // @ts-ignore Intentional
+        params: ["1"], // <- supposed to be a bigint
+      }),
+    ]);
+
+    expect(bigintResult === numberResult).toBe(true);
+    expect(bigintResult === stringResult).toBe(true);
+  });
 });

package/src/utils/contract/parse-abi-params.test.ts

@@ -156,5 +156,17 @@ describe("parseAbiParams", () => {
       const result = parseAbiParams(["bytes64"], [value]);
       expect(result).toStrictEqual([value]);
     });
+
+    it("should return a string for type string", () => {
+      const value = "this is a string";
+      const result = parseAbiParams(["string"], [value]);
+      expect(result).toStrictEqual(["this is a string"]);
+    });
+
+    it("should return the value itself if it falls through to the end", () => {
+      const value = { whatever: true };
+      const result = parseAbiParams(["non-existent-type"], [value]);
+      expect(result).toStrictEqual([{ whatever: true }]);
+    });
   });
 });

package/src/utils/contract/parse-abi-params.ts

@@ -32,6 +32,17 @@ export function parseAbiParams(
   constructorParamTypes: string[],
   constructorParamValues: unknown[],
 ): Array<string | bigint | boolean> {
+  /**
+   * Internal Solidity type checklist
+   * 1. tuple, array -> JSON.parse | todo: Recursively parse the content
+   * 2. uint, int -> bigint
+   * 3. address -> string
+   * 4. string -> string
+   * 5. bytes, bytes32 etc. -> string
+   * 6. bool -> boolean
+   * >>> Make sure to return the original value at the end of the function <<<
+   */
+
   // Make sure they have the same length
   if (constructorParamTypes.length !== constructorParamValues.length) {
     throw new Error(
@@ -46,6 +57,9 @@ export function parseAbiParams(
       }
       return value;
     }
+    if (type === "string") {
+      return String(value);
+    }
     if (type === "bytes32") {
       if (!isHex(value)) {
         throw new Error(`${value} is not a valid hex string`);
@@ -86,5 +100,8 @@ export function parseAbiParams(
         "Invalid boolean value. Expecting either 'true' or 'false'",
       );
     }
+
+    // Return the value here if none of the types match
+    return value;
   });
 }

package/src/utils/encoding/hex.test.ts

@@ -8,4 +8,44 @@ describe("hex.ts", () => {
       "0x0000000000000000000000000000000000000000000000000000000000000064",
     );
   });
+
+  /**
+   * This test is put here as a docs for the method `numberToHex` because:
+   *
+   * `numberToHex` can still work with number-convertible strings - even tho it only accepts number or bigint
+   * because there's is one line of code that's converting the param into bigint anyway
+   * ```ts
+   * const value = BigInt(value_);
+   * ```
+   *
+   * As a side effect, the following 3 return the same result:
+   * ```ts
+   * readContract({
+   *   contract,
+   *   method: "function tokenURI(uint256 tokenId) returns (string)",
+   *   params: [1n],
+   * })
+   *
+   * readContract({
+   *   contract,
+   *   method: "function tokenURI(uint256 tokenId) returns (string)",
+   *   // @ts-ignore
+   *   params: [1],
+   * })
+   *
+   * readContract({
+   *   contract,
+   *   method: "function tokenURI(uint256 tokenId) returns (string)",
+   *   // @ts-ignore
+   *   params: ["1"],
+   * })
+   * ```
+   */
+  it("should work with string !!!!", () => {
+    // @ts-ignore Intentional
+    const result = numberToHex("100", { size: 32, signed: false });
+    expect(result).toBe(
+      "0x0000000000000000000000000000000000000000000000000000000000000064",
+    );
+  });
 });

package/src/utils/extensions/airdrop/fetch-proofs-erc1155.ts

@@ -81,7 +81,7 @@ export async function fetchProofsERC1155(options: {
       uri: constructedShardUri,
     });
     shardData = await shard.json();
-  } catch (e) {
+  } catch {
     // if the file can't be fetched it means claimer not in merkle tree
     return null;
   }

package/src/utils/extensions/airdrop/fetch-proofs-erc20.ts

@@ -83,7 +83,7 @@ export async function fetchProofsERC20(options: {
       uri: constructedShardUri,
     });
     shardData = await shard.json();
-  } catch (e) {
+  } catch {
     // if the file can't be fetched it means claimer not in merkle tree
     return null;
   }

package/src/utils/extensions/airdrop/fetch-proofs-erc721.ts

@@ -81,7 +81,7 @@ export async function fetchProofsERC721(options: {
       uri: constructedShardUri,
     });
     shardData = await shard.json();
-  } catch (e) {
+  } catch {
     // if the file can't be fetched it means claimer not in merkle tree
     return null;
   }

package/src/utils/extensions/drops/fetch-proofs-for-claimers.ts

@@ -53,7 +53,7 @@ export async function fetchProofsForClaimer(options: {
       uri: constructedShardUri,
     });
     shardData = await shard.json();
-  } catch (e) {
+  } catch {
     // if the file can't be fetched it means claimer not in merkle tree
     return null;
   }

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/nft/fetchTokenMetadata.ts

@@ -63,7 +63,7 @@ export async function fetchTokenMetadata(
           ),
         })
       ).json();
-    } catch (err) {
+    } catch {
       // otherwise attempt the second format
       return await (
         await download({

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.48.1-nightly-886094fbac4f25735438a651cdb0747c6d5de6c5-20240821000347";
+export const version = "5.48.1";

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/native/helpers/auth/middleware.ts

@@ -64,7 +64,7 @@ export async function postAuth({
     try {
       // existing device share
       await getDeviceShare(client.clientId);
-    } catch (e) {
+    } catch {
       const _recoveryCode = await getRecoveryCode(
         storedToken,
         client,
@@ -116,7 +116,7 @@ export async function postAuthUserManaged(
     try {
       // existing device share
       await getDeviceShare(client.clientId);
-    } catch (e) {
+    } catch {
       // trying to recreate device share from recovery code to derive wallet
       try {
         await setUpShareForNewDevice({
@@ -155,7 +155,7 @@ async function getRecoveryCode(
     }
     try {
       return await getCognitoRecoveryPasswordV2(client);
-    } catch (e) {
+    } catch {
       return await getCognitoRecoveryPasswordV1(client).catch(() => {
         throw new Error("Something went wrong getting cognito recovery code");
       });

package/src/wallets/in-app/native/helpers/storage/local.ts

@@ -131,7 +131,7 @@ export async function getWalletUserDetails(
   try {
     const parsed = JSON.parse(result);
     return parsed;
-  } catch (e) {
+  } catch {
     return undefined;
   }
 }

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

@@ -152,7 +152,7 @@ async function getShares<
     deviceShareToReturn = deviceShare.toRetrieve
       ? (await getDeviceShare(client.clientId)).deviceShare
       : undefined;
-  } catch (e) {
+  } catch {
     throw new Error(DEVICE_SHARE_MISSING_MESSAGE);
   }
 

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/index.ts

@@ -261,7 +261,7 @@ async function createSmartAccount(
           params: [originalMsgHash],
         });
         factorySupports712 = true;
-      } catch (e) {
+      } catch {
         // ignore
       }
 
@@ -349,7 +349,7 @@ async function createSmartAccount(
           params: [originalMsgHash],
         });
         factorySupports712 = true;
-      } catch (e) {
+      } catch {
         // ignore
       }
 

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

package/src/wallets/utils/chains.ts

@@ -16,7 +16,7 @@ export function getValidPublicRPCUrl(chain: ChainMetadata) {
         url.search = "";
       }
       return url.toString();
-    } catch (e) {
+    } catch {
       return rpc;
     }
   });

package/src/wallets/wallet-connect/receiver/index.ts

@@ -344,7 +344,7 @@ export async function disconnectWalletConnectSession(options: {
         message: "Disconnected",
       },
     });
-  } catch (error) {
+  } catch {
     // ignore, the session doesn't exist already
   }
 }