thirdweb 5.50.1 → 5.51.0

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

@@ -1,11 +1,14 @@
 import type { BaseTransactionOptions } from "../../../../transaction/types.js";
 import type { ClaimCondition } from "../../../../utils/extensions/drops/types.js";
-import { claimCondition } from "../../__generated__/DropSinglePhase1155/read/claimCondition.js";
 import {
   type GetActiveClaimConditionIdParams,
   getActiveClaimConditionId,
+  isGetActiveClaimConditionIdSupported,
 } from "../../__generated__/IDrop1155/read/getActiveClaimConditionId.js";
-import { getClaimConditionById } from "../../__generated__/IDrop1155/read/getClaimConditionById.js";
+import {
+  getClaimConditionById,
+  isGetClaimConditionByIdSupported,
+} from "../../__generated__/IDrop1155/read/getClaimConditionById.js";
 
 export type GetActiveClaimConditionParams = GetActiveClaimConditionIdParams;
 /**
@@ -23,42 +26,32 @@ export type GetActiveClaimConditionParams = GetActiveClaimConditionIdParams;
 export async function getActiveClaimCondition(
   options: BaseTransactionOptions<GetActiveClaimConditionParams>,
 ): Promise<ClaimCondition> {
-  const getActiveClaimConditionMultiPhase = async () => {
+  try {
     const conditionId = await getActiveClaimConditionId(options);
     return getClaimConditionById({ ...options, conditionId });
-  };
-  const getActiveClaimConditionSinglePhase = async () => {
-    const [
-      startTimestamp,
-      maxClaimableSupply,
-      supplyClaimed,
-      quantityLimitPerWallet,
-      merkleRoot,
-      pricePerToken,
-      currency,
-      metadata,
-    ] = await claimCondition({ ...options, tokenId: options.tokenId });
-    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");
+}
+
+/**
+ * Checks if the `getActiveClaimCondition` 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 `getActiveClaimCondition` method is supported.
+ * @extension ERC1155
+ * @example
+ * ```ts
+ * import { isGetActiveClaimConditionSupported } from "thirdweb/extensions/erc1155";
+ *
+ * const supported = isGetActiveClaimConditionSupported(["0x..."]);
+ * ```
+ */
+export function isGetActiveClaimConditionSupported(
+  availableSelectors: string[],
+) {
+  // if multi phase is supported, return true
+  return (
+    isGetActiveClaimConditionIdSupported(availableSelectors) &&
+    isGetClaimConditionByIdSupported(availableSelectors)
+  );
 }

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

