thirdweb 5.53.0 → 5.54.0-nightly-c3800d6c0765a9a0b69ac0a4a390d20cec932419-20240912000413

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);

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

@@ -1,15 +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";
 
 /**
@@ -20,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;
 };
 
 /**
@@ -31,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";
  *
@@ -39,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
@@ -57,23 +90,68 @@ export async function deployPublishedContract(
     publisher,
     version,
     implementationConstructorParams,
+    salt,
   } = options;
-  const { compilerMetadata, extendedMetadata } =
-    await fetchPublishedContractMetadata({
-      client,
-      contractId: isZkSyncChain(chain) ? `${contractId}_ZkSync` : contractId,
-      publisher,
-      version,
-    });
+  const deployMetadata = await fetchPublishedContractMetadata({
+    client,
+    contractId: isZkSyncChain(chain) ? `${contractId}_ZkSync` : contractId,
+    publisher,
+    version,
+  });
 
-  switch (extendedMetadata?.deployType) {
+  return deployContractfromDeployMetadata({
+    account,
+    chain,
+    deployMetadata,
+    client,
+    initializeParams: contractParams,
+    implementationConstructorParams,
+    salt,
+  });
+}
+
+/**
+ * @internal
+ */
+export type DeployContractfromDeployMetadataOptions = {
+  client: ThirdwebClient;
+  chain: Chain;
+  account: Account;
+  deployMetadata: FetchDeployMetadataResult;
+  initializeParams?: Record<string, unknown>;
+  implementationConstructorParams?: Record<string, unknown>;
+  modules?: {
+    deployMetadata: FetchDeployMetadataResult;
+    initializeParams?: Record<string, unknown>;
+  }[];
+  salt?: string;
+};
+
+/**
+ * @internal
+ */
+export async function deployContractfromDeployMetadata(
+  options: DeployContractfromDeployMetadataOptions,
+): Promise<string> {
+  const {
+    client,
+    account,
+    chain,
+    initializeParams,
+    deployMetadata,
+    implementationConstructorParams,
+    modules,
+    salt,
+  } = options;
+  switch (deployMetadata?.deployType) {
     case "standard": {
       return directDeploy({
         account,
         client,
         chain,
-        compilerMetadata,
-        contractParams,
+        compilerMetadata: deployMetadata,
+        contractParams: initializeParams,
+        salt,
       });
     }
     case "autoFactory": {
@@ -89,28 +167,19 @@ export async function deployPublishedContract(
           chain,
           client,
           account,
-          contractId,
-          constructorParams: implementationConstructorParams || [],
-          publisher,
+          contractId: deployMetadata.name,
+          constructorParams: implementationConstructorParams,
+          publisher: deployMetadata.publisher,
         });
-      const initializeFunction = compilerMetadata.abi.find(
-        (i) =>
-          i.type === "function" &&
-          i.name ===
-            (extendedMetadata.factoryDeploymentData
-              ?.implementationInitializerFunction || "initialize"),
-      ) as AbiFunction;
-      if (!initializeFunction) {
-        throw new Error(`Could not find initialize function for ${contractId}`);
-      }
-      const initializeTransaction = prepareContractCall({
-        contract: getContract({
-          client,
-          chain,
-          address: implementationContract.address,
-        }),
-        method: initializeFunction,
-        params: contractParams,
+
+      const initializeTransaction = await getInitializeTransaction({
+        client,
+        chain,
+        deployMetadata: deployMetadata,
+        implementationContract,
+        initializeParams,
+        account,
+        modules,
       });
 
       return deployViaAutoFactory({
@@ -119,17 +188,18 @@ export async function deployPublishedContract(
         account,
         cloneFactoryContract,
         initializeTransaction,
+        salt,
       });
     }
     case "customFactory": {
-      if (!extendedMetadata?.factoryDeploymentData?.customFactoryInput) {
+      if (!deployMetadata?.factoryDeploymentData?.customFactoryInput) {
         throw new Error("No custom factory info found");
       }
       const factoryAddress =
-        extendedMetadata?.factoryDeploymentData?.customFactoryInput
+        deployMetadata?.factoryDeploymentData?.customFactoryInput
           ?.customFactoryAddresses?.[chain.id];
       const factoryFunction =
-        extendedMetadata.factoryDeploymentData?.customFactoryInput
+        deployMetadata.factoryDeploymentData?.customFactoryInput
           ?.factoryFunction;
       if (!factoryAddress || !factoryFunction) {
         throw new Error(`No factory address found on chain ${chain.id}`);
@@ -140,20 +210,21 @@ export async function deployPublishedContract(
         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
@@ -161,15 +232,14 @@ export async function deployPublishedContract(
         account,
         client,
         chain,
-        compilerMetadata,
-        contractParams,
+        compilerMetadata: deployMetadata,
+        contractParams: initializeParams,
+        salt,
       });
     }
     default:
       // If a deployType was specified but we don't support it, throw an error
-      throw new Error(
-        `Unsupported deploy type: ${extendedMetadata?.deployType}`,
-      );
+      throw new Error(`Unsupported deploy type: ${deployMetadata?.deployType}`);
   }
 }
 
@@ -178,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({
@@ -190,6 +262,7 @@ async function directDeploy(options: {
       bytecode: compilerMetadata.bytecode,
       abi: compilerMetadata.abi,
       params: contractParams,
+      salt,
     });
   }
 
@@ -201,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,