thirdweb 5.101.2 → 5.102.1

package/src/engine/server-wallet.ts

@@ -19,7 +19,7 @@ import type {
   Account,
   SendTransactionOption,
 } from "../wallets/interfaces/wallet.js";
-import { waitForTransactionHash } from "./get-status.js";
+import { waitForTransactionHash } from "./wait-for-tx-hash.js";
 
 /**
  * Options for creating an server wallet.
@@ -54,6 +54,9 @@ export type ServerWallet = Account & {
     transaction: PreparedTransaction;
     simulate?: boolean;
   }) => Promise<{ transactionId: string }>;
+  enqueueBatchTransaction: (args: {
+    transactions: PreparedTransaction[];
+  }) => Promise<{ transactionId: string }>;
 };
 
 /**
@@ -102,6 +105,37 @@ export type ServerWallet = Account & {
  * console.log("Transaction sent:", transactionHash);
  * ```
  *
+ *  ### Sending a batch of transactions
+ * ```ts
+ * // prepare the transactions
+ * const transaction1 = claimTo({
+ *   contract,
+ *   to: firstRecipient,
+ *   quantity: 1n,
+ * });
+ * const transaction2 = claimTo({
+ *   contract,
+ *   to: secondRecipient,
+ *   quantity: 1n,
+ * });
+ *
+ *
+ * // enqueue the transactions in a batch
+ * const { transactionId } = await myServerWallet.enqueueBatchTransaction({
+ *   transactions: [transaction1, transaction2],
+ * });
+ * ```
+ *
+ * ### Polling for the batch of transactions to be submitted onchain
+ * ```ts
+ * // optionally poll for the transaction to be submitted onchain
+ * const { transactionHash } = await Engine.waitForTransactionHash({
+ *   client,
+ *   transactionId,
+ * });
+ * console.log("Transaction sent:", transactionHash);
+ * ```
+ *
  * ### Getting the execution status of a transaction
  * ```ts
  * const executionResult = await Engine.getTransactionStatus({
@@ -130,16 +164,30 @@ export function serverWallet(options: ServerWalletOptions): ServerWallet {
         };
   };
 
-  const enqueueTx = async (transaction: SendTransactionOption) => {
+  const enqueueTx = async (transaction: SendTransactionOption[]) => {
+    if (transaction.length === 0) {
+      throw new Error("No transactions to enqueue");
+    }
+    const firstTransaction = transaction[0];
+    if (!firstTransaction) {
+      throw new Error("No transactions to enqueue");
+    }
+    const chainId = firstTransaction.chainId;
+    // Validate all transactions are on the same chain
+    for (let i = 1; i < transaction.length; i++) {
+      if (transaction[i]?.chainId !== chainId) {
+        throw new Error(
+          `All transactions in batch must be on the same chain. Expected ${chainId}, got ${transaction[i]?.chainId} at index ${i}`,
+        );
+      }
+    }
     const body = {
-      executionOptions: getExecutionOptions(transaction.chainId),
-      params: [
-        {
-          to: transaction.to ?? undefined,
-          data: transaction.data,
-          value: transaction.value?.toString(),
-        },
-      ],
+      executionOptions: getExecutionOptions(chainId),
+      params: transaction.map((t) => ({
+        to: t.to ?? undefined,
+        data: t.data,
+        value: t.value?.toString(),
+      })),
     };
 
     const result = await sendTransaction({
@@ -158,11 +206,7 @@ export function serverWallet(options: ServerWalletOptions): ServerWallet {
     if (!data) {
       throw new Error("No data returned from engine");
     }
-    const transactionId = data.transactions?.[0]?.id;
-    if (!transactionId) {
-      throw new Error("No transactionId returned from engine");
-    }
-    return transactionId;
+    return data.transactions.map((t) => t.id);
   };
 
   return {
@@ -193,11 +237,54 @@ export function serverWallet(options: ServerWalletOptions): ServerWallet {
           value: value ?? undefined,
         };
       }
-      const transactionId = await enqueueTx(serializedTransaction);
+      const transactionIds = await enqueueTx([serializedTransaction]);
+      const transactionId = transactionIds[0];
+      if (!transactionId) {
+        throw new Error("No transactionId returned from engine");
+      }
+      return { transactionId };
+    },
+    enqueueBatchTransaction: async (args: {
+      transactions: PreparedTransaction[];
+    }) => {
+      const serializedTransactions: SendTransactionOption[] = [];
+      for (const transaction of args.transactions) {
+        const [to, data, value] = await Promise.all([
+          transaction.to ? resolvePromisedValue(transaction.to) : null,
+          encode(transaction),
+          transaction.value ? resolvePromisedValue(transaction.value) : null,
+        ]);
+        serializedTransactions.push({
+          chainId: transaction.chain.id,
+          data,
+          to: to ?? undefined,
+          value: value ?? undefined,
+        });
+      }
+      const transactionIds = await enqueueTx(serializedTransactions);
+      const transactionId = transactionIds[0];
+      if (!transactionId) {
+        throw new Error("No transactionId returned from engine");
+      }
       return { transactionId };
     },
     sendTransaction: async (transaction: SendTransactionOption) => {
-      const transactionId = await enqueueTx(transaction);
+      const transactionIds = await enqueueTx([transaction]);
+      const transactionId = transactionIds[0];
+      if (!transactionId) {
+        throw new Error("No transactionId returned from engine");
+      }
+      return waitForTransactionHash({
+        client,
+        transactionId,
+      });
+    },
+    sendBatchTransaction: async (transactions: SendTransactionOption[]) => {
+      const transactionIds = await enqueueTx(transactions);
+      const transactionId = transactionIds[0];
+      if (!transactionId) {
+        throw new Error("No transactionId returned from engine");
+      }
       return waitForTransactionHash({
         client,
         transactionId,

package/src/engine/wait-for-tx-hash.ts

@@ -0,0 +1,75 @@
+import { stringify } from "viem";
+
+import type { Hex } from "../utils/encoding/hex.js";
+
+import type { ThirdwebClient } from "../client/client.js";
+import type { WaitForReceiptOptions } from "../transaction/actions/wait-for-tx-receipt.js";
+import { getTransactionStatus } from "./get-status.js";
+
+/**
+ * Wait for a transaction to be submitted onchain and return the transaction hash.
+ * @param args - The arguments for the transaction.
+ * @param args.client - The thirdweb client to use.
+ * @param args.transactionId - The id of the transaction to wait for.
+ * @param args.timeoutInSeconds - The timeout in seconds.
+ * @engine
+ * @example
+ * ```ts
+ * import { Engine } from "thirdweb";
+ *
+ * const { transactionHash } = await Engine.waitForTransactionHash({
+ *   client,
+ *   transactionId, // the transaction id returned from enqueueTransaction
+ * });
+ * ```
+ */
+export async function waitForTransactionHash(args: {
+  client: ThirdwebClient;
+  transactionId: string;
+  timeoutInSeconds?: number;
+}): Promise<WaitForReceiptOptions> {
+  const startTime = Date.now();
+  const TIMEOUT_IN_MS = args.timeoutInSeconds
+    ? args.timeoutInSeconds * 1000
+    : 5 * 60 * 1000; // 5 minutes in milliseconds
+
+  while (Date.now() - startTime < TIMEOUT_IN_MS) {
+    const executionResult = await getTransactionStatus(args);
+    const status = executionResult.status;
+
+    switch (status) {
+      case "FAILED": {
+        throw new Error(
+          `Transaction failed: ${executionResult.error || "Unknown error"}`,
+        );
+      }
+      case "CONFIRMED": {
+        const onchainStatus =
+          executionResult && "onchainStatus" in executionResult
+            ? executionResult.onchainStatus
+            : null;
+        if (onchainStatus === "REVERTED") {
+          const revertData =
+            "revertData" in executionResult
+              ? executionResult.revertData
+              : undefined;
+          throw new Error(
+            `Transaction reverted: ${revertData?.errorName || "unknown error"} ${revertData?.errorArgs ? stringify(revertData.errorArgs) : ""} - ${executionResult.transactionHash ? executionResult.transactionHash : ""}`,
+          );
+        }
+        return {
+          transactionHash: executionResult.transactionHash as Hex,
+          client: args.client,
+          chain: executionResult.chain,
+        };
+      }
+      default: {
+        // wait for the transaction to be confirmed
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+      }
+    }
+  }
+  throw new Error(
+    `Transaction timed out after ${TIMEOUT_IN_MS / 1000} seconds`,
+  );
+}

