thirdweb 5.53.1-nightly-865c5e3b16af70c3660f30ba8cffc5d6e360a389-20240911000352 → 5.54.0

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;
   }
 >;
 
@@ -56,10 +61,10 @@ export type DeployModularContractOptions = Prettify<
  * On chains where the thirdweb infrastructure contracts are not deployed, this function will deploy them as well.
  * @param options - The deployment options.
  * @returns The deployed contract address.
- * @extension DEPLOY
+ * @modules
  * @example
  * ```ts
- * import { deployModularContract } from "thirdweb/deploys";
+ * import { deployModularContract } from "thirdweb/modules";
  * const contractAddress = await deployModularContract({
  *  chain,
  *  client,
@@ -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

@@ -2,6 +2,7 @@ import { describe, expect, it } 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 { isContractDeployed } from "../../utils/bytecode/is-contract-deployed.js";
 import { ENTRYPOINT_ADDRESS_v0_6 } from "../../wallets/smart/lib/constants.js";
 import { deployPublishedContract } from "./deploy-published.js";
 
@@ -17,24 +18,72 @@ 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("0x8a9e25cbf6daa2b56cc0df4669195b8c8c20cda8");
+      const isDeployed = await isContractDeployed({
+        client: TEST_CLIENT,
+        chain: ANVIL_CHAIN,
+        address,
+      });
+      expect(isDeployed).toBe(true);
+    });
+
     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");
+      const isDeployed = await isContractDeployed({
+        client: TEST_CLIENT,
+        chain: ANVIL_CHAIN,
+        address,
+      });
+      expect(isDeployed).toBe(true);
+    });
+
     // TODO: Replace these tests' live contracts with mocks
     it("should deploy a published contract with no constructor", async () => {
       const address = await deployPublishedContract({
@@ -43,7 +92,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 +104,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);

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

@@ -1,16 +1,22 @@
-import type { AbiConstructor, AbiFunction } from "abitype";
+import type { AbiFunction } from "abitype";
 import type { Chain } from "../../chains/types.js";
 import type { ThirdwebClient } from "../../client/client.js";
-import { getContract } from "../../contract/contract.js";
+import { type ThirdwebContract, getContract } from "../../contract/contract.js";
 import { fetchPublishedContractMetadata } from "../../contract/deployment/publisher.js";
+import { getOrDeployInfraContractFromMetadata } from "../../contract/deployment/utils/bootstrap.js";
+import {} from "../../contract/deployment/utils/infra.js";
 import { zkDeployContract } from "../../contract/deployment/zksync/zkDeployContract.js";
 import { sendAndConfirmTransaction } from "../../transaction/actions/send-and-confirm-transaction.js";
 import { simulateTransaction } from "../../transaction/actions/simulate.js";
 import { prepareContractCall } from "../../transaction/prepare-contract-call.js";
 import { resolveMethod } from "../../transaction/resolve-method.js";
+import { encodeAbiParameters } from "../../utils/abi/encodeAbiParameters.js";
+import { normalizeFunctionParams } from "../../utils/abi/normalizeFunctionParams.js";
+import { getAddress } from "../../utils/address.js";
 import type { CompilerMetadata } from "../../utils/any-evm/deploy-metadata.js";
 import type { FetchDeployMetadataResult } from "../../utils/any-evm/deploy-metadata.js";
 import { isZkSyncChain } from "../../utils/any-evm/zksync/isZkSyncChain.js";
+import type { Hex } from "../../utils/encoding/hex.js";
 import type { Account } from "../../wallets/interfaces/wallet.js";
 
 /**
@@ -21,10 +27,11 @@ export type DeployPublishedContractOptions = {
   chain: Chain;
   account: Account;
   contractId: string;
-  contractParams: unknown[];
+  contractParams?: Record<string, unknown>;
   publisher?: string;
   version?: string;
-  implementationConstructorParams?: unknown[];
+  implementationConstructorParams?: Record<string, unknown>;
+  salt?: string;
 };
 
 /**
@@ -32,6 +39,27 @@ export type DeployPublishedContractOptions = {
  * @param options - the deploy options
  * @returns a promise that resolves to the deployed contract address
  * @example
+ *
+ * ## Deploying a published contract
+ *
+ * ```ts
+ * import { deployPublishedContract } from "thirdweb/deploys";
+ *
+ * const address = await deployedPublishedContract({
+ *   client,
+ *   chain,
+ *   account,
+ *   contractId: "MyPublishedContract",
+ *   contractParams: {
+ *     param1: "value1",
+ *     param2: 123,
+ *   },
+ *   publisher: "0x...", // optional, defaults to the thirdweb deployer
+ * });
+ * ```
+ *
+ *  ## Deploying a published contract deterministically
+ *
  * ```ts
  * import { deployPublishedContract } from "thirdweb/deploys";
  *
