thirdweb 5.54.0-nightly-c3800d6c0765a9a0b69ac0a4a390d20cec932419-20240912000413 → 5.54.0

package/src/react/web/ui/ConnectWallet/screens/LinkedProfilesScreen.tsx

@@ -4,6 +4,7 @@ import { shortenAddress } from "../../../../../utils/address.js";
 import type { Profile } from "../../../../../wallets/in-app/core/authentication/types.js";
 import { fontSize, iconSize } from "../../../../core/design-system/index.js";
 import { useProfiles } from "../../../../core/hooks/others/useProfiles.js";
+import { useSocialProfiles } from "../../../../core/social/useSocialProfiles.js";
 import { getWalletIcon } from "../../../../core/utils/walletIcon.js";
 import { LoadingScreen } from "../../../wallets/shared/LoadingScreen.js";
 import { Img } from "../../components/Img.js";
@@ -88,41 +89,11 @@ export function LinkedProfilesScreen(props: {
             </MenuButton>
             <Spacer y="xs" />
             {connectedProfiles?.map((profile) => (
-              <MenuButton
+              <LinkedProfile
                 key={`${profile.type}-${getProfileDisplayName(profile)}`}
-                onClick={() => {
-                  props.setScreen("linked-profiles");
-                }}
-                style={{
-                  fontSize: fontSize.sm,
-                  cursor: "default",
-                }}
-                disabled // disabled until we have more data to show on a dedicated profile screen
-              >
-                {profile.type === "wallet" && profile.details.address ? (
-                  <Container
-                    style={{
-                      width: "24px",
-                      height: "24px",
-                      borderRadius: "100%",
-                      overflow: "hidden",
-                    }}
-                  >
-                    <Blobbie address={profile.details.address} size={24} />
-                  </Container>
-                ) : (
-                  <Img
-                    src={getWalletIcon(profile.type)}
-                    width={iconSize.md}
-                    height={iconSize.md}
-                    loading="eager"
-                    client={props.client}
-                  />
-                )}
-                <Text color="primaryText">
-                  {getProfileDisplayName(profile)}
-                </Text>
-              </MenuButton>
+                profile={profile}
+                client={props.client}
+              />
             ))}
           </Container>
           <Spacer y="md" />
@@ -131,3 +102,75 @@ export function LinkedProfilesScreen(props: {
     </Container>
   );
 }
+
+function LinkedProfile({
+  profile,
+  client,
+}: { profile: Profile; client: ThirdwebClient }) {
+  const { data: socialProfiles } = useSocialProfiles({
+    client,
+    address: profile.details.address,
+  });
+
+  return (
+    <MenuButton
+      style={{
+        fontSize: fontSize.sm,
+        cursor: "default",
+      }}
+      disabled // disabled until we have more data to show on a dedicated profile screen
+    >
+      {socialProfiles?.some((p) => p.avatar) ? (
+        <Img
+          src={socialProfiles?.find((p) => p.avatar)?.avatar}
+          width={iconSize.lg}
+          height={iconSize.lg}
+          loading="eager"
+          client={client}
+          style={{
+            borderRadius: "100%",
+          }}
+        />
+      ) : profile.details.address !== undefined ? (
+        <Container
+          style={{
+            width: "32px",
+            height: "32px",
+            borderRadius: "100%",
+            overflow: "hidden",
+          }}
+        >
+          <Blobbie address={profile.details.address} size={32} />
+        </Container>
+      ) : (
+        <Img
+          src={getWalletIcon(profile.type)}
+          width={iconSize.lg}
+          height={iconSize.lg}
+          loading="eager"
+          client={client}
+        />
+      )}
+      <div
+        style={{
+          display: "flex",
+          flexDirection: "row",
+          justifyContent: "space-between",
+          alignItems: "center",
+          flexGrow: 1,
+        }}
+      >
+        <Text color="primaryText">
+          {socialProfiles?.find((p) => p.avatar)?.name ||
+            getProfileDisplayName(profile)}
+        </Text>
+        {socialProfiles?.find((p) => p.avatar)?.name &&
+          profile.details.address && (
+            <Text color="secondaryText" size="sm">
+              {shortenAddress(profile.details.address, 4)}
+            </Text>
+          )}
+      </div>
+    </MenuButton>
+  );
+}

package/src/utils/extensions/drops/types.ts

@@ -55,7 +55,9 @@ export type ClaimCondition = {
 
 /**
  * Represents the input data for creating a claim condition for a Modular Drop contract.
- * @extension MODULAR
+ * @modules ClaimableERC20
+ * @modules ClaimableERC721
+ * @modules ClaimableERC1155
  */
 export type ClaimConditionInput = {
   /**

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.54.0-nightly-c3800d6c0765a9a0b69ac0a4a390d20cec932419-20240912000413";
+export const version = "5.54.0";

package/src/wallets/in-app/core/users/getUser.ts

@@ -0,0 +1,112 @@
+import type { ThirdwebClient } from "../../../../client/client.js";
+import { getThirdwebBaseUrl } from "../../../../utils/domains.js";
+import { getClientFetch } from "../../../../utils/fetch.js";
+import type { OneOf, Prettify } from "../../../../utils/type-utils.js";
+import type { Profile } from "../authentication/types.js";
+
+export type GetUserResult = {
+  userId: string;
+  walletAddress: string;
+  email?: string;
+  phone?: string;
+  createdAt: string;
+  profiles: Profile[];
+};
+
+/**
+ * Gets user based on the provided query parameters.
+ * @note This function is only available on the server (a secret key is required in the client).
+ *
+ * @param options - The options for the find users function.
+ * @param options.client - The Thirdweb client with a secret key included.
+ * @param [options.walletAddress] - The wallet address to query by.
+ * @param [options.email] - The email to query by.
+ * @param [options.phone] - The phone number to query by.
+ * @param [options.id] - The user ID to query by.
+ *
+ * @returns An array of user objects.
+ *
+ * @example
+ * ```ts
+ * import { getUser } from "thirdweb/wallets";
+ *
+ * const user = await getUser({
+ *   client,
+ *   walletAddress: "0x123...",
+ * });
+ * ```
+ *
+ * @wallet
+ */
+export async function getUser({
+  client,
+  walletAddress,
+  email,
+  phone,
+  id,
+}: Prettify<
+  {
+    client: ThirdwebClient;
+  } & OneOf<{
+    walletAddress?: string;
+    email?: string;
+    phone?: string;
+    id?: string;
+  }>
+>): Promise<GetUserResult | null> {
+  if (!client.secretKey) {
+    throw new Error(
+      "A secret key is required to query for users. If you're making this request from the server, please add a secret key to your client.",
+    );
+  }
+
+  const url = new URL(
+    `${getThirdwebBaseUrl("inAppWallet")}/api/2023-11-30/embedded-wallet/user-details`,
+  );
+
+  if (walletAddress) {
+    url.searchParams.set("queryBy", "walletAddress");
+    url.searchParams.set("walletAddress", walletAddress);
+  } else if (email) {
+    url.searchParams.set("queryBy", "email");
+    url.searchParams.set("email", email);
+  } else if (phone) {
+    url.searchParams.set("queryBy", "phone");
+    url.searchParams.set("phone", phone);
+  } else if (id) {
+    url.searchParams.set("queryBy", "id");
+    url.searchParams.set("id", id);
+  } else {
+    throw new Error(
+      "Please provide a walletAddress, email, phone, or id to query for users.",
+    );
+  }
+
+  const clientFetch = getClientFetch(client);
+
+  const res = await clientFetch(url.toString());
+
+  if (!res.ok) {
+    throw new Error("Failed to get profiles");
+  }
+
+  const data = (await res.json()) as {
+    userId: string;
+    walletAddress: string;
+    email?: string;
+    phone?: string;
+    createdAt: string;
+    linkedAccounts: Profile[];
+  }[];
+
+  return (
+    data.map((item) => ({
+      userId: item.userId,
+      walletAddress: item.walletAddress,
+      email: item.email,
+      phone: item.phone,
+      createdAt: item.createdAt,
+      profiles: item.linkedAccounts,
+    }))[0] || null
+  );
+}

package/src/wallets/smart/index.ts

@@ -45,6 +45,7 @@ import {
 } from "./lib/calls.js";
 import { getDefaultAccountFactory } from "./lib/constants.js";
 import {
+  clearAccountDeploying,
   createUnsignedUserOp,
   signUserOp,
   waitForUserOpReceipt,
@@ -597,6 +598,9 @@ async function _sendUserOp(args: {
     userOpHash,
   });
 
+  // reset the isDeploying flag after every transaction
+  clearAccountDeploying(options.accountContract);
+
   return {
     client: options.client,
     chain: options.chain,

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

@@ -49,6 +49,24 @@ import { getPackedUserOperation } from "./packUserOp.js";
 import { getPaymasterAndData } from "./paymaster.js";
 import { generateRandomUint192 } from "./utils.js";
 
+const isDeployingSet: Set<string> = new Set();
+
+const getKey = (accountContract: ThirdwebContract) => {
+  return `${accountContract.chain.id}:${accountContract.address}`;
+};
+
+export const markAccountDeploying = (accountContract: ThirdwebContract) => {
+  isDeployingSet.add(getKey(accountContract));
+};
+
+export const clearAccountDeploying = (accountContract: ThirdwebContract) => {
+  isDeployingSet.delete(getKey(accountContract));
+};
+
+export const isAccountDeploying = (accountContract: ThirdwebContract) => {
+  return isDeployingSet.has(getKey(accountContract));
+};
+
 /**
  * Wait for the user operation to be mined.
  * @param args - The options and user operation hash
@@ -266,17 +284,25 @@ async function populateUserOp_v0_7(args: {
     maxPriorityFeePerGas,
   } = args;
   const { chain, client } = bundlerOptions;
-  const factory = isDeployed ? undefined : factoryContract.address;
-  const factoryData = isDeployed
-    ? "0x"
-    : await encode(
-        prepareCreateAccount({
-          factoryContract: factoryContract,
-          adminAddress,
-          accountSalt: overrides?.accountSalt,
-          createAccountOverride: overrides?.createAccount,
-        }),
-      );
+
+  let factory: string | undefined;
+  let factoryData: Hex;
+  // lock until account is deployed if needed to avoid 'sender already created' errors when sending multiple transactions in parallel
+  if (isDeployed || isAccountDeploying(accountContract)) {
+    factoryData = "0x";
+    await waitForAccountDeployed(accountContract);
+  } else {
+    factory = factoryContract.address;
+    factoryData = await encode(
+      prepareCreateAccount({
+        factoryContract: factoryContract,
+        adminAddress,
+        accountSalt: overrides?.accountSalt,
+        createAccountOverride: overrides?.createAccount,
+      }),
+    );
+    markAccountDeploying(accountContract);
+  }
 
   const partialOp: UserOperationV07 = {
     sender: accountContract.address,
@@ -395,14 +421,21 @@ async function populateUserOp_v0_6(args: {
     maxPriorityFeePerGas,
   } = args;
   const { chain, client } = bundlerOptions;
-  const initCode = isDeployed
-    ? "0x"
-    : await getAccountInitCode({
-        factoryContract: factoryContract,
-        adminAddress,
-        accountSalt: overrides?.accountSalt,
-        createAccountOverride: overrides?.createAccount,
-      });
+  let initCode: Hex;
+
+  // lock until account is deployed if needed to avoid 'sender already created' errors when sending multiple transactions in parallel
+  if (isDeployed || isAccountDeploying(accountContract)) {
+    initCode = "0x";
+    await waitForAccountDeployed(accountContract);
+  } else {
+    initCode = await getAccountInitCode({
+      factoryContract: factoryContract,
+      adminAddress,
+      accountSalt: overrides?.accountSalt,
+      createAccountOverride: overrides?.createAccount,
+    });
+    markAccountDeploying(accountContract);
+  }
 
   const partialOp: UserOperationV06 = {
     sender: accountContract.address,
@@ -688,3 +721,15 @@ export async function createAndSignUserOp(options: {
   });
   return signedUserOp;
 }
+
+async function waitForAccountDeployed(accountContract: ThirdwebContract) {
+  const startTime = Date.now();
+  while (isAccountDeploying(accountContract)) {
+    if (Date.now() - startTime > 60000) {
+      throw new Error(
+        "Account deployment is taking too long (over 1 minute). Please try again.",
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  }
+}

package/src/wallets/smart/smart-wallet-integration-v07.test.ts

@@ -202,5 +202,60 @@ describe.runIf(process.env.TW_SECRET_KEY).sequential(
       expect(logs.some((l) => l.args.signer === newAdmin.address)).toBe(true);
       expect(logs.some((l) => l.args.isAdmin)).toBe(true);
     });
+
+    it("can execute a 2 tx in parallel", async () => {
+      const newSmartWallet = smartWallet({
+        chain,
+        gasless: true,
+        overrides: {
+          accountSalt: "test",
+        },
+      });
+      const newSmartAccount = await newSmartWallet.connect({
+        client: TEST_CLIENT,
+        personalAccount,
+      });
+      console.log("newSmartAccount", newSmartAccount.address);
+      const newSmartAccountContract = getContract({
+        address: newSmartAccount.address,
+        chain,
+        client,
+      });
+      let isDeployed = await isContractDeployed(newSmartAccountContract);
+      expect(isDeployed).toEqual(false);
+
+      // sending transactions in parallel should deploy the account and not cause errors
+      const txs = await Promise.all([
+        sendAndConfirmTransaction({
+          transaction: claimTo({
+            contract,
+            quantity: 1n,
+            to: newSmartAccount.address,
+            tokenId: 0n,
+          }),
+          account: newSmartAccount,
+        }),
+        sendAndConfirmTransaction({
+          transaction: claimTo({
+            contract,
+            quantity: 1n,
+            to: newSmartAccount.address,
+            tokenId: 0n,
+          }),
+          account: newSmartAccount,
+        }),
+      ]);
+      expect(txs.length).toEqual(2);
+      expect(txs.every((t) => t.transactionHash.length === 66)).toBe(true);
+
+      isDeployed = await isContractDeployed(newSmartAccountContract);
+      expect(isDeployed).toEqual(true);
+      const balance = await balanceOf({
+        contract,
+        owner: newSmartAccountContract.address,
+        tokenId: 0n,
+      });
+      expect(balance).toEqual(2n);
+    });
   },
 );

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

@@ -301,5 +301,60 @@ describe.runIf(process.env.TW_SECRET_KEY).sequential(
       });
       expect(balance).toEqual(1n);
     });
+
+    it("can execute a 2 tx in parallel", async () => {
+      const newSmartWallet = smartWallet({
+        chain,
+        gasless: true,
+        overrides: {
+          accountSalt: "test",
+        },
+      });
+      const newSmartAccount = await newSmartWallet.connect({
+        client: TEST_CLIENT,
+        personalAccount,
+      });
+      console.log("newSmartAccount", newSmartAccount.address);
+      const newSmartAccountContract = getContract({
+        address: newSmartAccount.address,
+        chain,
+        client,
+      });
+      let isDeployed = await isContractDeployed(newSmartAccountContract);
+      expect(isDeployed).toEqual(false);
+
+      // sending transactions in parallel should deploy the account and not cause errors
+      const txs = await Promise.all([
+        sendAndConfirmTransaction({
+          transaction: claimTo({
+            contract,
+            quantity: 1n,
+            to: newSmartAccount.address,
+            tokenId: 0n,
+          }),
+          account: newSmartAccount,
+        }),
+        sendAndConfirmTransaction({
+          transaction: claimTo({
+            contract,
+            quantity: 1n,
+            to: newSmartAccount.address,
+            tokenId: 0n,
+          }),
+          account: newSmartAccount,
+        }),
+      ]);
+      expect(txs.length).toEqual(2);
+      expect(txs.every((t) => t.transactionHash.length === 66)).toBe(true);
+
+      isDeployed = await isContractDeployed(newSmartAccountContract);
+      expect(isDeployed).toEqual(true);
+      const balance = await balanceOf({
+        contract,
+        owner: newSmartAccountContract.address,
+        tokenId: 0n,
+      });
+      expect(balance).toEqual(2n);
+    });
   },
 );

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

@@ -74,7 +74,7 @@ describe.runIf(process.env.TW_SECRET_KEY).skip(
         personalAccount,
       });
       const zkCandySmartWalletAddress = zkCandySmartAccount.address;
-      const preparedTx = await prepareTransaction({
+      const preparedTx = prepareTransaction({
         chain: defineChain(302),
         client: client,
         to: zkCandySmartWalletAddress,