package/src/extensions/erc1155/read/getOwnedNFTs.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+
+import { DROP1155_CONTRACT } from "~test/test-contracts.js";
+import { getOwnedNFTs } from "./getOwnedNFTs.js";
+
+describe.runIf(process.env.TW_SECRET_KEY)("erc1155.getOwnedNFTs", () => {
+  it("with indexer", async () => {
+    const nfts = await getOwnedNFTs({
+      contract: DROP1155_CONTRACT,
+      address: "0x00d4da27dedce60f859471d8f595fdb4ae861557",
+    });
+    expect(nfts.length).toBe(3);
+    expect(nfts.find((nft) => nft.id === 4n)?.quantityOwned).toBe(411n);
+  });
+
+  it("without indexer", async () => {
+    const nfts = await getOwnedNFTs({
+      contract: DROP1155_CONTRACT,
+      address: "0x00d4da27dedce60f859471d8f595fdb4ae861557",
+      useIndexer: false,
+    });
+    expect(nfts.length).toBe(3);
+    expect(nfts.find((nft) => nft.id === 4n)?.quantityOwned).toBe(411n);
+  });
+});

package/src/extensions/erc20/drop20.test.ts

@@ -11,7 +11,7 @@ import {
 import { type ThirdwebContract, getContract } from "../../contract/contract.js";
 import { sendAndConfirmTransaction } from "../../transaction/actions/send-and-confirm-transaction.js";
 import { resolvePromisedValue } from "../../utils/promise/resolve-promised-value.js";
-import { toEther } from "../../utils/units.js";
+import { toEther, toWei } from "../../utils/units.js";
 import { name } from "../common/read/name.js";
 import { deployERC20Contract } from "../prebuilts/deploy-erc20.js";
 import { canClaim } from "./drops/read/canClaim.js";
@@ -20,6 +20,8 @@ import { claimTo } from "./drops/write/claimTo.js";
 import { resetClaimEligibility } from "./drops/write/resetClaimEligibility.js";
 import { setClaimConditions } from "./drops/write/setClaimConditions.js";
 import { getBalance } from "./read/getBalance.js";
+import { getApprovalForTransaction } from "./write/getApprovalForTransaction.js";
+import { mintTo } from "./write/mintTo.js";
 
 describe.runIf(process.env.TW_SECRET_KEY)(
   "DropERC20",
@@ -135,6 +137,94 @@ describe.runIf(process.env.TW_SECRET_KEY)(
       ).toBe("2");
     });
 
