thirdweb 5.53.1-nightly-865c5e3b16af70c3660f30ba8cffc5d6e360a389-20240911000352 → 5.54.0-nightly-c3800d6c0765a9a0b69ac0a4a390d20cec932419-20240912000413

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);
+    });
   },
 );

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

@@ -6,11 +6,15 @@ import { getOrDeployInfraForPublishedContract } from "../../contract/deployment/
 import { upload } from "../../storage/upload.js";
 import type { FileOrBufferOrString } from "../../storage/upload/types.js";
 import { type Address, getAddress } from "../../utils/address.js";
+import type {} from "../../utils/any-evm/deploy-metadata.js";
 import type { Hex } from "../../utils/encoding/hex.js";
 import type { Prettify } from "../../utils/type-utils.js";
 import type { ClientAndChainAndAccount } from "../../utils/types.js";
 import type { Account } from "../../wallets/interfaces/wallet.js";
-import { initialize } from "../modules/__generated__/ERC20Core/write/initialize.js";
+import {
+  type InitializeParams,
+  initialize,
+} from "../modules/__generated__/ERC20Core/write/initialize.js";
 
 export type CoreType = "ERC20" | "ERC721" | "ERC1155";
 
@@ -48,6 +52,7 @@ export type DeployModularContractOptions = Prettify<
     params: ModularContractParams;
     modules?: ModuleInstaller[];
     publisher?: string;
+    salt?: string;
   }
 >;
 
@@ -93,6 +98,7 @@ export async function deployModularContract(
     core,
     params: coreParams,
     modules = [],
+    salt,
   } = options;
   const contractId = getContractId(core);
   const { cloneFactoryContract, implementationContract } =
@@ -101,35 +107,59 @@ export async function deployModularContract(
       client,
       account,
       contractId,
-      constructorParams: [],
       publisher,
     });
-  const initializeTransaction = await getInitializeTransaction({
-    client,
-    chain,
-    account,
-    implementationContract,
-    contractId,
-    coreParams,
-    accountAddress: getAddress(account.address),
-    modules,
-  });
+  const contractURI =
+    coreParams.contractURI ||
+    (await upload({
+      client,
+      files: [
+        {
+          name: coreParams.name,
+          description: coreParams.description,
+          symbol: coreParams.symbol,
+          image: coreParams.image,
+          external_link: coreParams.external_link,
+          social_urls: coreParams.social_urls,
+        },
+      ],
+    })) ||
+    "";
+  const initializeTransaction =
+    await getInitializeTransactionForModularContract({
+      client,
+      chain,
+      account,
+      implementationContract,
+      contractId,
+      initializeParams: {
+        name: coreParams.name || "",
+        symbol: coreParams.symbol || "",
+        contractURI,
+        owner: coreParams.defaultAdmin
+          ? getAddress(coreParams.defaultAdmin)
+          : account.address,
+      },
+      accountAddress: getAddress(account.address),
+      modules,
+    });
   return deployViaAutoFactory({
     client,
     chain,
     account,
     cloneFactoryContract,
     initializeTransaction,
+    salt,
   });
 }
 