@@ -0,0 +1,62 @@
+import type { BaseTransactionOptions } from "../../../../transaction/types.js";
+import type { ClaimCondition } from "../../../../utils/extensions/drops/types.js";
+import * as MultiPhase from "../../__generated__/IDrop1155/read/claimCondition.js";
+import * as MultiById from "../../__generated__/IDrop1155/read/getClaimConditionById.js";
+
+export type GetClaimConditionsParams = {
+  tokenId: bigint;
+};
+/**
+ * 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 ERC1155
+ * @example
+ * ```ts
+ * import { getClaimConditions } from "thirdweb/extensions/erc1155";
+ * const conditions = await getClaimConditions({ contract, tokenId: 1n });
+ * ```
+ */
+export async function getClaimConditions(
+  options: BaseTransactionOptions<GetClaimConditionsParams>,
+): 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 ERC1155
+ * @example
+ * ```ts
+ * import { isGetClaimConditionsSupported } from "thirdweb/extensions/erc1155";
+ *
+ * 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/erc1155/drops/write/claimTo.ts

@@ -1,6 +1,8 @@
 import type { BaseTransactionOptions } from "../../../../transaction/types.js";
 import { getClaimParams } from "../../../../utils/extensions/drops/get-claim-params.js";
-import { claim } from "../../__generated__/IDrop1155/write/claim.js";
+import { isGetContractMetadataSupported } from "../../../common/read/getContractMetadata.js";
+import * as GeneratedClaim from "../../__generated__/IDrop1155/write/claim.js";
+import { isGetActiveClaimConditionSupported } from "../read/getActiveClaimCondition.js";
 
 /**
  * @extension ERC1155
@@ -34,7 +36,7 @@ export type ClaimToParams = {
  * @returns The prepared transaction
  */
 export function claimTo(options: BaseTransactionOptions<ClaimToParams>) {
-  return claim({
+  return GeneratedClaim.claim({
     contract: options.contract,
     async asyncParams() {
       const params = await getClaimParams({
@@ -53,3 +55,26 @@ 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 ERC1155
+ * @example
+ * ```ts
+ * import { isClaimToSupported } from "thirdweb/extensions/erc1155";
+ *
+ * const supported = isClaimToSupported(["0x..."]);
+ * ```
+ */
+export function isClaimToSupported(availableSelectors: string[]) {
+  return [
+    // has to support the claim method
+    GeneratedClaim.isClaimSupported(availableSelectors),
+    // has to support the getActiveClaimCondition method
+    isGetActiveClaimConditionSupported(availableSelectors),
+    // requires contractMetadata for claimer proofs
+    isGetContractMetadataSupported(availableSelectors),
+  ].every(Boolean);
+}

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

@@ -0,0 +1,76 @@
+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__/IDrop1155/write/setClaimConditions.js";
+import {
+  type GetClaimConditionsParams,
+  getClaimConditions,
+  isGetClaimConditionsSupported,
+} from "../read/getClaimConditions.js";
+
+export type ResetClaimEligibilityParams = GetClaimConditionsParams;
+
+/**
+ * Reset the claim eligibility for all users.
+ * @param options
+ * @returns the prepared transaction
+ * @extension ERC1155
+ * @example
+ * ```ts
+ * import { resetClaimEligibility } from "thirdweb/extensions/erc1155";
+ * import { sendTransaction } from "thirdweb";
+ *
+ * const transaction = resetClaimEligibility({
+ *  contract,
+ * });
+ *
+ * await sendTransaction({ transaction, account });
+ * ```
+ */
+export function resetClaimEligibility(
+  options: BaseTransactionOptions<ResetClaimEligibilityParams>,
+) {
+  // 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 {
+        tokenId: options.tokenId,
+        // 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 ERC1155
+ * @example
+ * ```ts
+ * import { isResetClaimEligibilitySupported } from "thirdweb/extensions/erc1155";
+ *
+ * const supported = isResetClaimEligibilitySupported(["0x..."]);
+ * ```
+ */
+export function isResetClaimEligibilitySupported(availableSelectors: string[]) {
+  return (
+    isGetClaimConditionsSupported(availableSelectors) &&
+    isSetClaimConditionsSupported(availableSelectors)
+  );
+}

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

@@ -1,7 +1,13 @@
 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 { 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__/IDrop1155/write/setClaimConditions.js";
 
 /**
  * @extension ERC1155
@@ -57,3 +63,26 @@ 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 ERC1155
+ * @example
+ * ```ts
+ * import { isSetClaimConditionsSupported } from "thirdweb/extensions/erc1155";
+ *
+ * const supported = isSetClaimConditionsSupported(["0x..."]);
+ * ```
+ */
+export function isSetClaimConditionsSupported(availableSelectors: string[]) {
+  return (
+    isMulticallSupported(availableSelectors) &&
+    // needed for setting contract metadata
+    isGetContractMetadataSupported(availableSelectors) &&
+    isSetContractURISupported(availableSelectors) &&
+    // needs to actually be able to set the claim Conditions
+    isSetClaimConditionsSupportedGenerated(availableSelectors)
+  );
+}

package/src/extensions/erc1155/drops/write/updateMetadata.ts

@@ -1,8 +1,7 @@
-import { getBaseURICount } from "../../../erc721/__generated__/IBatchMintMetadata/read/getBaseURICount.js";
-import {
-  type UpdateBatchBaseURIParams,
-  updateBatchBaseURI,
-} from "../../__generated__/DropERC1155/write/updateBatchBaseURI.js";
+import * as BaseURICount from "../../../erc721/__generated__/IBatchMintMetadata/read/getBaseURICount.js";
+import * as BatchAtIndex from "../../__generated__/BatchMintMetadata/read/getBatchIdAtIndex.js";
+import * as BatchBaseURI from "../../__generated__/DropERC1155/write/updateBatchBaseURI.js";
+import * as GetNFT from "../../read/getNFT.js";
 
 import type { ThirdwebClient } from "../../../../client/client.js";
 import type { BaseTransactionOptions } from "../../../../transaction/types.js";
@@ -22,9 +21,9 @@ export type UpdateMetadataParams = {
  */
 export async function getUpdateMetadataParams(
   options: BaseTransactionOptions<UpdateMetadataParams>,
-): Promise<UpdateBatchBaseURIParams> {
+): Promise<BatchBaseURI.UpdateBatchBaseURIParams> {
   const { contract, targetTokenId, newMetadata, client } = options;
-  const batchCount = await getBaseURICount(options);
+  const batchCount = await BaseURICount.getBaseURICount(options);
   if (batchCount === 0n) {
     throw new Error(
       "No base URI set. Please set a base URI before updating metadata",
@@ -32,17 +31,15 @@ export async function getUpdateMetadataParams(
   }
 
   // Look for the batchId & determine the start + end tokenId of the batch
-  const [{ getBatchIdAtIndex }, { getNFT }] = await Promise.all([
-    import("../../__generated__/BatchMintMetadata/read/getBatchIdAtIndex.js"),
-    import("../../read/getNFT.js"),
-  ]);
-
   let startTokenId = 0n;
   let endTokenId = 0n;
   let batchIndex = 0n;
   for (let i = 0n; i < batchCount; i += 1n) {
     batchIndex = i;
-    endTokenId = await getBatchIdAtIndex({ contract, index: batchIndex });
+    endTokenId = await BatchAtIndex.getBatchIdAtIndex({
+      contract,
+      index: batchIndex,
+    });
     if (endTokenId > targetTokenId) {
       break;
     }
@@ -55,7 +52,7 @@ export async function getUpdateMetadataParams(
   );
 
   const currentMetadatas = await Promise.all(
-    range.map((id) => getNFT({ contract, tokenId: id })),
+    range.map((id) => GetNFT.getNFT({ contract, tokenId: id })),
   );
 
   // Abort if any of the items failed to load
@@ -125,8 +122,29 @@ export function updateMetadata(
   options: BaseTransactionOptions<UpdateMetadataParams>,
 ) {
   const { contract } = options;
-  return updateBatchBaseURI({
+  return BatchBaseURI.updateBatchBaseURI({
     contract,
     asyncParams: async () => getUpdateMetadataParams(options),
   });
 }
+
+/**
+ * Checks if the `updateMetadata` 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 `updateMetadata` method is supported.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { isUpdateMetadataSupported } from "thirdweb/extensions/erc721";
+ *
+ * const supported = isUpdateMetadataSupported(["0x..."]);
+ * ```
+ */
+export function isUpdateMetadataSupported(availableSelectors: string[]) {
+  return (
+    BaseURICount.isGetBaseURICountSupported(availableSelectors) &&
+    BatchBaseURI.isUpdateBatchBaseURISupported(availableSelectors) &&
+    BatchAtIndex.isGetBatchIdAtIndexSupported(availableSelectors) &&
+    GetNFT.isGetNFTSupported(availableSelectors)
+  );
+}