+    it("should allow to claim tokens with erc20 price", async () => {
+      expect(
+        (await getBalance({ contract, address: TEST_ACCOUNT_C.address }))
+          .displayValue,
+      ).toBe("2");
+      const erc20ContractAddres = await deployERC20Contract({
+        account: TEST_ACCOUNT_A,
+        chain: ANVIL_CHAIN,
+        client: TEST_CLIENT,
+        type: "TokenERC20",
+        params: {
+          name: "Test DropERC20",
+        },
+      });
+      const erc20Contract = getContract({
+        address: erc20ContractAddres,
+        chain: ANVIL_CHAIN,
+        client: TEST_CLIENT,
+      });
+      const mintToTx = mintTo({
+        contract: erc20Contract,
+        to: TEST_ACCOUNT_C.address,
+        amount: "0.02",
+      });
+      await sendAndConfirmTransaction({
+        transaction: mintToTx,
+        account: TEST_ACCOUNT_A,
+      });
+      expect(
+        (
+          await getBalance({
+            contract: erc20Contract,
+            address: TEST_ACCOUNT_C.address,
+          })
+        ).displayValue,
+      ).toBe("0.02");
+      // set cc with price
+      await sendAndConfirmTransaction({
+        transaction: setClaimConditions({
+          contract,
+          phases: [
+            {
+              price: "0.01",
+              currencyAddress: erc20ContractAddres,
+            },
+          ],
+        }),
+        account: TEST_ACCOUNT_A,
+      });
+      const claimTx = claimTo({
+        contract,
+        to: TEST_ACCOUNT_C.address,
+        quantity: "2",
+      });
+      // assert value is set correctly
+      const value = await resolvePromisedValue(claimTx.erc20Value);
+      expect(value).toBeDefined();
+      if (!value) throw new Error("value is undefined");
+      expect(value.amountWei).toBe(toWei("0.02"));
+      const approve = await getApprovalForTransaction({
+        transaction: claimTx,
+        account: TEST_ACCOUNT_C,
+      });
+      if (approve) {
+        await sendAndConfirmTransaction({
+          transaction: approve,
+          account: TEST_ACCOUNT_C,
+        });
+      }
+      // claim
+      await sendAndConfirmTransaction({
+        transaction: claimTx,
+        account: TEST_ACCOUNT_C,
+      });
+      expect(
+        (await getBalance({ contract, address: TEST_ACCOUNT_C.address }))
+          .displayValue,
+      ).toBe("4");
+      expect(
+        (
+          await getBalance({
+            contract: erc20Contract,
+            address: TEST_ACCOUNT_C.address,
+          })
+        ).displayValue,
+      ).toBe("0");
+    });
+
     describe("Allowlists", () => {
       it("should allow to claim tokens with an allowlist", async () => {
         await sendAndConfirmTransaction({

package/src/insight/get-nfts.ts

@@ -319,7 +319,12 @@ async function transformNFTModel(
         });
       }
 
-      return parsedNft;
+      return {
+        ...parsedNft,
+        ...(contract?.type === "erc1155"
+          ? { quantityOwned: balance ? BigInt(balance) : undefined }
+          : {}),
+      };
     }),
   );
 }