-async function getInitializeTransaction(options: {
+async function getInitializeTransactionForModularContract(options: {
   client: ThirdwebClient;
   chain: Chain;
   account: Account;
   implementationContract: ThirdwebContract;
   contractId: string;
-  coreParams: ModularContractParams;
+  initializeParams: Omit<InitializeParams, "modules" | "moduleInstallData">;
   accountAddress: Address;
   modules: ModuleInstaller[];
 }) {
@@ -137,28 +167,12 @@ async function getInitializeTransaction(options: {
     client,
     implementationContract,
     contractId,
-    coreParams,
+    initializeParams,
     modules,
-    accountAddress,
     chain,
     account,
   } = options;
-  const contractURI =
-    coreParams.contractURI ||
-    (await upload({
-      client,
-      files: [
-        {
-          name: coreParams.name,
-          description: coreParams.description,
-          symbol: coreParams.symbol,
-          image: coreParams.image,
-          external_link: coreParams.external_link,
-          social_urls: coreParams.social_urls,
-        },
-      ],
-    })) ||
-    "";
+
   switch (contractId) {
     case "ERC20CoreInitializable":
     case "ERC721CoreInitializable":
@@ -179,12 +193,10 @@ async function getInitializeTransaction(options: {
       // all 3 cores have the same initializer
       return initialize({
         contract: implementationContract,
-        owner: coreParams.defaultAdmin
-          ? getAddress(coreParams.defaultAdmin)
-          : accountAddress,
-        name: coreParams.name || "",
-        symbol: coreParams.symbol || "",
-        contractURI,
+        owner: initializeParams.owner,
+        name: initializeParams.name,
+        symbol: initializeParams.symbol,
+        contractURI: initializeParams.contractURI,
         modules: moduleAddresses,
         moduleInstallData,
       });

package/src/extensions/prebuilts/deploy-published.test.ts

@@ -17,24 +17,60 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         chain: ANVIL_CHAIN,
         account: TEST_ACCOUNT_A,
         contractId: "AccountFactory",
-        contractParams: [TEST_ACCOUNT_A.address, ENTRYPOINT_ADDRESS_v0_6],
+        contractParams: {
+          defaultAdmin: TEST_ACCOUNT_A.address,
+          entrypoint: ENTRYPOINT_ADDRESS_v0_6,
+        },
       });
       expect(address).toBeDefined();
       expect(address.length).toBe(42);
     });
 
+    it("should deploy a published direct deploy contract deterministically", async () => {
+      const address = await deployPublishedContract({
+        client: TEST_CLIENT,
+        chain: ANVIL_CHAIN,
+        account: TEST_ACCOUNT_A,
+        contractId: "AccountFactory",
+        contractParams: {
+          defaultAdmin: TEST_ACCOUNT_A.address,
+          entrypoint: ENTRYPOINT_ADDRESS_v0_6,
+        },
+        salt: "test",
+      });
+      expect(address).toBe("0x75fc461544723c0dac7b46256027878e82ddc2cb");
+    });
+
     it("should deploy a published autofactory contract", async () => {
       const address = await deployPublishedContract({
         client: TEST_CLIENT,
         chain: ANVIL_CHAIN,
         account: TEST_ACCOUNT_A,
         contractId: "Airdrop",
-        contractParams: [TEST_ACCOUNT_A.address, ""],
+        contractParams: {
+          defaultAdmin: TEST_ACCOUNT_A.address,
+          contractURI: "",
+        },
       });
       expect(address).toBeDefined();
       expect(address.length).toBe(42);
     });
 
+    it("should deploy a published autofactory contract deterministically", async () => {
+      const address = await deployPublishedContract({
+        client: TEST_CLIENT,
+        chain: ANVIL_CHAIN,
+        account: TEST_ACCOUNT_A,
+        contractId: "Airdrop",
+        contractParams: {
+          defaultAdmin: TEST_ACCOUNT_A.address,
+          contractURI: "",
+        },
+        salt: "test",
+      });
+      expect(address).toBe("0x777151741260F8d4098dD492e45FdB536F442672");
+    });
+
     // TODO: Replace these tests' live contracts with mocks
     it("should deploy a published contract with no constructor", async () => {
       const address = await deployPublishedContract({
@@ -43,7 +79,6 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         account: TEST_ACCOUNT_A,
         contractId: "Counter",
         publisher: "0x4a706de5CE9bfe2f9C37BA945805e396d1810824",
-        contractParams: [],
       });
       expect(address).toBeDefined();
       expect(address.length).toBe(42);
@@ -56,7 +91,29 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         account: TEST_ACCOUNT_A,
         contractId: "MyToken",
         publisher: "0xc77e556cd96235A7B72d46EAAf13405d698CB2C0",
-        contractParams: [],
+      });
+      expect(address).toBeDefined();
+      expect(address.length).toBe(42);
+    });
+
+    it("should deploy a published contract with no fuzzy params", async () => {
+      const address = await deployPublishedContract({
+        client: TEST_CLIENT,
+        chain: ANVIL_CHAIN,
+        account: TEST_ACCOUNT_A,
+        contractId: "DropERC1155",
+        contractParams: {
+          defaultAdmin: TEST_ACCOUNT_A.address, // defaultAdmin
+          name: "test", // name
+          symbol: "test", // symbol
+          contractURI: "", // contractURI
+          trustedForwarders: [], // trustedForwarders
+          saleRecipient: TEST_ACCOUNT_A.address, // saleRecipient
+          royaltyRecipient: TEST_ACCOUNT_A.address, // royaltyRecipient
+          royaltyBps: 0n, // royaltyBps
+          platformFeeBps: 0n, // platformFeeBps
+          platformFeeRecipient: TEST_ACCOUNT_A.address, // platformFeeRecipient
+        },
       });
       expect(address).toBeDefined();
       expect(address.length).toBe(42);