package/src/extensions/erc1155/read/getNFT.ts

@@ -4,6 +4,8 @@ import { type NFT, parseNFT } from "../../../utils/nft/parseNft.js";
 import { totalSupply } from "../__generated__/IERC1155/read/totalSupply.js";
 import { uri } from "../__generated__/IERC1155/read/uri.js";
 
+export { isUriSupported as isGetNFTSupported } from "../__generated__/IERC1155/read/uri.js";
+
 /**
  * Parameters for getting an NFT.
  * @extension ERC1155

package/src/extensions/erc1155/read/getNFTs.ts

@@ -1,8 +1,11 @@
 import type { BaseTransactionOptions } from "../../../transaction/types.js";
 import { min } from "../../../utils/bigint.js";
 import type { NFT } from "../../../utils/nft/parseNft.js";
-import { nextTokenIdToMint } from "../__generated__/IERC1155Enumerable/read/nextTokenIdToMint.js";
-import { getNFT } from "./getNFT.js";
+import {
+  isNextTokenIdToMintSupported,
+  nextTokenIdToMint,
+} from "../__generated__/IERC1155Enumerable/read/nextTokenIdToMint.js";
+import { getNFT, isGetNFTSupported } from "./getNFT.js";
 
 const DEFAULT_QUERY_ALL_COUNT = 100n;
 
@@ -57,3 +60,22 @@ export async function getNFTs(
 
   return await Promise.all(promises);
 }
+
+/**
+ * Checks if the `getNFTs` 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 `getNFTs` method is supported.
+ * @extension ERC1155
+ * @example
+ * ```ts
+ * import { isGetNFTsSupported } from "thirdweb/extensions/erc721";
+ *
+ * const supported = isGetNFTsSupported(["0x..."]);
+ * ```
+ */
+export function isGetNFTsSupported(availableSelectors: string[]) {
+  return (
+    isGetNFTSupported(availableSelectors) &&
+    isNextTokenIdToMintSupported(availableSelectors)
+  );
+}