package/src/react/native/hooks/wallets/useUnlinkProfile.test.tsx

@@ -40,6 +40,32 @@ describe("useUnlinkProfile", () => {
       client: TEST_CLIENT,
       ecosystem: undefined,
       profileToUnlink: mockProfile,
+      allowAccountDeletion: false,
+    });
+    expect(queryClient.invalidateQueries).toHaveBeenCalledWith({
+      queryKey: ["profiles"],
+    });
+  });
+
+  it("should call unlinkProfile with allowAccountDeletion if true", async () => {
+    const { result } = renderHook(() => useUnlinkProfile(), {
+      wrapper,
+    });
+    const mutationFn = result.current.mutateAsync;
+
+    await act(async () => {
+      await mutationFn({
+        client: TEST_CLIENT,
+        profileToUnlink: mockProfile,
+        allowAccountDeletion: true,
+      });
+    });
+
+    expect(unlinkProfile).toHaveBeenCalledWith({
+      client: TEST_CLIENT,
+      ecosystem: undefined,
+      profileToUnlink: mockProfile,
+      allowAccountDeletion: true,
     });
     expect(queryClient.invalidateQueries).toHaveBeenCalledWith({
       queryKey: ["profiles"],
@@ -70,6 +96,7 @@ describe("useUnlinkProfile", () => {
           ?.partnerId,
       },
       profileToUnlink: mockProfile,
+      allowAccountDeletion: false,
     });
   });
 });

package/src/react/native/hooks/wallets/useUnlinkProfile.ts

