thirdweb 5.53.1-nightly-865c5e3b16af70c3660f30ba8cffc5d6e360a389-20240911000352 → 5.54.0

package/src/transaction/actions/zksync/send-eip712-transaction.test.ts

@@ -35,19 +35,19 @@ describe("sendEip712Transaction", () => {
       client: TEST_CLIENT,
       chain: zkSyncSepolia, // TODO make zksync fork chain work
       account: TEST_ACCOUNT_A,
-      contractId: "DropERC1155",
-      contractParams: [
-        TEST_ACCOUNT_A.address, // defaultAdmin
-        "test", // name
-        "", // symbol
-        "", // contractURI
-        [], // trustedForwarders
-        TEST_ACCOUNT_A.address, // saleRecipient
-        TEST_ACCOUNT_A.address, // royaltyRecipient
-        0n, // royaltyBps
-        0n, // platformFeeBps
-        TEST_ACCOUNT_A.address, // platformFeeRecipient
-      ],
+      contractId: "DropERC721",
+      contractParams: {
+        defaultAdmin: TEST_ACCOUNT_A.address, // defaultAdmin
+        name: "test", // name
+        symbol: "test", // symbol
+        contractURI: "", // contractURI
+        trustedForwarders: [], // trustedForwarders
+        saleRecipient: TEST_ACCOUNT_A.address, // saleRecipient
+        royaltyRecipient: TEST_ACCOUNT_A.address, // royaltyRecipient
+        royaltyBps: 0n, // royaltyBps
+        platformFeeBps: 0n, // platformFeeBps
+        platformFeeRecipient: TEST_ACCOUNT_A.address, // platformFeeRecipient
+      },
     });
     console.log("deployed address", address);
     expect(address).toBeDefined();

package/src/utils/abi/normalizeFunctionParams.ts

@@ -0,0 +1,29 @@
+import type { AbiConstructor, AbiFunction } from "abitype";
+
+export function normalizeFunctionParams(
+  abiFunction: AbiFunction | AbiConstructor | undefined,
+  params: Record<string, unknown> = {},
+): unknown[] {
+  if (!abiFunction) {
+    return [];
+  }
+  if (abiFunction.inputs?.length !== Object.keys(params).length) {
+    throw new Error(
+      `Expected ${abiFunction.inputs?.length || 0} parameters, but got ${Object.keys(params).length}`,
+    );
+  }
+  return abiFunction.inputs.map((input, index) => {
+    const value = input.name;
+    if (value === undefined) {
+      throw new Error(
+        `Missing named parameter for ${"name" in abiFunction ? abiFunction.name : "constructor"} at index ${index}`,
+      );
+    }
+    const valueWithoutUnderscore = value.replace(/^_+/, "");
+    const normalizedValue = params[value] ?? params[valueWithoutUnderscore]; // handle _name, _symbol, etc passed without underscore in the keys
+    if (normalizedValue === undefined) {
+      throw new Error(`Missing value for parameter ${value} at index ${index}`);
+    }
+    return normalizedValue;
+  });
+}

package/src/utils/any-evm/compute-published-contract-address.ts

@@ -1,10 +1,8 @@
 import type { Chain } from "../../chains/types.js";
 import type { ThirdwebClient } from "../../client/client.js";
+import { fetchPublishedContractMetadata } from "../../contract/deployment/publisher.js";
 import { computeDeploymentAddress } from "./compute-deployment-address.js";
