thirdweb 5.93.14-nightly-169ae22a86787af674cf20ac4e8d1e4a06c84d77-20250404043931 → 5.93.15-nightly-386138e4f06b14aac2fea2ab4a7a0497932f74a7-20250406000354

package/src/extensions/erc1155/customDrop1155.test.ts

@@ -7,13 +7,16 @@ import { TEST_CLIENT } from "../../../test/src/test-clients.js";
 import {
   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";
 import { deployContractfromDeployMetadata } from "../prebuilts/deploy-published.js";
 import { balanceOf } from "./__generated__/IERC1155/read/balanceOf.js";
 import { nextTokenIdToMint } from "./__generated__/IERC1155Enumerable/read/nextTokenIdToMint.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 { getNFT } from "./read/getNFT.js";
 import { lazyMint } from "./write/lazyMint.js";
@@ -92,6 +95,14 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         }),
         account: TEST_ACCOUNT_C,
       });
+
+      const condition = await getClaimConditions({
+        contract,
+        tokenId: 0n,
+      });
+      expect(condition.length).to.eq(1);
+      expect(condition[0]?.maxClaimableSupply).to.eq(10n);
+
       const claimTx = claimTo({
         contract,
         to: TEST_ACCOUNT_C.address,
@@ -166,5 +177,80 @@ describe.runIf(process.env.TW_SECRET_KEY)(
           chainId: ${contract.chain.id}]
         `);
     });
+
+    it("should reset claim eligibility", async () => {
+      await sendAndConfirmTransaction({
+        transaction: setClaimConditions({
+          contract,
+          phases: [
+            {
+              startTime: new Date(0),
+              maxClaimableSupply: 10n,
+              maxClaimablePerWallet: 1n,
+            },
+          ],
+          tokenId: 0n,
+          singlePhaseDrop: true,
+        }),
+        account: TEST_ACCOUNT_C,
+      });
+      // claim one token
+      const claimTx = claimTo({
+        contract,
+        to: TEST_ACCOUNT_D.address,
+        tokenId: 0n,
+        quantity: 1n,
+        singlePhaseDrop: true,
+      });
+      await sendAndConfirmTransaction({
+        transaction: claimTx,
+        account: TEST_ACCOUNT_D,
+      });
+      await expect(
+        balanceOf({ contract, owner: TEST_ACCOUNT_D.address, tokenId: 0n }),
+      ).resolves.toBe(1n);
+
+      // attempt to claim another token (this should fail)
+      await expect(
+        sendAndConfirmTransaction({
+          transaction: claimTo({
+            tokenId: 0n,
+            contract,
+            to: TEST_ACCOUNT_D.address,
+            quantity: 1n,
+          }),
+          account: TEST_ACCOUNT_D,
+        }),
+      ).rejects.toThrowErrorMatchingInlineSnapshot(`
+        [TransactionError: Error - !Qty
+
+        contract: ${contract.address}
+        chainId: ${contract.chain.id}]
+      `);
+
+      // reset claim eligibility
+      await sendAndConfirmTransaction({
+        transaction: resetClaimEligibility({
+          tokenId: 0n,
+          contract,
+          singlePhaseDrop: true,
+        }),
+        account: TEST_ACCOUNT_C,
+      });
+      // attempt to claim another token (this should succeed)
+      await sendAndConfirmTransaction({
+        transaction: claimTo({
+          tokenId: 0n,
+          contract,
+          to: TEST_ACCOUNT_D.address,
+          quantity: 1n,
+        }),
+        account: TEST_ACCOUNT_D,
+      });
+      // check that the account has claimed two tokens
+      await expect(
+        balanceOf({ tokenId: 0n, contract, owner: TEST_ACCOUNT_D.address }),
+      ).resolves.toBe(2n);
+    });
   },
 );

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

@@ -9,6 +9,10 @@ import {
   getClaimConditionById,
   isGetClaimConditionByIdSupported,
 } from "../../__generated__/IDrop1155/read/getClaimConditionById.js";
+import {
+  claimCondition,
+  isClaimConditionSupported,
+} from "../../__generated__/IDropSinglePhase1155/read/claimCondition.js";
 
 export type GetActiveClaimConditionParams = GetActiveClaimConditionIdParams;
 /**
@@ -26,12 +30,43 @@ export type GetActiveClaimConditionParams = GetActiveClaimConditionIdParams;
 export async function getActiveClaimCondition(
   options: BaseTransactionOptions<GetActiveClaimConditionParams>,
 ): Promise<ClaimCondition> {
-  try {
+  const getActiveClaimConditionMultiPhase = async () => {
     const conditionId = await getActiveClaimConditionId(options);
     return getClaimConditionById({ ...options, conditionId });
-  } catch {
-    throw new Error("Claim condition not found");
+  };
+
+  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,
+    };
+  };
+  const results = await Promise.allSettled([
+    getActiveClaimConditionMultiPhase(),
+    getActiveClaimConditionSinglePhase(),
+  ]);
+
+  const condition = results.find((result) => result.status === "fulfilled");
+  if (condition?.status === "fulfilled") {
+    return condition.value;
   }
+  throw new Error("Claim condition not found");
 }
 
 /**
@@ -49,9 +84,10 @@ export async function getActiveClaimCondition(
 export function isGetActiveClaimConditionSupported(
   availableSelectors: string[],
 ) {
-  // if multi phase is supported, return true
   return (
-    isGetActiveClaimConditionIdSupported(availableSelectors) &&
-    isGetClaimConditionByIdSupported(availableSelectors)
+    // check multi-phase
+    (isGetActiveClaimConditionIdSupported(availableSelectors) &&
+      isGetClaimConditionByIdSupported(availableSelectors)) ||
+    isClaimConditionSupported(availableSelectors) // check single phase
   );
 }

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

@@ -2,6 +2,7 @@ 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";
+import * as SinglePhase from "../../__generated__/IDropSinglePhase1155/read/claimCondition.js";
 
 export type GetClaimConditionsParams = {
   tokenId: bigint;
@@ -21,24 +22,53 @@ export type GetClaimConditionsParams = {
 export async function getClaimConditions(
   options: BaseTransactionOptions<GetClaimConditionsParams>,
 ): Promise<ClaimCondition[]> {
-  try {
-    const [startId, count] = await MultiPhase.claimCondition(options);
+  const [multi, single] = await Promise.allSettled([
+    (async () => {
+      const [startId, count] = await MultiPhase.claimCondition(options);
 
-    const conditionPromises: Array<
-      ReturnType<typeof MultiById.getClaimConditionById>
-    > = [];
-    for (let i = startId; i < startId + count; i++) {
-      conditionPromises.push(
-        MultiById.getClaimConditionById({
-          ...options,
-          conditionId: i,
-        }),
-      );
-    }
-    return Promise.all(conditionPromises);
-  } catch {
-    throw new Error("Claim condition not found");
+      const conditionPromises: Array<
+        ReturnType<typeof MultiById.getClaimConditionById>
+      > = [];
+      for (let i = startId; i < startId + count; i++) {
+        conditionPromises.push(
+          MultiById.getClaimConditionById({
+            ...options,
+            conditionId: i,
+          }),
+        );
+      }
+      return Promise.all(conditionPromises);
+    })(),
+    SinglePhase.claimCondition(options).then(
+      ([
+        startTimestamp,
+        maxClaimableSupply,
+        supplyClaimed,
+        quantityLimitPerWallet,
+        merkleRoot,
+        pricePerToken,
+        currency,
+        metadata,
+      ]) => ({
+        startTimestamp,
+        maxClaimableSupply,
+        supplyClaimed,
+        quantityLimitPerWallet,
+        merkleRoot,
+        pricePerToken,
+        currency,
+        metadata,
+      }),
+    ),
+  ]);
+  if (multi.status === "fulfilled") {
+    return multi.value;
   }
+  if (single.status === "fulfilled") {
+    return [single.value];
+  }
+
+  throw new Error("Claim condition not found");
 }
 
 /**
@@ -56,7 +86,8 @@ export async function getClaimConditions(
 export function isGetClaimConditionsSupported(availableSelectors: string[]) {
   // if multi phase is supported, return true
   return (
-    MultiPhase.isClaimConditionSupported(availableSelectors) &&
-    MultiById.isGetClaimConditionByIdSupported(availableSelectors)
+    (MultiPhase.isClaimConditionSupported(availableSelectors) &&
+      MultiById.isGetClaimConditionByIdSupported(availableSelectors)) ||
+    SinglePhase.isClaimConditionSupported(availableSelectors)
   );
 }

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

@@ -3,8 +3,16 @@ import type { BaseTransactionOptions } from "../../../../transaction/types.js";
 import type { ClaimCondition } from "../../../../utils/extensions/drops/types.js";
 import {
   isSetClaimConditionsSupported,
-  setClaimConditions,
+  setClaimConditions as setClaimConditionsMultiPhase,
 } from "../../__generated__/IDrop1155/write/setClaimConditions.js";
+import {
+  claimCondition as claimConditionSinglePhase,
+  isClaimConditionSupported,
+} from "../../__generated__/IDropSinglePhase1155/read/claimCondition.js";
+import {
+  isSetClaimConditionsSupported as isSetClaimConditionsSupportedGeneratedSinglePhase,
+  setClaimConditions as setClaimConditionsSinglePhase,
+} from "../../__generated__/IDropSinglePhase1155/write/setClaimConditions.js";
 import {
   type GetClaimConditionsParams,
   getClaimConditions,
@@ -31,10 +39,49 @@ export type ResetClaimEligibilityParams = GetClaimConditionsParams;
  * ```
  */
 export function resetClaimEligibility(
-  options: BaseTransactionOptions<ResetClaimEligibilityParams>,
+  options: BaseTransactionOptions<ResetClaimEligibilityParams> & {
+    singlePhaseDrop?: boolean;
+  },
 ) {
+  if (options.singlePhaseDrop) {
+    return setClaimConditionsSinglePhase({
+      contract: options.contract,
+      asyncParams: async () => {
+        // get existing condition
+        const existingCondition = await claimConditionSinglePhase(options).then(
+          ([
+            startTimestamp,
+            maxClaimableSupply,
+            supplyClaimed,
+            quantityLimitPerWallet,
+            merkleRoot,
+            pricePerToken,
+            currency,
+            metadata,
+          ]) => ({
+            startTimestamp,
+            maxClaimableSupply,
+            supplyClaimed,
+            quantityLimitPerWallet,
+            merkleRoot,
+            pricePerToken,
+            currency,
+            metadata,
+          }),
+        );
+
+        // 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)
+          phase: existingCondition,
+          resetClaimEligibility: true,
+        };
+      },
+    });
+  }
   // download existing conditions
-  return setClaimConditions({
+  return setClaimConditionsMultiPhase({
     contract: options.contract,
     asyncParams: async () => {
       // get existing conditions
@@ -70,7 +117,9 @@ export function resetClaimEligibility(
  */
 export function isResetClaimEligibilitySupported(availableSelectors: string[]) {
   return (
-    isGetClaimConditionsSupported(availableSelectors) &&
-    isSetClaimConditionsSupported(availableSelectors)
+    (isGetClaimConditionsSupported(availableSelectors) &&
+      isSetClaimConditionsSupported(availableSelectors)) ||
+    isClaimConditionSupported(availableSelectors) ||
+    isSetClaimConditionsSupportedGeneratedSinglePhase(availableSelectors)
   );
 }

package/src/utils/extensions/drops/get-claim-params.ts

@@ -50,15 +50,6 @@ export async function getClaimParams(options: GetClaimParamsOptions) {
   const cc: ClaimCondition = await (async () => {
     if (options.type === "erc1155") {
       // lazy-load the getActiveClaimCondition function
-      if (options.singlePhaseDrop) {
-        const { claimCondition } = await import(
-          "../../../extensions/erc1155/__generated__/IDropSinglePhase1155/read/claimCondition.js"
-        );
-        return await claimCondition({
-          contract: options.contract,
-          tokenId: options.tokenId,
-        });
-      }
       const { getActiveClaimCondition } = await import(
         "../../../extensions/erc1155/drops/read/getActiveClaimCondition.js"
       );

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.93.14-nightly-169ae22a86787af674cf20ac4e8d1e4a06c84d77-20250404043931";
+export const version = "5.93.15-nightly-386138e4f06b14aac2fea2ab4a7a0497932f74a7-20250406000354";