@@ -31,6 +31,23 @@ import { useConnectedWallets } from "../../../core/hooks/wallets/useConnectedWal
  * };
  * ```
  *
+ * ### Unlinking an email account with account deletion
+ *
+ * ```jsx
+ * import { useUnlinkProfile } from "thirdweb/react";
+ *
+ * const { mutate: unlinkProfile } = useUnlinkProfile();
+ *
+ * const onClick = () => {
+ *   unlinkProfile({
+ *     client,
+ *      // Select the profile you want to unlink
+ *     profileToUnlink: connectedProfiles[0],
+ *     allowAccountDeletion: true, // This will delete the account if it's the last profile linked to the account
+ *   });
+ * };
+ * ```
+ *
  * @wallet
  */
 export function useUnlinkProfile() {
@@ -40,7 +57,12 @@ export function useUnlinkProfile() {
     mutationFn: async ({
       client,
       profileToUnlink,
-    }: { client: ThirdwebClient; profileToUnlink: Profile }) => {
+      allowAccountDeletion = false,
+    }: {
+      client: ThirdwebClient;
+      profileToUnlink: Profile;
+      allowAccountDeletion?: boolean;
+    }) => {
       const ecosystemWallet = wallets.find((w) => isEcosystemWallet(w));
       const ecosystem: Ecosystem | undefined = ecosystemWallet
         ? {
@@ -53,6 +75,7 @@ export function useUnlinkProfile() {
         client,
         ecosystem,
         profileToUnlink,
+        allowAccountDeletion,
       });
     },
     onSuccess: () => {

package/src/react/web/hooks/wallets/useUnlinkProfile.test.tsx

@@ -40,6 +40,7 @@ describe("useUnlinkProfile", () => {
       client: TEST_CLIENT,
       ecosystem: undefined,
       profileToUnlink: mockProfile,
+      allowAccountDeletion: false,
     });
     expect(queryClient.invalidateQueries).toHaveBeenCalledWith({
       queryKey: ["profiles"],
@@ -70,6 +71,7 @@ describe("useUnlinkProfile", () => {
           ?.partnerId,
       },
       profileToUnlink: mockProfile,
+      allowAccountDeletion: false,
     });
   });
 });

package/src/react/web/hooks/wallets/useUnlinkProfile.ts

@@ -31,6 +31,23 @@ import { useConnectedWallets } from "../../../core/hooks/wallets/useConnectedWal
  * };
  * ```
  *