package/src/extensions/erc1155/write/lazyMint.ts

@@ -5,8 +5,11 @@ import {
   uploadOrExtractURIs,
 } from "../../../utils/ipfs.js";
 import type { Prettify } from "../../../utils/type-utils.js";
-import { nextTokenIdToMint } from "../__generated__/IERC1155Enumerable/read/nextTokenIdToMint.js";
-import { lazyMint as generatedLazyMint } from "../__generated__/ILazyMint/write/lazyMint.js";
+import {
+  isNextTokenIdToMintSupported,
+  nextTokenIdToMint,
+} from "../__generated__/IERC1155Enumerable/read/nextTokenIdToMint.js";
+import * as LazyMint from "../__generated__/ILazyMint/write/lazyMint.js";
 
 /**
  * Represents the input data for creating an NFT (Non-Fungible Token).
@@ -57,7 +60,7 @@ export type LazyMintParams = {
  * ```
  */
 export function lazyMint(options: BaseTransactionOptions<LazyMintParams>) {
-  return generatedLazyMint({
+  return LazyMint.lazyMint({
     contract: options.contract,
     asyncParams: async () => {
       const startFileNumber = await nextTokenIdToMint({
@@ -81,3 +84,23 @@ export function lazyMint(options: BaseTransactionOptions<LazyMintParams>) {
     },
   });
 }
+
+/**
+ * Checks if the `lazyMint` 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 `lazyMint` method is supported.
+ * @extension ERC1155
+ * @example
+ * ```ts
+ * import { isLazyMintSupported } from "thirdweb/extensions/erc1155";
+ *
+ * const supported = isLazyMintSupported(["0x..."]);
+ * ```
+ */
+export function isLazyMintSupported(availableSelectors: string[]) {
+  return (
+    LazyMint.isLazyMintSupported(availableSelectors) &&
+    // required because we use it in the lazyMint function
+    isNextTokenIdToMintSupported(availableSelectors)
+  );
+}

package/src/extensions/erc1155/write/mintAdditionalSupplyTo.ts

@@ -1,6 +1,6 @@
 import type { BaseTransactionOptions } from "../../../transaction/types.js";
-import { uri } from "../__generated__/IERC1155/read/uri.js";
-import { mintTo as generatedMintTo } from "../__generated__/IMintableERC1155/write/mintTo.js";
+import * as URI from "../__generated__/IERC1155/read/uri.js";
+import * as MintTo from "../__generated__/IMintableERC1155/write/mintTo.js";
 
 /**
  * @extension ERC1155
@@ -35,11 +35,11 @@ export type MintAdditionalSupplyToParams = {
 export function mintAdditionalSupplyTo(
   options: BaseTransactionOptions<MintAdditionalSupplyToParams>,
 ) {
-  return generatedMintTo({
+  return MintTo.mintTo({
     contract: options.contract,
     asyncParams: async () => {
       // we'll be re-using the exising token URI
-      const tokenUri = await uri({
+      const tokenUri = await URI.uri({
         contract: options.contract,
         tokenId: options.tokenId,
       });
@@ -53,3 +53,24 @@ export function mintAdditionalSupplyTo(
     },
   });
 }
+
+/**
+ * Checks if the `mintAdditionalSupplyTo` 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 `mintAdditionalSupplyTo` method is supported.
+ * @extension ERC1155
+ * @example
+ * ```ts
+ * import { isMintAdditionalSupplyToSupported } from "thirdweb/extensions/erc1155";
+ *
+ * const supported = isMintAdditionalSupplyToSupported(["0x..."]);
+ * ```
+ */
+export function isMintAdditionalSupplyToSupported(
+  availableSelectors: string[],
+) {
+  return (
+    MintTo.isMintToSupported(availableSelectors) &&
+    URI.isUriSupported(availableSelectors)
+  );
+}

package/src/extensions/erc1155/write/mintTo.ts

@@ -6,6 +6,8 @@ import type {
 import type { NFTInput } from "../../../utils/nft/parseNft.js";
 import { mintTo as generatedMintTo } from "../__generated__/IMintableERC1155/write/mintTo.js";
 
+export { isMintToSupported } from "../__generated__/IMintableERC1155/write/mintTo.js";
+
 /**
  * @extension ERC1155
  */

package/src/extensions/erc1155/write/updateTokenURI.ts

@@ -6,6 +6,7 @@ import {
   setTokenURI,
 } from "../../erc1155/__generated__/INFTMetadata/write/setTokenURI.js";
 
+export { isSetTokenURISupported as isUpdateTokenURISupported } from "../../erc1155/__generated__/INFTMetadata/write/setTokenURI.js";
 /**
  * @extension ERC1155
  */

package/src/extensions/erc20/__generated__/{DropSinglePhase → IDropERC20}/read/claimCondition.ts

@@ -9,44 +9,12 @@ export const FN_SELECTOR = "0xd637ed59" as const;
 const FN_INPUTS = [] as const;
 const FN_OUTPUTS = [
   {
-    name: "startTimestamp",
     type: "uint256",
-    internalType: "uint256",
+    name: "currentStartId",
   },
   {
-    name: "maxClaimableSupply",
     type: "uint256",
-    internalType: "uint256",
-  },
-  {
-    name: "supplyClaimed",
-    type: "uint256",
-    internalType: "uint256",
-  },
-  {
-    name: "quantityLimitPerWallet",
-    type: "uint256",
-    internalType: "uint256",
-  },
-  {
-    name: "merkleRoot",
-    type: "bytes32",
-    internalType: "bytes32",
-  },
-  {
-    name: "pricePerToken",
-    type: "uint256",
-    internalType: "uint256",
-  },
-  {
-    name: "currency",
-    type: "address",
-    internalType: "address",
-  },
-  {
-    name: "metadata",
-    type: "string",
-    internalType: "string",
+    name: "count",
   },
 ] as const;
 

package/src/extensions/erc20/__generated__/IDropERC20/write/setClaimConditions.ts

@@ -20,10 +20,10 @@ export type SetClaimConditionsParams = WithOverrides<{
       { type: "uint256"; name: "maxClaimableSupply" },
       { type: "uint256"; name: "supplyClaimed" },
       { type: "uint256"; name: "quantityLimitPerWallet" },
-      { type: "uint256"; name: "waitTimeInSecondsBetweenClaims" },
       { type: "bytes32"; name: "merkleRoot" },
       { type: "uint256"; name: "pricePerToken" },
       { type: "address"; name: "currency" },
+      { type: "string"; name: "metadata" },
     ];
   }>;
   resetClaimEligibility: AbiParameterToPrimitiveType<{
@@ -32,7 +32,7 @@ export type SetClaimConditionsParams = WithOverrides<{
   }>;
 }>;
 
-export const FN_SELECTOR = "0xe23b8164" as const;
+export const FN_SELECTOR = "0x74bc7db7" as const;
 const FN_INPUTS = [
   {
     type: "tuple[]",
@@ -54,10 +54,6 @@ const FN_INPUTS = [
         type: "uint256",
         name: "quantityLimitPerWallet",
       },
-      {
-        type: "uint256",
-        name: "waitTimeInSecondsBetweenClaims",
-      },
       {
         type: "bytes32",
         name: "merkleRoot",
@@ -70,6 +66,10 @@ const FN_INPUTS = [
         type: "address",
         name: "currency",
       },
+      {
+        type: "string",
+        name: "metadata",
+      },
     ],
   },
   {