@@ -40,8 +68,12 @@ export type DeployPublishedContractOptions = {
  *   chain,
  *   account,
  *   contractId: "MyPublishedContract",
- *   contractParams: [...],
+ *   contractParams: {
+ *     param1: "value1",
+ *     param2: 123,
+ *   },
  *   publisher: "0x...",
+ *   salt: "your-salt", // this will deterministically deploy the contract at the same address on all chains
  * });
  * ```
  * @extension DEPLOY
@@ -58,6 +90,7 @@ export async function deployPublishedContract(
     publisher,
     version,
     implementationConstructorParams,
+    salt,
   } = options;
   const deployMetadata = await fetchPublishedContractMetadata({
     client,
@@ -71,8 +104,9 @@ export async function deployPublishedContract(
     chain,
     deployMetadata,
     client,
-    contractParams,
+    initializeParams: contractParams,
     implementationConstructorParams,
+    salt,
   });
 }
 
@@ -84,8 +118,13 @@ export type DeployContractfromDeployMetadataOptions = {
   chain: Chain;
   account: Account;
   deployMetadata: FetchDeployMetadataResult;
-  contractParams: unknown[];
-  implementationConstructorParams?: unknown[];
+  initializeParams?: Record<string, unknown>;
+  implementationConstructorParams?: Record<string, unknown>;
+  modules?: {
+    deployMetadata: FetchDeployMetadataResult;
+    initializeParams?: Record<string, unknown>;
+  }[];
+  salt?: string;
 };
 
 /**
@@ -93,14 +132,16 @@ export type DeployContractfromDeployMetadataOptions = {
  */
 export async function deployContractfromDeployMetadata(
   options: DeployContractfromDeployMetadataOptions,
-) {
+): Promise<string> {
   const {
     client,
     account,
     chain,
-    contractParams,
+    initializeParams,
     deployMetadata,
     implementationConstructorParams,
+    modules,
+    salt,
   } = options;
   switch (deployMetadata?.deployType) {
     case "standard": {
@@ -109,7 +150,8 @@ export async function deployContractfromDeployMetadata(
         client,
         chain,
         compilerMetadata: deployMetadata,
-        contractParams,
+        contractParams: initializeParams,
+        salt,
       });
     }
     case "autoFactory": {
@@ -126,32 +168,18 @@ export async function deployContractfromDeployMetadata(
           client,
           account,
           contractId: deployMetadata.name,
-          constructorParams: implementationConstructorParams || [],
+          constructorParams: implementationConstructorParams,
           publisher: deployMetadata.publisher,
         });
-      const initializeFunction = deployMetadata.abi.find(
-        (i) =>
-          i.type === "function" &&
-          i.name ===
-            (deployMetadata.factoryDeploymentData
-              ?.implementationInitializerFunction || "initialize"),
-      ) as AbiFunction;
-      if (!initializeFunction) {
-        throw new Error(
-          `Could not find initialize function for ${deployMetadata.name}`,
-        );
-      }
-      const initializeTransaction = prepareContractCall({
-        contract: getContract({
-          client,
-          chain,
-          address: implementationContract.address,
-        }),
-        method: resolveMethod(
-          deployMetadata.factoryDeploymentData
-            ?.implementationInitializerFunction || "initialize",
-        ),
-        params: contractParams,
+
+      const initializeTransaction = await getInitializeTransaction({
+        client,
+        chain,
+        deployMetadata: deployMetadata,
+        implementationContract,
+        initializeParams,
+        account,
+        modules,
       });
 
       return deployViaAutoFactory({
@@ -160,6 +188,7 @@ export async function deployContractfromDeployMetadata(
         account,
         cloneFactoryContract,
         initializeTransaction,
+        salt,
       });
     }
     case "customFactory": {
@@ -181,20 +210,21 @@ export async function deployContractfromDeployMetadata(
         chain,
         address: factoryAddress,
       });
+      const method = await resolveMethod(factoryFunction)(factory);
       const deployTx = prepareContractCall({
         contract: factory,
-        method: resolveMethod(factoryFunction),
-        params: contractParams,
+        method,
+        params: normalizeFunctionParams(method, initializeParams),
       });
       // asumption here is that the factory address returns the deployed proxy address
-      const address = simulateTransaction({
+      const address = await simulateTransaction({
         transaction: deployTx,
       });
       await sendAndConfirmTransaction({
         transaction: deployTx,
         account,
       });
-      return address;
+      return address as string;
     }
     case undefined: {
       // Default to standard deployment if none was specified
@@ -203,7 +233,8 @@ export async function deployContractfromDeployMetadata(
         client,
         chain,
         compilerMetadata: deployMetadata,
-        contractParams,
+        contractParams: initializeParams,
+        salt,
       });
     }
     default:
@@ -217,9 +248,11 @@ async function directDeploy(options: {
   client: ThirdwebClient;
   chain: Chain;
   compilerMetadata: CompilerMetadata;
-  contractParams: unknown[];
-}) {
-  const { account, client, chain, compilerMetadata, contractParams } = options;
+  contractParams?: Record<string, unknown>;
+  salt?: string;
+}): Promise<string> {
+  const { account, client, chain, compilerMetadata, contractParams, salt } =
+    options;
 
   if (isZkSyncChain(chain)) {
     return zkDeployContract({
@@ -229,6 +262,7 @@ async function directDeploy(options: {
       bytecode: compilerMetadata.bytecode,
       abi: compilerMetadata.abi,
       params: contractParams,
+      salt,
     });
   }
 
@@ -240,10 +274,90 @@ async function directDeploy(options: {
     client,
     chain,
     bytecode: compilerMetadata.bytecode,
-    constructorAbi:
-      (compilerMetadata.abi.find(
-        (i) => i.type === "constructor",
-      ) as AbiConstructor) || [],
+    abi: compilerMetadata.abi,
     constructorParams: contractParams,
+    salt,
+  });
+}
+
+async function getInitializeTransaction(options: {
+  client: ThirdwebClient;
+  chain: Chain;
+  account: Account;
+  implementationContract: ThirdwebContract;
+  deployMetadata: FetchDeployMetadataResult;
+  initializeParams?: Record<string, unknown>;
+  modules?: {
+    deployMetadata: FetchDeployMetadataResult;
+    initializeParams?: Record<string, unknown>;
+  }[];
+}) {
+  const {
+    account,
+    client,
+    chain,
+    deployMetadata: metadata,
+    initializeParams = {},
+    implementationContract,
+    modules = [],
+  } = options;
+
+  const initializeFunction = metadata.abi.find(
+    (i) =>
+      i.type === "function" &&
+      i.name ===
+        (metadata.factoryDeploymentData?.implementationInitializerFunction ||
+          "initialize"),
+  ) as AbiFunction;
+  if (!initializeFunction) {
+    throw new Error(`Could not find initialize function for ${metadata.name}`);
+  }
+
+  const hasModules =
+    initializeFunction.inputs.find(
+      (i) => i.name === "modules" || i.name === "_modules",
+    ) &&
+    initializeFunction.inputs.find(
+      (i) => i.name === "moduleInstallData" || i.name === "_moduleInstallData",
+    );
+  if (hasModules) {
+    const moduleAddresses: Hex[] = [];
+    const moduleInstallData: Hex[] = [];
+    for (const module of modules) {
+      // deploy the module if not already deployed
+      const contract = await getOrDeployInfraContractFromMetadata({
+        client,
+        chain,
+        account,
+        contractMetadata: module.deployMetadata,
+      });
+
+      const installFunction = module.deployMetadata.abi.find(
+        (i) => i.type === "function" && i.name === "encodeBytesOnInstall",
+      ) as AbiFunction | undefined;
+
+      moduleAddresses.push(getAddress(contract.address));
+      moduleInstallData.push(
+        installFunction
+          ? encodeAbiParameters(
+              installFunction.inputs,
+              normalizeFunctionParams(installFunction, module.initializeParams),
+            )
+          : "0x",
+      );
+    }
+    initializeParams.modules = moduleAddresses;
+    initializeParams.moduleInstallData = moduleInstallData;
+  }
+
+  const initializeTransaction = prepareContractCall({
+    contract: getContract({
+      client,
+      chain,
+      address: implementationContract.address,
+    }),
+    method: initializeFunction,
+    params: normalizeFunctionParams(initializeFunction, initializeParams),
   });
+  return initializeTransaction;
 }

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

@@ -83,7 +83,6 @@ export async function deploySplitContract(options: DeploySplitContractOptions) {
       client,
       account,
       contractId: "Split",
-      constructorParams: [],
     });
   const initializeTransaction = await getInitializeTransaction({
     client,

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

@@ -97,7 +97,6 @@ export async function deployVoteContract(options: DeployVoteContractOptions) {
       client,
       account,
       contractId: "VoteERC20",
-      constructorParams: [],
     });
   const initializeTransaction = await getInitializeTransaction({
     client,