-import {
-  computeDeploymentInfoFromContractId,
-  computeDeploymentInfoFromMetadata,
-} from "./compute-published-contract-deploy-info.js";
+import { computeDeploymentInfoFromMetadata } from "./compute-published-contract-deploy-info.js";
 import type { FetchDeployMetadataResult } from "./deploy-metadata.js";
 
 /**
@@ -34,13 +32,24 @@ export async function computePublishedContractAddress(args: {
   client: ThirdwebClient;
   chain: Chain;
   contractId: string;
-  constructorParams: unknown[];
+  constructorParams?: Record<string, unknown>;
   publisher?: string;
   version?: string;
   salt?: string;
 }): Promise<string> {
-  const info = await computeDeploymentInfoFromContractId(args);
-  return computeDeploymentAddress(info);
+  const contractMetadata = await fetchPublishedContractMetadata({
+    client: args.client,
+    contractId: args.contractId,
+    publisher: args.publisher,
+    version: args.version,
+  });
+  return computeContractAddress({
+    client: args.client,
+    chain: args.chain,
+    contractMetadata,
+    constructorParams: args.constructorParams,
+    salt: args.salt,
+  });
 }
 
 /**
@@ -50,7 +59,7 @@ export async function computeContractAddress(args: {
   client: ThirdwebClient;
   chain: Chain;
   contractMetadata: FetchDeployMetadataResult;
-  constructorParams: unknown[];
+  constructorParams?: Record<string, unknown>;
   salt?: string;
 }): Promise<string> {
   const info = await computeDeploymentInfoFromMetadata(args);

package/src/utils/any-evm/compute-published-contract-deploy-info.ts

@@ -1,9 +1,12 @@
-import type { AbiConstructor } from "abitype";
+import type { Abi, AbiConstructor } from "abitype";
 import type { Chain } from "../../chains/types.js";
 import type { ThirdwebClient } from "../../client/client.js";
 import { fetchPublishedContractMetadata } from "../../contract/deployment/publisher.js";
 import { computeCreate2FactoryAddress } from "../../contract/deployment/utils/create-2-factory.js";
 import { encodeAbiParameters } from "../abi/encodeAbiParameters.js";
+import { normalizeFunctionParams } from "../abi/normalizeFunctionParams.js";
+import { ensureBytecodePrefix } from "../bytecode/prefix.js";
+import type { Hex } from "../encoding/hex.js";
 import type { FetchDeployMetadataResult } from "./deploy-metadata.js";
 import { getInitBytecodeWithSalt } from "./get-init-bytecode-with-salt.js";
 
@@ -14,7 +17,7 @@ export async function computeDeploymentInfoFromContractId(args: {
   client: ThirdwebClient;
   chain: Chain;
   contractId: string;
-  constructorParams: unknown[];
+  constructorParams?: Record<string, unknown>;
   publisher?: string;
   version?: string;
   salt?: string;
@@ -42,22 +45,39 @@ export async function computeDeploymentInfoFromMetadata(args: {
   client: ThirdwebClient;
   chain: Chain;
   contractMetadata: FetchDeployMetadataResult;
-  constructorParams: unknown[];
+  constructorParams?: Record<string, unknown>;
   salt?: string;
 }) {
-  const { client, chain, contractMetadata, constructorParams, salt } = args;
+  return computeDeploymentInfoFromBytecode({
+    client: args.client,
+    chain: args.chain,
+    abi: args.contractMetadata.abi,
+    bytecode: args.contractMetadata.bytecode,
+    constructorParams: args.constructorParams,
+    salt: args.salt,
+  });
+}
+
+export async function computeDeploymentInfoFromBytecode(args: {
+  client: ThirdwebClient;
+  chain: Chain;
+  abi: Abi;
+  bytecode: Hex;
+  constructorParams?: Record<string, unknown>;
+  salt?: string;
+}) {
+  const { client, chain, constructorParams, salt } = args;
   const create2FactoryAddress = await computeCreate2FactoryAddress({
     client,
     chain,
   });
-  const bytecode = contractMetadata.bytecode;
-  const constructorAbi =
-    (contractMetadata.abi.find(
-      (abi) => abi.type === "constructor",
-    ) as AbiConstructor) || [];
+  const bytecode = ensureBytecodePrefix(args.bytecode);
+  const constructorAbi = args.abi.find((abi) => abi.type === "constructor") as
+    | AbiConstructor
+    | undefined;
   const encodedArgs = encodeAbiParameters(
-    constructorAbi.inputs ?? [],
-    constructorParams,
+    constructorAbi?.inputs ?? [],
+    normalizeFunctionParams(constructorAbi, constructorParams),
   );
   const initBytecodeWithsalt = getInitBytecodeWithSalt({
     bytecode,

package/src/utils/bytecode/resolveImplementation.test.ts

@@ -1,4 +1,4 @@
-import type { AbiConstructor } from "abitype";
+import type { Abi } from "abitype";
 import { describe, expect, it } from "vitest";
 import {
   DUMMY_BYTECODE,
@@ -46,8 +46,7 @@ describe("Resolve implementation", async () => {
       chain: ANVIL_CHAIN,
       account: TEST_ACCOUNT_A,
       bytecode: DUMMY_BYTECODE,
-      constructorAbi: {} as AbiConstructor,
-      constructorParams: [],
+      abi: [],
     });
 
     const proxyAddress = await deployContract({
@@ -55,8 +54,11 @@ describe("Resolve implementation", async () => {
       chain: ANVIL_CHAIN,
       account: TEST_ACCOUNT_A,
       bytecode: ERC1967_PROXY_BYTECODE,
-      constructorAbi: ERC1967_PROXY_CONSTRUCTOR_ABI as AbiConstructor,
-      constructorParams: [implementationAddress, ""],
+      abi: ERC1967_PROXY_CONSTRUCTOR_ABI as Abi,
+      constructorParams: {
+        logic: implementationAddress,
+        data: "",
+      },
     });
 
     const proxy = getContract({

package/src/utils/caching/lru.test.ts

@@ -0,0 +1,38 @@
+import { expect, test } from "vitest";
+import { LruMap } from "./lru.js";
+
+test("default", () => {
+  const cache = new LruMap(5);
+  cache.set("a", 1);
+  cache.set("b", 2);
+  cache.set("c", 3);
+  cache.set("d", 4);
+  cache.set("e", 5);
+  cache.set("f", 6);
+  cache.set("g", 7);
+  expect(cache.size).toBe(5);
+  expect(cache.has("a")).toBe(false);
+  expect(cache.has("b")).toBe(false);
+  expect(cache.get("c")).toBe(3);
+  expect(cache.get("d")).toBe(4);
+  expect(cache.get("e")).toBe(5);
+  expect(cache.get("f")).toBe(6);
+  expect(cache.get("g")).toBe(7);
+});
+
+test("update touched keys", () => {
+  const cache = new LruMap(5);
+  cache.set("a", 1);
+  cache.set("b", 2);
+  cache.set("c", 3);
+  cache.set("d", 4);
+  cache.set("e", 5);
+  expect(cache.size).toBe(5);
+  cache.get("a");
+  cache.set("f", 6);
+  cache.set("g", 7);
+  expect(cache.has("a")).toBe(true);
+  expect(cache.has("b")).toBe(false);
+  expect(cache.has("c")).toBe(false);
+  expect(cache.has("d")).toBe(true);
+});

package/src/utils/caching/lru.ts

@@ -1,30 +1,34 @@
 /**
- * Represents a Least Recently Used (LRU) Map.
- * Extends the built-in Map class.
+ * Map with a LRU (Least recently used) policy.
+ *
+ * @link https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU
  */
 export class LruMap<value = unknown> extends Map<string, value> {
   maxSize: number;
 
-  /**
-   *
-   * @param size
-   * @internal
-   */
   constructor(size: number) {
     super();
     this.maxSize = size;
   }
 
-  /**
-   *
-   * @param key
-   * @param value
-   * @internal
-   */
+  override get(key: string) {
+    const value = super.get(key);
+
+    if (super.has(key) && value !== undefined) {
+      this.delete(key);
+      super.set(key, value);
+    }
+
+    return value;
+  }
+
   override set(key: string, value: value) {
     super.set(key, value);
     if (this.maxSize && this.size > this.maxSize) {
-      this.delete(this.keys().next().value);
+      const firstKey = this.keys().next().value;
+      if (firstKey) {
+        this.delete(firstKey);
+      }
     }
     return this;
   }

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.53.1-nightly-865c5e3b16af70c3660f30ba8cffc5d6e360a389-20240911000352";
+export const version = "5.54.0";

package/src/wallets/in-app/core/eip5972/in-app-wallet-calls.ts

@@ -3,6 +3,7 @@ import { eth_getTransactionReceipt } from "../../../../rpc/actions/eth_getTransa
 import { getRpcClient } from "../../../../rpc/rpc.js";
 import { sendAndConfirmTransaction } from "../../../../transaction/actions/send-and-confirm-transaction.js";
 import { sendBatchTransaction } from "../../../../transaction/actions/send-batch-transaction.js";
+import { LruMap } from "../../../../utils/caching/lru.js";
 import type { Hex } from "../../../../utils/encoding/hex.js";
 import { randomBytesHex } from "../../../../utils/random.js";
 import type { PreparedSendCall } from "../../../eip5792/send-calls.js";
@@ -13,19 +14,7 @@ import type {
 } from "../../../eip5792/types.js";
 import type { Account, Wallet } from "../../../interfaces/wallet.js";
 
-const bundlesToTransactions = new Map<string, Hex[]>();
-const MAX_BUNDLE_ENTRIES = 1000;
-
-/**
- * @internal
- */
-function setBundleId(bundleId: Hex, hashes: Hex[]) {
-  if (bundlesToTransactions.size >= MAX_BUNDLE_ENTRIES) {
-    const lru = bundlesToTransactions.keys().next().value;
-    bundlesToTransactions.delete(lru);
-  }
-  bundlesToTransactions.set(bundleId, hashes);
-}
+const bundlesToTransactions = new LruMap<Hex[]>(1000);
 
 /**
  * @internal
@@ -45,7 +34,7 @@ export async function inAppWalletSendCalls(args: {
       transactions: calls,
     });
     hashes.push(receipt.transactionHash);
-    setBundleId(bundleId, hashes);
+    bundlesToTransactions.set(bundleId, hashes);
   } else {
     for (const tx of calls) {
       const receipt = await sendAndConfirmTransaction({

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