thirdweb 5.50.1 → 5.51.0

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

@@ -6,6 +6,7 @@ import {
   TEST_ACCOUNT_A,
   TEST_ACCOUNT_B,
   TEST_ACCOUNT_C,
+  TEST_ACCOUNT_D,
 } from "../../../test/src/test-wallets.js";
 import { type ThirdwebContract, getContract } from "../../contract/contract.js";
 import { sendAndConfirmTransaction } from "../../transaction/actions/send-and-confirm-transaction.js";
@@ -13,7 +14,9 @@ import { resolvePromisedValue } from "../../utils/promise/resolve-promised-value
 import { toEther } from "../../utils/units.js";
 import { getContractMetadata } from "../common/read/getContractMetadata.js";
 import { deployERC20Contract } from "../prebuilts/deploy-erc20.js";
+import { getClaimConditions } from "./drops/read/getClaimConditions.js";
 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";
 
@@ -262,7 +265,7 @@ describe.runIf(process.env.TW_SECRET_KEY)(
           [TransactionError: Error - !Qty
 
           contract: ${contract.address}
-          chainId: 31337]
+          chainId: ${contract.chain.id}]
         `);
 
         // we now try to claim just ONE more token
@@ -345,5 +348,113 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         }
       `);
     });
+
+    it("should be able to retrieve multiple phases", async () => {
+      await sendAndConfirmTransaction({
+        transaction: setClaimConditions({
+          contract,
+          phases: [
+            {
+              maxClaimablePerWallet: 1n,
+              startTime: new Date(0),
+            },
+            {
+              maxClaimablePerWallet: 2n,
+              startTime: new Date(),
+            },
+          ],
+        }),
+        account: TEST_ACCOUNT_A,
+      });
+
+      const phases = await getClaimConditions({ contract });
+      expect(phases).toHaveLength(2);
+      expect(phases[0]?.quantityLimitPerWallet).toBe(1n);
+      expect(phases[1]?.quantityLimitPerWallet).toBe(2n);
+    });
+
+    it("should be able to reset claim eligibility", async () => {
+      // set claim conditions to only allow one claim
+      await sendAndConfirmTransaction({
+        transaction: setClaimConditions({
+          contract,
+          phases: [
+            {
+              maxClaimablePerWallet: 1n,
+            },
+          ],
+        }),
+        account: TEST_ACCOUNT_A,
+      });
+      // claim one token
+      await sendAndConfirmTransaction({
+        transaction: claimTo({
+          contract,
+          // fresh account to avoid any previous claims
+          to: TEST_ACCOUNT_D.address,
+          quantityInWei: 1n,
+        }),
+        // fresh account to avoid any previous claims
+        account: TEST_ACCOUNT_D,
+      });
+      // check that the account has claimed one token
+      await expect(
+        getBalance({ contract, address: TEST_ACCOUNT_D.address }),
+      ).resolves.toMatchInlineSnapshot(`
+        {
+          "decimals": 18,
+          "displayValue": "0.000000000000000001",
+          "name": "Test DropERC20",
+          "symbol": "",
+          "value": 1n,
+        }
+      `);
+
+      // attempt to claim another token (this should fail)
+      await expect(
+        sendAndConfirmTransaction({
+          transaction: claimTo({
+            contract,
+            to: TEST_ACCOUNT_D.address,
+            quantityInWei: 1n,
+          }),
+          account: TEST_ACCOUNT_D,
+        }),
+      ).rejects.toThrowErrorMatchingInlineSnapshot(`
+        [TransactionError: Error - !Qty
+
+        contract: ${contract.address}
+        chainId: ${contract.chain.id}]
+      `);
+
+      // reset claim eligibility
+      await sendAndConfirmTransaction({
+        transaction: resetClaimEligibility({
+          contract,
+        }),
+        account: TEST_ACCOUNT_A,
+      });
+      // attempt to claim another token (this should succeed)
+      await sendAndConfirmTransaction({
+        transaction: claimTo({
+          contract,
+          to: TEST_ACCOUNT_D.address,
+          quantityInWei: 1n,
+        }),
+        account: TEST_ACCOUNT_D,
+      });
+      // check that the account has claimed two tokens
+      await expect(
+        getBalance({ contract, address: TEST_ACCOUNT_D.address }),
+      ).resolves.toMatchInlineSnapshot(`
+        {
+          "decimals": 18,
+          "displayValue": "0.000000000000000002",
+          "name": "Test DropERC20",
+          "symbol": "",
+          "value": 2n,
+        }
+      `);
+    });
   },
 );