+ * ### Unlinking an email account with account deletion
+ *
+ * ```jsx
+ * import { useUnlinkProfile } from "thirdweb/react";
+ *
+ * const { mutate: unlinkProfile } = useUnlinkProfile();
+ *
+ * const onClick = () => {
+ *   unlinkProfile({
+ *     client,
+ *      // Select the profile you want to unlink
+ *     profileToUnlink: connectedProfiles[0],
+ *     allowAccountDeletion: true, // This will delete the account if it's the last profile linked to the account
+ *   });
+ * };
+ * ```
+ *
  * @wallet
  */
 export function useUnlinkProfile() {
@@ -40,7 +57,12 @@ export function useUnlinkProfile() {
     mutationFn: async ({
       client,
       profileToUnlink,
-    }: { client: ThirdwebClient; profileToUnlink: Profile }) => {
+      allowAccountDeletion = false,
+    }: {
+      client: ThirdwebClient;
+      profileToUnlink: Profile;
+      allowAccountDeletion?: boolean;
+    }) => {
       const ecosystemWallet = wallets.find((w) => isEcosystemWallet(w));
       const ecosystem: Ecosystem | undefined = ecosystemWallet
         ? {
@@ -53,6 +75,7 @@ export function useUnlinkProfile() {
         client,
         ecosystem,
         profileToUnlink,
+        allowAccountDeletion,
       });
     },
     onSuccess: () => {

package/src/utils/fetch.ts

@@ -127,6 +127,7 @@ const THIRDWEB_DOMAINS = [
   // dev domains
   ".thirdweb.dev",
   ".thirdweb-dev.com",
+  ".thirdwebstorage-dev.com",
 ] as const;
 
 export const IS_THIRDWEB_URL_CACHE = new LruMap<boolean>(4096);

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.101.2";
+export const version = "5.102.1";

package/src/wallets/in-app/core/authentication/linkAccount.test.ts

@@ -90,7 +90,37 @@ describe("Account linking functions", () => {
             Authorization: "Bearer iaw-auth-token:mock-token",
             "Content-Type": "application/json",
           },
-          body: JSON.stringify(profileToUnlink),
+          body: JSON.stringify({
+            type: profileToUnlink.type,
+            details: profileToUnlink.details,
+            allowAccountDeletion: false,
+          }),
+        },
+      );
+      expect(result).toEqual(mockLinkedAccounts);
+    });
+
+    it("should successfully unlink an account with allowAccountDeletion", async () => {
+      const result = await unlinkAccount({
+        client: mockClient,
+        profileToUnlink,
+        storage: mockStorage,
+        allowAccountDeletion: true,
+      });
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        "https://embedded-wallet.thirdweb.com/api/2024-05-05/account/disconnect",
+        {
+          method: "POST",
+          headers: {
+            Authorization: "Bearer iaw-auth-token:mock-token",
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({
+            type: profileToUnlink.type,
+            details: profileToUnlink.details,
+            allowAccountDeletion: true,
+          }),
         },
       );
       expect(result).toEqual(mockLinkedAccounts);

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

@@ -66,11 +66,13 @@ export async function unlinkAccount({
   client,
   ecosystem,
   profileToUnlink,
+  allowAccountDeletion = false,
   storage,
 }: {
   client: ThirdwebClient;
   ecosystem?: Ecosystem;
   profileToUnlink: Profile;
+  allowAccountDeletion?: boolean;
   storage: ClientScopedStorage;
 }): Promise<Profile[]> {
   const clientFetch = getClientFetch(client, ecosystem);
@@ -90,7 +92,11 @@ export async function unlinkAccount({
     {
       method: "POST",
       headers,
-      body: stringify(profileToUnlink),
+      body: stringify({
+        type: profileToUnlink.type,
+        details: profileToUnlink.details,
+        allowAccountDeletion,
+      }),
     },
   );
 

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

@@ -259,4 +259,5 @@ export type UnlinkParams = {
   client: ThirdwebClient;
   ecosystem?: Ecosystem;
   profileToUnlink: Profile;
+  allowAccountDeletion?: boolean;
 };

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

@@ -37,7 +37,10 @@ export interface InAppConnector {
   ): Promise<AuthLoginReturnType>;
   logout(): Promise<LogoutReturnType>;
   linkProfile(args: AuthArgsType): Promise<Profile[]>;
-  unlinkProfile(args: Profile): Promise<Profile[]>;
+  unlinkProfile(
+    args: Profile,
+    allowAccountDeletion?: boolean,
+  ): Promise<Profile[]>;
   getProfiles(): Promise<Profile[]>;
   storage: ClientScopedStorage;
 }

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

@@ -203,7 +203,10 @@ export async function linkProfile(args: AuthArgsType) {
  */
 export async function unlinkProfile(args: UnlinkParams) {
   const connector = await getInAppWalletConnector(args.client, args.ecosystem);
-  return await connector.unlinkProfile(args.profileToUnlink);
+  return await connector.unlinkProfile(
+    args.profileToUnlink,
+    args.allowAccountDeletion,
+  );
 }
 
 /**

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

@@ -367,7 +367,7 @@ export class InAppNativeConnector implements InAppConnector {
     });
   }
 
-  async unlinkProfile(profile: Profile) {
+  async unlinkProfile(profile: Profile, allowAccountDeletion?: boolean) {
     const { unlinkAccount } = await import(
       "../core/authentication/linkAccount.js"
     );
@@ -376,6 +376,7 @@ export class InAppNativeConnector implements InAppConnector {
       ecosystem: this.ecosystem,
       storage: this.storage,
       profileToUnlink: profile,
+      allowAccountDeletion,
     });
   }