thirdweb 5.53.0 → 5.54.0-nightly-c3800d6c0765a9a0b69ac0a4a390d20cec932419-20240912000413

package/src/extensions/erc721/lazyMinting/read/getBatchesToReveal.ts

@@ -49,23 +49,23 @@ export async function getBatchesToReveal(
   const countRangeArray = Array.from(Array(Number(count)).keys());
   const uriIndices = await Promise.all(
     countRangeArray.map(async (batchId) => {
-      try {
-        return await GetBatchIdAtIndex.getBatchIdAtIndex({
+      const promiseAll = await Promise.allSettled([
+        GetBatchIdAtIndex.getBatchIdAtIndex({
           contract: options.contract,
           index: BigInt(batchId),
-        });
-      } catch {
-        try {
-          return await BaseURIIndicies.baseURIIndices({
-            contract: options.contract,
-            index: BigInt(batchId),
-          });
-        } catch {
-          throw new Error(
-            "Contract does not have `getBatchIdAtIndex` or `baseURIIndices`, which are required for `getBatchesToReveal`",
-          );
-        }
+        }),
+        BaseURIIndicies.baseURIIndices({
+          contract: options.contract,
+          index: BigInt(batchId),
+        }),
+      ]);
+      const result = promiseAll.find((result) => result.status === "fulfilled");
+      if (!result) {
+        throw new Error(
+          "Contract does not have `getBatchIdAtIndex` or `baseURIIndices`, which are required for `getBatchesToReveal`",
+        );
       }
+      return result.value;
     }),
   );
 
@@ -131,7 +131,7 @@ export async function getBatchesToReveal(
  * const supported = isGetBatchesToRevealSupported(["0x..."]);
  * ```
  */
-export function isGetBaseURICountSupported(availableSelectors: string[]) {
+export function isGetBatchesToRevealSupported(availableSelectors: string[]) {
   return [
     GetBaseURICount.isGetBaseURICountSupported(availableSelectors),
     GetBatchIdAtIndex.isGetBatchIdAtIndexSupported(availableSelectors),

package/src/extensions/erc721/lazyMinting/write/createAndReveal.test.ts

@@ -0,0 +1,84 @@
+import { beforeAll, describe, it } from "vitest";
+import { expect } from "vitest";
+import { ANVIL_CHAIN } from "../../../../../test/src/chains.js";
+import { TEST_CLIENT } from "../../../../../test/src/test-clients.js";
+import { TEST_ACCOUNT_A } 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 { deployERC721Contract } from "../../../prebuilts/deploy-erc721.js";
+import { getNFT } from "../../read/getNFT.js";
+import { createDelayedRevealBatch } from "./createDelayedRevealBatch.js";
+import { reveal } from "./reveal.js";
+
+const placeholderNFT = {
+  name: "Hidden NFT",
+  description: "Will be revealed next week!",
+};
+
+const realNFTs = [
+  {
+    name: "Common NFT #1",
+    description: "Common NFT, one of many.",
+  },
+  {
+    name: "Super Rare NFT #2",
+    description: "You got a Super Rare NFT!",
+  },
+];
+
+describe("createAndReveal", () => {
+  let contract: ThirdwebContract;
+  beforeAll(async () => {
+    const address = await deployERC721Contract({
+      client: TEST_CLIENT,
+      chain: ANVIL_CHAIN,
+      account: TEST_ACCOUNT_A,
+      type: "DropERC721",
+      params: {
+        name: "Test NFT",
+        description: "Test NFT Description",
+        contractURI: "",
+      },
+    });
+    contract = getContract({
+      chain: ANVIL_CHAIN,
+      address,
+      client: TEST_CLIENT,
+    });
+  });
+
+  it("should create and reveal a batch", async () => {
+    const tx = createDelayedRevealBatch({
+      contract,
+      metadata: realNFTs,
+      password: "password",
+      placeholderMetadata: placeholderNFT,
+    });
+    await sendAndConfirmTransaction({
+      transaction: tx,
+      account: TEST_ACCOUNT_A,
+    });
+    const nft = await getNFT({
+      contract,
+      tokenId: 0n,
+    });
+    expect(nft.metadata.name).toBe(placeholderNFT.name);
+    const revealTx = reveal({
+      contract,
+      batchId: 0n,
+      password: "password",
+    });
+    await sendAndConfirmTransaction({
+      transaction: revealTx,
+      account: TEST_ACCOUNT_A,
+    });
+    const nftAfterReveal = await getNFT({
+      contract,
+      tokenId: 0n,
+    });
+    expect(nftAfterReveal.metadata.name).toBe(realNFTs[0]?.name);
+  });
+});

package/src/extensions/erc721/lazyMinting/write/createDelayedRevealBatch.ts

@@ -6,9 +6,18 @@ import { toHex } from "../../../../utils/encoding/hex.js";
 import { keccak256 } from "../../../../utils/hashing/keccak256.js";
 import { getBaseUriFromBatch } from "../../../../utils/ipfs.js";
 import type { NFTInput } from "../../../../utils/nft/parseNft.js";
-import { getBaseURICount } from "../../__generated__/IBatchMintMetadata/read/getBaseURICount.js";
-import { encryptDecrypt } from "../../__generated__/IDelayedReveal/read/encryptDecrypt.js";
-import { lazyMint as generatedLazyMint } from "../../__generated__/ILazyMint/write/lazyMint.js";
+import {
+  getBaseURICount,
+  isGetBaseURICountSupported,
+} from "../../__generated__/IBatchMintMetadata/read/getBaseURICount.js";
+import {
+  encryptDecrypt,
+  isEncryptDecryptSupported,
+} from "../../__generated__/IDelayedReveal/read/encryptDecrypt.js";
+import {
+  lazyMint as generatedLazyMint,
+  isLazyMintSupported,
+} from "../../__generated__/ILazyMint/write/lazyMint.js";
 import { hashDelayedRevealPassword } from "../helpers/hashDelayedRevealBatch.js";
 
 /**
@@ -123,3 +132,24 @@ export function createDelayedRevealBatch(
     },
   });
 }
+
+/**
+ * Checks if the `createDelayedRevealBatch` 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 `createDelayedRevealBatch` method is supported.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { isCreateDelayedRevealBatchSupported } from "thirdweb/extensions/erc721";
+ * const supported = isCreateDelayedRevealBatchSupported(["0x..."]);
+ * ```
+ */
+export function isCreateDelayedRevealBatchSupported(
+  availableSelectors: string[],
+) {
+  return [
+    isGetBaseURICountSupported(availableSelectors),
+    isEncryptDecryptSupported(availableSelectors),
+    isLazyMintSupported(availableSelectors),
+  ].every(Boolean);
+}

package/src/extensions/erc721/lazyMinting/write/reveal.test.ts

@@ -1,4 +1,4 @@
-import { beforeAll, describe, expect, it, vi } from "vitest";
+import { beforeAll, describe, expect, it } from "vitest";
 import { ANVIL_CHAIN } from "../../../../../test/src/chains.js";
 import { TEST_CLIENT } from "../../../../../test/src/test-clients.js";
 import {
@@ -7,14 +7,6 @@ import {
 } from "../../../../contract/contract.js";
 import { reveal } from "./reveal.js";
 
-const mocks = vi.hoisted(() => ({
-  simulateTransaction: vi.fn(),
-}));
-
-vi.mock("../../../../transaction/actions/simulate.js", () => ({
-  simulateTransaction: mocks.simulateTransaction,
-}));
-
 describe("reveal", () => {
   let contract: ThirdwebContract;
   beforeAll(() => {
@@ -34,40 +26,4 @@ describe("reveal", () => {
 
     expect(() => reveal(options)).toThrowError("Password is required");
   });
-
-  it("should successfully prepare a reveal transaction", async () => {
-    const options = {
-      contract,
-      batchId: 1n,
-      password: "securepassword",
-    };
-
-    mocks.simulateTransaction.mockResolvedValue(
-      "ipfs://correctly_decrypted_uri/",
-    );
-
-    const tx = reveal(options);
-    if (typeof tx.data === "function") {
-      await tx.data();
-    }
-
-    expect(mocks.simulateTransaction).toHaveBeenCalled();
-  });
-
-  it("should throw an error if the decrypted URI is invalid", async () => {
-    const options = {
-      contract,
-      batchId: 1n,
-      password: "securepassword",
-    };
-
-    mocks.simulateTransaction.mockResolvedValue("invalid_uri");
-
-    const tx = reveal(options);
-    if (typeof tx.data === "function") {
-      expect(tx.data()).rejects.toThrow("Invalid reveal password");
-    } else {
-      throw new Error("Something went wrong");
-    }
-  });
 });

package/src/extensions/erc721/lazyMinting/write/reveal.ts

@@ -1,8 +1,9 @@
-import { simulateTransaction } from "../../../../transaction/actions/simulate.js";
 import type { BaseTransactionOptions } from "../../../../transaction/types.js";
 import { reveal as generatedReveal } from "../../__generated__/IDelayedReveal/write/reveal.js";
 import { hashDelayedRevealPassword } from "../helpers/hashDelayedRevealBatch.js";
 
+export { isRevealSupported } from "../../__generated__/IDelayedReveal/write/reveal.js";
+
 /**
  * @extension ERC721
  */
@@ -44,28 +45,6 @@ export function reveal(options: BaseTransactionOptions<RevealParams>) {
         options.password,
         options.contract,
       );
-
-      const transaction = generatedReveal({
-        contract: options.contract,
-        asyncParams: async () => ({
-          identifier: options.batchId,
-          key,
-        }),
-      });
-
-      let decryptedUri: string;
-      try {
-        decryptedUri = await simulateTransaction({
-          transaction,
-        });
-      } catch (error) {
-        throw new Error("Reveal failed", { cause: error });
-      }
-
-      if (!decryptedUri.includes("://") || decryptedUri.slice(-1) !== "/") {
-        throw new Error("Invalid reveal password");
-      }
-
       return {
         identifier: options.batchId,
         key,

package/src/extensions/erc721/write/updateTokenURI.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import { ANVIL_CHAIN } from "~test/chains.js";
+import { TEST_CONTRACT_URI } from "~test/ipfs-uris.js";
+import { TEST_CLIENT } from "~test/test-clients.js";
+import { TEST_ACCOUNT_A } from "~test/test-wallets.js";
+import { getContract } from "../../../contract/contract.js";
+import { deployERC721Contract } from "../../../extensions/prebuilts/deploy-erc721.js";
+import { sendAndConfirmTransaction } from "../../../transaction/actions/send-and-confirm-transaction.js";
+import { getNFT } from "../read/getNFT.js";
+import { mintTo } from "./mintTo.js";
+import { updateTokenURI } from "./updateTokenURI.js";
+
+const client = TEST_CLIENT;
+const chain = ANVIL_CHAIN;
+const account = TEST_ACCOUNT_A;
+
+describe.runIf(process.env.TW_SECRET_KEY)(
+  "NFTCollection: Update token uri",
+  () => {
+    it("should update token uri", async () => {
+      const address = await deployERC721Contract({
+        client,
+        chain,
+        account,
+        type: "TokenERC721",
+        params: {
+          name: "NFT collection",
+          contractURI: TEST_CONTRACT_URI,
+        },
+      });
+      const contract = getContract({
+        address,
+        client,
+        chain,
+      });
+      await sendAndConfirmTransaction({
+        transaction: mintTo({
+          contract,
+          nft: { name: "Test1" },
+          to: account.address,
+        }),
+        account,
+      });
+      await sendAndConfirmTransaction({
+        transaction: updateTokenURI({
+          contract,
+          newMetadata: { name: "Test1 Updated" },
+          tokenId: 0n,
+        }),
+        account,
+      });
+      const nft = await getNFT({ contract, tokenId: 0n });
+      expect(nft.metadata.name).toBe("Test1 Updated");
+    });
+  },
+);

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

@@ -50,6 +50,9 @@ export function updateTokenURI(
   });
 }
 
+/**
+ * @internal
+ */
 export async function getUpdateTokenParams(
   options: BaseTransactionOptions<UpdateTokenURIParams>,
 ): Promise<SetTokenURIParams> {

package/src/extensions/marketplace/offers/offers.test.ts

@@ -92,7 +92,6 @@ describe.skip("Marketplace: Offers", () => {
     WETH9 = (await getDeployedInfraContract({
       chain: ANVIL_CHAIN,
       contractId: "WETH9",
-      constructorParams: [],
       client: TEST_CLIENT,
     }))!;
 

package/src/extensions/marketplace/offers/write/makeOffer.ts

@@ -103,7 +103,6 @@ export function makeOffer(options: BaseTransactionOptions<MakeOfferParams>) {
           const WETH9 = await getDeployedInfraContract({
             chain: options.contract.chain,
             client: options.contract.client,
-            constructorParams: [],
             contractId: "WETH9",
           });
 

package/src/extensions/modules/common/getOrDeployModule.ts

@@ -10,17 +10,14 @@ export const getOrDeployModule = async (options: {
   account: Account;
   contractId: string;
   publisher?: string;
-  constructorParams?: unknown[];
 }) => {
-  const { client, chain, account, contractId, publisher, constructorParams } =
-    options;
+  const { client, chain, account, contractId, publisher } = options;
   const contract = await getOrDeployInfraContract({
     client,
     chain,
     account,
     contractId,
     publisher,
-    constructorParams: constructorParams ?? [],
   });
   return contract;
 };
@@ -30,14 +27,12 @@ export const getDeployedModule = (options: {
   chain: Chain;
   contractId: string;
   publisher?: string;
-  constructorParams?: unknown[];
 }) => {
-  const { client, chain, contractId, publisher, constructorParams } = options;
+  const { client, chain, contractId, publisher } = options;
   return getDeployedInfraContract({
     client,
     chain,
     contractId,
     publisher,
-    constructorParams: constructorParams ?? [],
   });
 };

package/src/extensions/modules/common/installPublishedModule.ts

@@ -12,7 +12,7 @@ export type InstallPublishedModuleOptions = {
   moduleName: string;
   publisher?: string;
   version?: string;
-  constructorParams?: unknown[];
+  constructorParams?: Record<string, unknown>;
   moduleData?: `0x${string}`;
 };
 
@@ -53,7 +53,7 @@ export function installPublishedModule(options: InstallPublishedModuleOptions) {
         client: contract.client,
         account,
         contractId: moduleName,
-        constructorParams: constructorParams || [],
+        constructorParams,
         publisher,
       });
       return {

package/src/extensions/modules/common/uninstallPublishedModule.ts

@@ -10,7 +10,6 @@ export type UninstallPublishedModuleOptions = {
   moduleName: string;
   publisherAddress?: string;
   version?: string;
-  constructorParams?: unknown[];
   moduleData?: `0x${string}`;
 };
 
@@ -35,13 +34,7 @@ export type UninstallPublishedModuleOptions = {
 export function uninstallPublishedModule(
   options: UninstallPublishedModuleOptions,
 ) {
-  const {
-    contract,
-    moduleName,
-    publisherAddress,
-    constructorParams,
-    moduleData,
-  } = options;
+  const { contract, moduleName, publisherAddress, moduleData } = options;
 
   return uninstallModule({
     contract,
@@ -50,7 +43,6 @@ export function uninstallPublishedModule(
         chain: contract.chain,
         client: contract.client,
         contractId: moduleName,
-        constructorParams: constructorParams || [],
         publisher: publisherAddress,
       });
       return {

package/src/extensions/prebuilts/deploy-erc1155.ts

@@ -75,7 +75,6 @@ export async function deployERC1155Contract(
       client,
       account,
       contractId: type,
-      constructorParams: [],
     });
   const initializeTransaction = await getInitializeTransaction({
     client,

package/src/extensions/prebuilts/deploy-erc20.ts

@@ -69,7 +69,6 @@ export async function deployERC20Contract(options: DeployERC20ContractOptions) {
       client,
       account,
       contractId: type,
-      constructorParams: [],
       publisher,
     });
   const initializeTransaction = await getInitializeTransaction({

package/src/extensions/prebuilts/deploy-erc721.ts

@@ -80,7 +80,6 @@ export async function deployERC721Contract(
       client,
       account,
       contractId: type,
-      constructorParams: [],
     });
 
   const initializeTransaction = await getInitializeTransaction({

package/src/extensions/prebuilts/deploy-marketplace.ts

@@ -51,14 +51,13 @@ export async function deployMarketplaceContract(
     client,
     account,
     contractId: "WETH9",
-    constructorParams: [],
   });
   const direct = await getOrDeployInfraForPublishedContract({
     chain,
     client,
     account,
     contractId: "DirectListingsLogic",
-    constructorParams: [WETH.address],
+    constructorParams: { _nativeTokenWrapper: WETH.address },
   });
 
   const english = await getOrDeployInfraForPublishedContract({
@@ -66,7 +65,7 @@ export async function deployMarketplaceContract(
     client,
     account,
     contractId: "EnglishAuctionsLogic",
-    constructorParams: [WETH.address],
+    constructorParams: { _nativeTokenWrapper: WETH.address },
   });
 
   const offers = await getOrDeployInfraForPublishedContract({
@@ -74,7 +73,6 @@ export async function deployMarketplaceContract(
     client,
     account,
     contractId: "OffersLogic",
-    constructorParams: [],
   });
 
   const [directFunctions, englishFunctions, offersFunctions] =
@@ -96,8 +94,8 @@ export async function deployMarketplaceContract(
       client,
       account,
       contractId: "MarketplaceV3",
-      constructorParams: [
-        {
+      constructorParams: {
+        _marketplaceV3Params: {
           extensions: [
             {
               metadata: {
@@ -126,8 +124,8 @@ export async function deployMarketplaceContract(
           ],
           royaltyEngineAddress: getRoyaltyEngineV1ByChainId(chain.id),
           nativeTokenWrapper: WETH.address,
-        },
-      ] as MarketplaceConstructorParams,
+        } as MarketplaceConstructorParams[number],
+      },
     });
 
   const initializeTransaction = await getInitializeTransaction({

package/src/extensions/prebuilts/deploy-modular-core.test.ts

@@ -4,6 +4,7 @@ import { TEST_CLIENT } from "../../../test/src/test-clients.js";
 import { TEST_ACCOUNT_A } from "../../../test/src/test-wallets.js";
 import { ZERO_ADDRESS } from "../../constants/addresses.js";
 import { getContract } from "../../contract/contract.js";
+import { fetchPublishedContractMetadata } from "../../contract/deployment/publisher.js";
 import { sendAndConfirmTransaction } from "../../transaction/actions/send-and-confirm-transaction.js";
 import * as ERC20Claimable from "../modules/ClaimableERC20/index.js";
 import { getInstalledModules } from "../modules/__generated__/IModularCore/read/getInstalledModules.js";
@@ -11,7 +12,10 @@ import { installPublishedModule } from "../modules/common/installPublishedModule
 import { uninstallModuleByProxy } from "../modules/common/uninstallModuleByProxy.js";
 import { uninstallPublishedModule } from "../modules/common/uninstallPublishedModule.js";
 import { deployModularContract } from "./deploy-modular.js";
-import { deployPublishedContract } from "./deploy-published.js";
+import {
+  deployContractfromDeployMetadata,
+  deployPublishedContract,
+} from "./deploy-published.js";
 
 describe.runIf(process.env.TW_SECRET_KEY)(
   "deployModularCore",
@@ -27,7 +31,9 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         chain: ANVIL_CHAIN,
         account: TEST_ACCOUNT_A,
         contractId: "DemoCore",
-        contractParams: [TEST_ACCOUNT_A.address, [], ["0x"]],
+        contractParams: {
+          _owner: TEST_ACCOUNT_A.address,
+        },
         publisher: "0xFD78F7E2dF2B8c3D5bff0413c96f3237500898B3",
       });
     }, 120000);
@@ -161,5 +167,60 @@ describe.runIf(process.env.TW_SECRET_KEY)(
       });
       expect(installedModules.length).toBe(1);
     });
+
+    it("should deploy a modular contract with dynamic modules", async () => {
+      const modules = await Promise.all([
+        fetchPublishedContractMetadata({
+          client: TEST_CLIENT,
+          contractId: "ClaimableERC721",
+        }).then((m) => ({
+          deployMetadata: m,
+          initializeParams: {
+            primarySaleRecipient: TEST_ACCOUNT_A.address,
+          },
+        })),
+        fetchPublishedContractMetadata({
+          client: TEST_CLIENT,
+          contractId: "BatchMetadataERC721",
+        }).then((m) => ({
+          deployMetadata: m,
+        })),
+        fetchPublishedContractMetadata({
+          client: TEST_CLIENT,
+          contractId: "RoyaltyERC721",
+        }).then((m) => ({
+          deployMetadata: m,
+          initializeParams: {
+            royaltyRecipient: TEST_ACCOUNT_A.address,
+            royaltyBps: 10000,
+            transferValidator: ZERO_ADDRESS,
+          },
+        })),
+      ]);
+      const address = await deployContractfromDeployMetadata({
+        chain: ANVIL_CHAIN,
+        client: TEST_CLIENT,
+        account: TEST_ACCOUNT_A,
+        deployMetadata: await fetchPublishedContractMetadata({
+          client: TEST_CLIENT,
+          contractId: "ERC721CoreInitializable",
+        }),
+        initializeParams: {
+          owner: TEST_ACCOUNT_A.address,
+          name: "TestModularDynamic",
+          symbol: "TT",
+          contractURI: "",
+        },
+        modules,
+      });
+      const installedModules = await getInstalledModules({
+        contract: getContract({
+          client: TEST_CLIENT,
+          chain: ANVIL_CHAIN,
+          address,
+        }),
+      });
+      expect(installedModules.length).toBe(3);
+    });
   },
 );