package/src/extensions/erc20/drops/read/getActiveClaimCondition.ts

@@ -1,6 +1,5 @@
 import type { BaseTransactionOptions } from "../../../../transaction/types.js";
 import type { ClaimCondition } from "../../../../utils/extensions/drops/types.js";
-import * as Single from "../../__generated__/DropSinglePhase/read/claimCondition.js";
 import * as MultiActiveId from "../../__generated__/IDropERC20/read/getActiveClaimConditionId.js";
 import * as MultiById from "../../__generated__/IDropERC20/read/getClaimConditionById.js";
 
@@ -19,57 +18,19 @@ import * as MultiById from "../../__generated__/IDropERC20/read/getClaimConditio
 export async function getActiveClaimCondition(
   options: BaseTransactionOptions,
 ): Promise<ClaimCondition> {
-  const getActiveClaimConditionMultiPhase = async () => {
+  try {
     const conditionId = await MultiActiveId.getActiveClaimConditionId(options);
     return MultiById.getClaimConditionById({ ...options, conditionId });
-  };
-  const getActiveClaimConditionSinglePhase = async () => {
-    const [
-      startTimestamp,
-      maxClaimableSupply,
-      supplyClaimed,
-      quantityLimitPerWallet,
-      merkleRoot,
-      pricePerToken,
-      currency,
-      metadata,
-    ] = await Single.claimCondition(options);
-    return {
-      startTimestamp,
-      maxClaimableSupply,
-      supplyClaimed,
-      quantityLimitPerWallet,
-      merkleRoot,
-      pricePerToken,
-      currency,
-      metadata,
-    };
-  };
-
-  // The contract's phase type is unknown, so try both options and return whichever resolves, prioritizing multi-phase
-  const results = await Promise.allSettled([
-    getActiveClaimConditionMultiPhase(),
-    getActiveClaimConditionSinglePhase(),
-  ]);
-
-  const condition = results.find((result) => result.status === "fulfilled");
-  if (condition?.status === "fulfilled") {
-    return condition.value;
+  } catch {
+    throw new Error("Claim condition not found");
   }
-  throw new Error("Claim condition not found");
 }
 
 export function isGetActiveClaimConditionSupported(
   availableSelectors: string[],
 ) {
-  // either needs to have the single-phase claim condition or the multi-phase claim condition
-  return [
-    // either the single-phase claim condition is supported
-    Single.isClaimConditionSupported(availableSelectors),
-    // or the multi-phase claim condition is supported (both methods are required)
-    [
-      MultiActiveId.isGetActiveClaimConditionIdSupported(availableSelectors),
-      MultiById.isGetClaimConditionByIdSupported(availableSelectors),
-    ].every(Boolean),
-  ].some(Boolean);
+  return (
+    MultiActiveId.isGetActiveClaimConditionIdSupported(availableSelectors) &&
+    MultiById.isGetClaimConditionByIdSupported(availableSelectors)
+  );
 }

package/src/extensions/erc20/drops/read/getClaimConditions.ts

@@ -0,0 +1,59 @@
+import type { BaseTransactionOptions } from "../../../../transaction/types.js";
+import type { ClaimCondition } from "../../../../utils/extensions/drops/types.js";
+import * as MultiPhase from "../../__generated__/IDropERC20/read/claimCondition.js";
+import * as MultiById from "../../__generated__/IDropERC20/read/getClaimConditionById.js";
+
+/**
+ * Retrieves all claim conditions.
+ * @param options - The transaction options.
+ * @returns A promise that resolves to all claim conditions.
+ * @throws An error if the claim conditions are unsupported by the contract.
+ * @extension ERC20
+ * @example
+ * ```ts
+ * import { getClaimConditions } from "thirdweb/extensions/erc20";
+ * const conditions = await getClaimConditions({ contract });
+ * ```
+ */
+export async function getClaimConditions(
+  options: BaseTransactionOptions,
+): Promise<ClaimCondition[]> {
+  try {
+    const [startId, count] = await MultiPhase.claimCondition(options);
+
+    const conditionPromises: Array<
+      ReturnType<typeof MultiById.getClaimConditionById>
+    > = [];
+    for (let i = startId; i < count; i++) {
+      conditionPromises.push(
+        MultiById.getClaimConditionById({
+          ...options,
+          conditionId: i,
+        }),
+      );
+    }
+    return Promise.all(conditionPromises);
+  } catch {
+    throw new Error("Claim condition not found");
+  }
+}
+
+/**
+ * Checks if the `getClaimConditions` method is supported by the given contract.
+ * @param availableSelectors An array of 4byte function selectors of the contract. You can get this in various ways, such as using "whatsabi" or if you have the ABI of the contract available you can use it to generate the selectors.
+ * @returns A boolean indicating if the `getClaimConditions` method is supported.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { isGetClaimConditionsSupported } from "thirdweb/extensions/erc721";
+ *
+ * const supported = isGetClaimConditionsSupported(["0x..."]);
+ * ```
+ */
+export function isGetClaimConditionsSupported(availableSelectors: string[]) {
+  // if multi phase is supported, return true
+  return (
+    MultiPhase.isClaimConditionSupported(availableSelectors) &&
+    MultiById.isGetClaimConditionByIdSupported(availableSelectors)
+  );
+}

package/src/extensions/erc20/drops/write/claimTo.ts

@@ -1,8 +1,9 @@
 import type { Address } from "abitype";
 import type { BaseTransactionOptions } from "../../../../transaction/types.js";
 import { getClaimParams } from "../../../../utils/extensions/drops/get-claim-params.js";
-import * as generatedClaim from "../../__generated__/IDropERC20/write/claim.js";
-import { decimals } from "../../read/decimals.js";
+import { isGetContractMetadataSupported } from "../../../common/read/getContractMetadata.js";
+import * as GeneratedClaim from "../../__generated__/IDropERC20/write/claim.js";
+import { decimals, isDecimalsSupported } from "../../read/decimals.js";
 import { isGetActiveClaimConditionSupported } from "../read/getActiveClaimCondition.js";
 
 /**
@@ -35,7 +36,7 @@ export type ClaimToParams = {
  * @returns A promise that resolves with the submitted transaction hash.
  */
 export function claimTo(options: BaseTransactionOptions<ClaimToParams>) {
-  return generatedClaim.claim({
+  return GeneratedClaim.claim({
     contract: options.contract,
     asyncParams: async () => {
       const quantity = await (async () => {
@@ -62,11 +63,27 @@ export function claimTo(options: BaseTransactionOptions<ClaimToParams>) {
   });
 }
 
+/**
+ * Checks if the `claimTo` method is supported by the given contract.
+ * @param availableSelectors An array of 4byte function selectors of the contract. You can get this in various ways, such as using "whatsabi" or if you have the ABI of the contract available you can use it to generate the selectors.
+ * @returns A boolean indicating if the `claimTo` method is supported.
+ * @extension ERC20
+ * @example
+ * ```ts
+ * import { isClaimToSupported } from "thirdweb/extensions/erc20";
+ *
+ * const supported = isClaimToSupported(["0x..."]);
+ * ```
+ */
 export function isClaimToSupported(availableSelectors: string[]) {
   return [
     // has to support the claim method
-    generatedClaim.isClaimSupported(availableSelectors),
+    GeneratedClaim.isClaimSupported(availableSelectors),
     // has to support the getActiveClaimCondition method
     isGetActiveClaimConditionSupported(availableSelectors),
+    // has to support the decimals method
+    isDecimalsSupported(availableSelectors),
+    // requires contractMetadata for claimer proofs
+    isGetContractMetadataSupported(availableSelectors),
   ].every(Boolean);
 }

package/src/extensions/erc20/drops/write/resetClaimEligibility.ts

@@ -0,0 +1,70 @@
+import type { Hex } from "viem";
+import type { BaseTransactionOptions } from "../../../../transaction/types.js";
+import type { ClaimCondition } from "../../../../utils/extensions/drops/types.js";
+import {
+  isSetClaimConditionsSupported,
+  setClaimConditions,
+} from "../../__generated__/IDropERC20/write/setClaimConditions.js";
+import {
+  getClaimConditions,
+  isGetClaimConditionsSupported,
+} from "../read/getClaimConditions.js";
+
+/**
+ * Reset the claim eligibility for all users.
+ * @param options
+ * @returns the prepared transaction
+ * @extension ERC20
+ * @example
+ * ```ts
+ * import { resetClaimEligibility } from "thirdweb/extensions/erc20";
+ * import { sendTransaction } from "thirdweb";
+ *
+ * const transaction = resetClaimEligibility({
+ *  contract,
+ * });
+ *
+ * await sendTransaction({ transaction, account });
+ * ```
+ */
+export function resetClaimEligibility(options: BaseTransactionOptions) {
+  // download existing conditions
+  return setClaimConditions({
+    contract: options.contract,
+    asyncParams: async () => {
+      // get existing conditions
+      const existingConditions = await getClaimConditions(options);
+
+      // then simply return the exact same ones, but with the resetClaimEligibility flag set to true
+      return {
+        // type is necessary because of viem hex shenanigans (strict vs non-strict `0x` prefix string)
+        phases: existingConditions as Array<
+          ClaimCondition & {
+            currency: Hex;
+            merkleRoot: Hex;
+          }
+        >,
+        resetClaimEligibility: true,
+      };
+    },
+  });
+}
+
+/**
+ * Checks if the `resetClaimEligibility` method is supported by the given contract.
+ * @param availableSelectors An array of 4byte function selectors of the contract. You can get this in various ways, such as using "whatsabi" or if you have the ABI of the contract available you can use it to generate the selectors.
+ * @returns A boolean indicating if the `resetClaimEligibility` method is supported.
+ * @extension ERC20
+ * @example
+ * ```ts
+ * import { isResetClaimEligibilitySupported } from "thirdweb/extensions/erc20";
+ *
+ * const supported = isResetClaimEligibilitySupported(["0x..."]);
+ * ```
+ */
+export function isResetClaimEligibilitySupported(availableSelectors: string[]) {
+  return (
+    isGetClaimConditionsSupported(availableSelectors) &&
+    isSetClaimConditionsSupported(availableSelectors)
+  );
+}

package/src/extensions/erc20/drops/write/setClaimConditions.ts

@@ -1,8 +1,14 @@
 import type { BaseTransactionOptions } from "../../../../transaction/types.js";
 import { getMulticallSetClaimConditionTransactions } from "../../../../utils/extensions/drops/get-multicall-set-claim-claim-conditon-transactions.js";
 import type { ClaimConditionsInput } from "../../../../utils/extensions/drops/types.js";
-import { multicall } from "../../../common/__generated__/IMulticall/write/multicall.js";
-import { decimals } from "../../read/decimals.js";
+import { isSetContractURISupported } from "../../../common/__generated__/IContractMetadata/write/setContractURI.js";
+import {
+  isMulticallSupported,
+  multicall,
+} from "../../../common/__generated__/IMulticall/write/multicall.js";
+import { isGetContractMetadataSupported } from "../../../common/read/getContractMetadata.js";
+import { isSetClaimConditionsSupported as isSetClaimConditionsSupportedGenerated } from "../../__generated__/IDropERC20/write/setClaimConditions.js";
+import { decimals, isDecimalsSupported } from "../../read/decimals.js";
 
 /**
  * @extension ERC20
@@ -55,3 +61,28 @@ export function setClaimConditions(
     },
   });
 }
+
+/**
+ * Checks if the `setClaimConditions` method is supported by the given contract.
+ * @param availableSelectors An array of 4byte function selectors of the contract. You can get this in various ways, such as using "whatsabi" or if you have the ABI of the contract available you can use it to generate the selectors.
+ * @returns A boolean indicating if the `setClaimConditions` method is supported.
+ * @extension ERC20
+ * @example
+ * ```ts
+ * import { isSetClaimConditionsSupported } from "thirdweb/extensions/erc20";
+ *
+ * const supported = isSetClaimConditionsSupported(["0x..."]);
+ * ```
+ */
+export function isSetClaimConditionsSupported(availableSelectors: string[]) {
+  return (
+    isMulticallSupported(availableSelectors) &&
+    // needed for setting contract metadata
+    isGetContractMetadataSupported(availableSelectors) &&
+    isSetContractURISupported(availableSelectors) &&
+    // needed for decimals
+    isDecimalsSupported(availableSelectors) &&
+    // needs to actually be able to set the claim Conditions
+    isSetClaimConditionsSupportedGenerated(availableSelectors)
+  );
+}

package/src/extensions/erc20/read/decimals.ts

@@ -2,6 +2,8 @@ import type { BaseTransactionOptions } from "../../../transaction/types.js";
 import { withCache } from "../../../utils/promise/withCache.js";
 import { decimals as generatedDecimals } from "../__generated__/IERC20/read/decimals.js";
 
+export { isDecimalsSupported } from "../__generated__/IERC20/read/decimals.js";
+
 /**
  * Retrieves the number of decimal places for a given ERC20 contract.
  * @param options - The options for the transaction.

package/src/extensions/erc4337/account/isAccountDeployed.ts

@@ -0,0 +1,36 @@
+import type { BaseTransactionOptions } from "../../../transaction/types.js";
+import { isContractDeployed } from "../../../utils/bytecode/is-contract-deployed.js";
+import * as PredictAddress from "../__generated__/IAccountFactory/read/getAddress.js";
+
+export {
+  isGetAddressSupported as isIsAccountDeployedSupported,
+  type GetAddressParams as IsAccountDeployedParams,
+} from "../__generated__/IAccountFactory/read/getAddress.js";
+
+/**
+ * Adds admin permissions for a specified address.
+ * @param options - The options for the addAdmin function.
+ * @returns The transaction object to be sent.
+ * @example
+ * ```ts
+ * import { isAccountDeployed } from 'thirdweb/extensions/erc4337';
+ *
+ * const transaction = addAdmin({
+ * contract,
+ * account,
+ * adminAddress: '0x...'
+ * });
+ *
+ * await isAccountDeployed({ contract, adminSigner });
+ * ```
+ * @extension ERC4337
+ */
+export async function isAccountDeployed(
+  options: BaseTransactionOptions<PredictAddress.GetAddressParams>,
+): Promise<boolean> {
+  const predictedAddress = await PredictAddress.getAddress(options);
+  return isContractDeployed({
+    ...options.contract,
+    address: predictedAddress,
+  });
+}

package/src/extensions/erc4626/__generated__/IERC4626/events/Deposit.ts

@@ -6,16 +6,14 @@ import type { AbiParameterToPrimitiveType } from "abitype";
  */
 export type DepositEventFilters = Partial<{
   caller: AbiParameterToPrimitiveType<{
-    name: "caller";
     type: "address";
+    name: "caller";
     indexed: true;
-    internalType: "address";
   }>;
   owner: AbiParameterToPrimitiveType<{
-    name: "owner";
     type: "address";
+    name: "owner";
     indexed: true;
-    internalType: "address";
   }>;
 }>;
 

package/src/extensions/erc4626/__generated__/IERC4626/events/Withdraw.ts

@@ -6,22 +6,19 @@ import type { AbiParameterToPrimitiveType } from "abitype";
  */
 export type WithdrawEventFilters = Partial<{
   caller: AbiParameterToPrimitiveType<{
-    name: "caller";
     type: "address";
+    name: "caller";
     indexed: true;
-    internalType: "address";
   }>;
   receiver: AbiParameterToPrimitiveType<{
-    name: "receiver";
     type: "address";
+    name: "receiver";
     indexed: true;
-    internalType: "address";
   }>;
   owner: AbiParameterToPrimitiveType<{
-    name: "owner";
     type: "address";
+    name: "owner";
     indexed: true;
-    internalType: "address";
   }>;
 }>;
 

package/src/extensions/erc4626/__generated__/IERC4626/read/asset.ts

@@ -9,9 +9,8 @@ export const FN_SELECTOR = "0x38d52e0f" as const;
 const FN_INPUTS = [] as const;
 const FN_OUTPUTS = [
   {
-    name: "assetTokenAddress",
     type: "address",
-    internalType: "contract ERC20",
+    name: "assetTokenAddress",
   },
 ] as const;
 

package/src/extensions/erc4626/__generated__/IERC4626/read/convertToAssets.ts

@@ -10,26 +10,20 @@ import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
  * Represents the parameters for the "convertToAssets" function.
  */
 export type ConvertToAssetsParams = {
-  shares: AbiParameterToPrimitiveType<{
-    name: "shares";
-    type: "uint256";
-    internalType: "uint256";
-  }>;
+  shares: AbiParameterToPrimitiveType<{ type: "uint256"; name: "shares" }>;
 };
 
 export const FN_SELECTOR = "0x07a2d13a" as const;
 const FN_INPUTS = [
   {
-    name: "shares",
     type: "uint256",
-    internalType: "uint256",
+    name: "shares",
   },
 ] as const;
 const FN_OUTPUTS = [
   {
-    name: "assets",
     type: "uint256",
-    internalType: "uint256",
+    name: "assets",
   },
 ] as const;
 

package/src/extensions/erc4626/__generated__/IERC4626/read/convertToShares.ts

@@ -10,26 +10,20 @@ import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
  * Represents the parameters for the "convertToShares" function.
  */
 export type ConvertToSharesParams = {
-  assets: AbiParameterToPrimitiveType<{
-    name: "assets";
-    type: "uint256";
-    internalType: "uint256";
-  }>;
+  assets: AbiParameterToPrimitiveType<{ type: "uint256"; name: "assets" }>;
 };
 
 export const FN_SELECTOR = "0xc6e6f592" as const;
 const FN_INPUTS = [
   {
-    name: "assets",
     type: "uint256",
-    internalType: "uint256",
+    name: "assets",
   },
 ] as const;
 const FN_OUTPUTS = [
   {
-    name: "shares",
     type: "uint256",
-    internalType: "uint256",
+    name: "shares",
   },
 ] as const;
 

package/src/extensions/erc4626/__generated__/IERC4626/read/maxDeposit.ts

@@ -10,26 +10,20 @@ import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
  * Represents the parameters for the "maxDeposit" function.
  */
 export type MaxDepositParams = {
-  receiver: AbiParameterToPrimitiveType<{
-    name: "receiver";
-    type: "address";
-    internalType: "address";
-  }>;
+  receiver: AbiParameterToPrimitiveType<{ type: "address"; name: "receiver" }>;
 };
 
 export const FN_SELECTOR = "0x402d267d" as const;
 const FN_INPUTS = [
   {
-    name: "receiver",
     type: "address",
-    internalType: "address",
+    name: "receiver",
   },
 ] as const;
 const FN_OUTPUTS = [
   {
-    name: "maxAssets",
     type: "uint256",
-    internalType: "uint256",
+    name: "maxAssets",
   },
 ] as const;
 

package/src/extensions/erc4626/__generated__/IERC4626/read/maxMint.ts

@@ -10,26 +10,20 @@ import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
  * Represents the parameters for the "maxMint" function.
  */
 export type MaxMintParams = {
-  receiver: AbiParameterToPrimitiveType<{
-    name: "receiver";
-    type: "address";
-    internalType: "address";
-  }>;
+  receiver: AbiParameterToPrimitiveType<{ type: "address"; name: "receiver" }>;
 };
 
 export const FN_SELECTOR = "0xc63d75b6" as const;
 const FN_INPUTS = [
   {
-    name: "receiver",
     type: "address",
-    internalType: "address",
+    name: "receiver",
   },
 ] as const;
 const FN_OUTPUTS = [
   {
-    name: "maxShares",
     type: "uint256",
-    internalType: "uint256",
+    name: "maxShares",
   },
 ] as const;