thirdweb 5.53.1-nightly-865c5e3b16af70c3660f30ba8cffc5d6e360a389-20240911000352 → 5.54.0

package/src/contract/deployment/deploy-deterministic.ts

@@ -1,5 +1,10 @@
+import type { Abi } from "abitype";
 import { prepareTransaction } from "../../transaction/prepare-transaction.js";
-import { computeDeploymentInfoFromContractId } from "../../utils/any-evm/compute-published-contract-deploy-info.js";
+import {
+  computeDeploymentInfoFromBytecode,
+  computeDeploymentInfoFromContractId,
+} from "../../utils/any-evm/compute-published-contract-deploy-info.js";
+import type { Hex } from "../../utils/encoding/hex.js";
 import type { Prettify } from "../../utils/type-utils.js";
 import type { ClientAndChain } from "../../utils/types.js";
 import { computeCreate2FactoryAddress } from "./utils/create-2-factory.js";
@@ -10,7 +15,7 @@ import { computeCreate2FactoryAddress } from "./utils/create-2-factory.js";
 export type DeployDetemisiticParams = Prettify<
   ClientAndChain & {
     contractId: string;
-    constructorParams: unknown[];
+    constructorParams?: Record<string, unknown>;
     publisher?: string;
     version?: string;
     salt?: string;
@@ -56,3 +61,31 @@ export function prepareDeterministicDeployTransaction(
     },
   });
 }
+
+/**
+ * @internal
+ */
+export function prepareDeterministicDeployTransactionFromBytecode(
+  options: ClientAndChain & {
+    abi: Abi;
+    bytecode: Hex;
+    constructorParams?: Record<string, unknown>;
+    salt?: string;
+  },
+) {
+  const { client, chain } = options;
+  return prepareTransaction({
+    client,
+    chain,
+    to: () =>
+      computeCreate2FactoryAddress({
+        client,
+        chain,
+      }),
+    data: async () => {
+      const infraContractInfo =
+        await computeDeploymentInfoFromBytecode(options);
+      return infraContractInfo.initBytecodeWithsalt;
+    },
+  });
+}

package/src/contract/deployment/deploy-via-autofactory.test.ts

@@ -39,7 +39,6 @@ describe.runIf(process.env.TW_SECRET_KEY)("deployFromMetadata", () => {
         chain: ANVIL_CHAIN,
         client: TEST_CLIENT,
         contractId: "DropERC721",
-        constructorParams: [],
       });
       if (!implementationContract) {
         throw new Error("Clone factory not found");
@@ -87,7 +86,6 @@ describe.runIf(process.env.TW_SECRET_KEY)("deployFromMetadata", () => {
         chain: ANVIL_CHAIN,
         client: TEST_CLIENT,
         contractId: "DropERC721",
-        constructorParams: [],
       });
       if (!implementationContract) {
         throw new Error("Clone factory not found");

package/src/contract/deployment/deploy-via-autofactory.ts

@@ -70,6 +70,7 @@ export async function deployViaAutoFactory(
     account,
     cloneFactoryContract,
     initializeTransaction,
+    salt,
   } = options;
 
   if (isZkSyncChain(chain)) {
@@ -79,6 +80,7 @@ export async function deployViaAutoFactory(
       account,
       cloneFactoryContract,
       initializeTransaction,
+      salt,
     });
   }
 
@@ -87,6 +89,7 @@ export async function deployViaAutoFactory(
     client,
     cloneFactoryContract,
     initializeTransaction,
+    salt,
   });
   const receipt = await sendAndConfirmTransaction({
     transaction: tx,

package/src/contract/deployment/deploy-with-abi.ts

@@ -1,11 +1,10 @@
-import type {
-  AbiConstructor,
-  AbiParameter,
-  AbiParametersToPrimitiveTypes,
-} from "abitype";
+import type { Abi, AbiConstructor } from "abitype";
 import { sendAndConfirmTransaction } from "../../transaction/actions/send-and-confirm-transaction.js";
 import { prepareTransaction } from "../../transaction/prepare-transaction.js";
 import { encodeAbiParameters } from "../../utils/abi/encodeAbiParameters.js";
+import { normalizeFunctionParams } from "../../utils/abi/normalizeFunctionParams.js";
+import { computeDeploymentAddress } from "../../utils/any-evm/compute-deployment-address.js";
+import { computeDeploymentInfoFromBytecode } from "../../utils/any-evm/compute-published-contract-deploy-info.js";
 import { ensureBytecodePrefix } from "../../utils/bytecode/prefix.js";
 import { concatHex } from "../../utils/encoding/helpers/concat-hex.js";
 import { type Hex, isHex } from "../../utils/encoding/hex.js";
@@ -16,16 +15,11 @@ import type { Account } from "../../wallets/interfaces/wallet.js";
 /**
  * @extension DEPLOY
  */
-export type PrepareDirectDeployTransactionOptions<
-  TConstructor extends AbiConstructor,
-  TParams = AbiParametersToPrimitiveTypes<TConstructor["inputs"]>,
-> = Prettify<
+export type PrepareDirectDeployTransactionOptions = Prettify<
   ClientAndChain & {
-    constructorAbi: TConstructor;
+    abi: Abi;
     bytecode: Hex;
-    constructorParams: TParams extends readonly AbiParameter[]
-      ? TParams
-      : readonly unknown[];
+    constructorParams?: Record<string, unknown>;
   }
 >;
 
@@ -51,13 +45,16 @@ export type PrepareDirectDeployTransactionOptions<
  * ```
  * @extension DEPLOY
  */
-export function prepareDirectDeployTransaction<
-  const TConstructor extends AbiConstructor,
->(options: PrepareDirectDeployTransactionOptions<TConstructor>) {
+export function prepareDirectDeployTransaction(
+  options: PrepareDirectDeployTransactionOptions,
+) {
   const bytecode = ensureBytecodePrefix(options.bytecode);
   if (!isHex(bytecode)) {
     throw new Error(`Contract bytecode is invalid.\n\n${bytecode}`);
   }
+  const constructorAbi = options.abi.find(
+    (abi) => abi.type === "constructor",
+  ) as AbiConstructor | undefined;
   // prepare the tx
   return prepareTransaction({
     chain: options.chain,
@@ -66,8 +63,8 @@ export function prepareDirectDeployTransaction<
     data: concatHex([
       bytecode,
       encodeAbiParameters(
-        options.constructorAbi.inputs ?? [], // Leave an empty array if there's no constructor
-        options.constructorParams,
+        constructorAbi?.inputs || [], // Leave an empty array if there's no constructor
+        normalizeFunctionParams(constructorAbi, options.constructorParams),
       ),
     ]),
   });
@@ -78,6 +75,9 @@ export function prepareDirectDeployTransaction<
  * @param options - the deploy options
  * @returns - a promise that resolves to the deployed contract address
  * @example
+ *
+ * ## Deploying a regular contract from ABI and bytecode
+ *
  * ```ts
  * import { deployContract } from "thirdweb/deployContract";
  *
@@ -85,20 +85,60 @@ export function prepareDirectDeployTransaction<
  *  client,
  *  chain,
  *  bytecode: "0x...",
- *  constructorAbi: {
- *    inputs: [{ type: "uint256", name: "value" }],
- *    type: "constructor",
+ *  abi: contractAbi,
+ *  constructorParams: {
+ *    param1: "value1",
+ *    param2: 123,
  *  },
- *  constructorParams: [123],
+ *  salt, // optional: salt enables deterministic deploys
+ * });
+ * ```
+ *
+ * ## Deploying a contract deterministically
+ *
+ * ```ts
+ * import { deployContract } from "thirdweb/deployContract";
+ *
+ * const address = await deployContract({
+ *  client,
+ *  chain,
+ *  bytecode: "0x...",
+ *  abi: contractAbi,
+ *  constructorParams: {
+ *    param1: "value1",
+ *    param2: 123,
+ *  },
+ *  salt, // passing a salt will enable deterministic deploys
  * });
  * ```
  * @extension DEPLOY
  */
-export async function deployContract<const TConstructor extends AbiConstructor>(
-  options: PrepareDirectDeployTransactionOptions<TConstructor> & {
+export async function deployContract(
+  options: PrepareDirectDeployTransactionOptions & {
     account: Account;
+    salt?: string;
   },
 ) {
+  if (options.salt !== undefined) {
+    // Deploy with CREATE2 if salt is provided
+    const info = await computeDeploymentInfoFromBytecode(options);
+    await sendAndConfirmTransaction({
+      account: options.account,
+      transaction: prepareTransaction({
+        chain: options.chain,
+        client: options.client,
+        to: info.create2FactoryAddress,
+        data: info.initBytecodeWithsalt,
+      }),
+    });
+    return computeDeploymentAddress({
+      bytecode: options.bytecode,
+      encodedArgs: info.encodedArgs,
+      create2FactoryAddress: info.create2FactoryAddress,
+      salt: options.salt,
+    });
+  }
+
   const deployTx = prepareDirectDeployTransaction(options);
   const receipt = await sendAndConfirmTransaction({
     account: options.account,

package/src/contract/deployment/utils/bootstrap.test.ts

@@ -27,7 +27,6 @@ describe.runIf(process.env.TW_SECRET_KEY)("bootstrap", () => {
       chain: ANVIL_CHAIN,
       client: TEST_CLIENT,
       contractId: "Forwarder",
-      constructorParams: [],
     });
     expect(forwarder).not.toBeNull();
     if (!forwarder) {
@@ -37,7 +36,9 @@ describe.runIf(process.env.TW_SECRET_KEY)("bootstrap", () => {
       chain: ANVIL_CHAIN,
       client: TEST_CLIENT,
       contractId: "TWCloneFactory",
-      constructorParams: [forwarder.address],
+      constructorParams: {
+        _trustedForwarder: forwarder.address,
+      },
     });
     expect(cloneFactory).not.toBeNull();
   });

package/src/contract/deployment/utils/bootstrap.ts

@@ -1,4 +1,5 @@
 import { sendAndConfirmTransaction } from "../../../transaction/actions/send-and-confirm-transaction.js";
+import type { FetchDeployMetadataResult } from "../../../utils/any-evm/deploy-metadata.js";
 import { isZkSyncChain } from "../../../utils/any-evm/zksync/isZkSyncChain.js";
 import type { ClientAndChainAndAccount } from "../../../utils/types.js";
 import { type ThirdwebContract, getContract } from "../../contract.js";
@@ -13,7 +14,8 @@ import {
 import {
   type InfraContractId,
   getDeployedInfraContract,
-  prepareInfraContractDeployTransaction,
+  getDeployedInfraContractFromMetadata,
+  prepareInfraContractDeployTransactionFromMetadata,
 } from "./infra.js";
 
 /**
@@ -22,7 +24,7 @@ import {
 export async function getOrDeployInfraForPublishedContract(
   args: ClientAndChainAndAccount & {
     contractId: string;
-    constructorParams: unknown[];
+    constructorParams?: Record<string, unknown>;
     publisher?: string;
     version?: string;
   },
@@ -124,14 +126,13 @@ export async function deployCloneFactory(options: ClientAndChainAndAccount) {
   const forwarder = await getOrDeployInfraContract({
     ...options,
     contractId: "Forwarder",
-    constructorParams: [],
   });
 
   // clone factory
   return getOrDeployInfraContract({
     ...options,
     contractId: "TWCloneFactory",
-    constructorParams: [forwarder.address],
+    constructorParams: { _trustedForwarder: forwarder.address },
   });
 }
 
@@ -142,7 +143,7 @@ export async function deployCloneFactory(options: ClientAndChainAndAccount) {
 export async function deployImplementation(
   options: ClientAndChainAndAccount & {
     contractId: string;
-    constructorParams?: unknown[];
+    constructorParams?: Record<string, unknown>;
     publisher?: string;
     version?: string;
   },
@@ -150,7 +151,7 @@ export async function deployImplementation(
   return getOrDeployInfraContract({
     ...options,
     contractId: options.contractId,
-    constructorParams: options.constructorParams || [],
+    constructorParams: options.constructorParams,
     publisher: options.publisher,
     version: options.version,
   });
@@ -163,23 +164,46 @@ export async function deployImplementation(
 export async function getOrDeployInfraContract(
   options: ClientAndChainAndAccount & {
     contractId: InfraContractId;
-    constructorParams: unknown[];
+    constructorParams?: Record<string, unknown>;
     publisher?: string;
     version?: string;
   },
 ) {
-  const infraContract = await getDeployedInfraContract(options);
+  const contractMetadata = await fetchPublishedContractMetadata({
+    client: options.client,
+    contractId: options.contractId,
+    publisher: options.publisher,
+    version: options.version,
+  });
+  return getOrDeployInfraContractFromMetadata({
+    account: options.account,
+    chain: options.chain,
+    client: options.client,
+    constructorParams: options.constructorParams,
+    contractMetadata,
+  });
+}
+
+export async function getOrDeployInfraContractFromMetadata(
+  options: ClientAndChainAndAccount & {
+    contractMetadata: FetchDeployMetadataResult;
+    constructorParams?: Record<string, unknown>;
+  },
+) {
+  const infraContract = await getDeployedInfraContractFromMetadata(options);
   if (infraContract) {
     return infraContract;
   }
-  const transaction = prepareInfraContractDeployTransaction(options);
+  const transaction =
+    prepareInfraContractDeployTransactionFromMetadata(options);
   await sendAndConfirmTransaction({
     transaction,
     account: options.account,
   });
-  const deployedInfraContract = await getDeployedInfraContract(options);
+  const deployedInfraContract =
+    await getDeployedInfraContractFromMetadata(options);
   if (!deployedInfraContract) {
-    throw new Error(`Failed to deploy ${options.contractId}`);
+    throw new Error(`Failed to deploy ${options.contractMetadata.name}`);
   }
   return deployedInfraContract;
 }

package/src/contract/deployment/utils/clone-factory.ts

@@ -9,7 +9,6 @@ export async function getDeployedCloneFactoryContract(args: ClientAndChain) {
   const forwarder = await getDeployedInfraContract({
     ...args,
     contractId: "Forwarder",
-    constructorParams: [],
   });
   if (!forwarder) {
     return null;
@@ -19,7 +18,7 @@ export async function getDeployedCloneFactoryContract(args: ClientAndChain) {
   const cloneFactory = await getDeployedInfraContract({
     ...args,
     contractId: "TWCloneFactory",
-    constructorParams: [forwarder.address],
+    constructorParams: { _trustedForwarder: forwarder.address },
   });
   if (!cloneFactory) {
     return null;

package/src/contract/deployment/utils/infra.ts

@@ -1,10 +1,17 @@
+import type { Chain } from "../../../chains/types.js";
+import type { ThirdwebClient } from "../../../client/client.js";
 import { prepareTransaction } from "../../../transaction/prepare-transaction.js";
-import { computePublishedContractAddress } from "../../../utils/any-evm/compute-published-contract-address.js";
-import { computeDeploymentInfoFromContractId } from "../../../utils/any-evm/compute-published-contract-deploy-info.js";
+import { computeContractAddress } from "../../../utils/any-evm/compute-published-contract-address.js";
+import {
+  computeDeploymentInfoFromContractId,
+  computeDeploymentInfoFromMetadata,
+} from "../../../utils/any-evm/compute-published-contract-deploy-info.js";
+import type { FetchDeployMetadataResult } from "../../../utils/any-evm/deploy-metadata.js";
 import { isContractDeployed } from "../../../utils/bytecode/is-contract-deployed.js";
 import type { Prettify } from "../../../utils/type-utils.js";
 import type { ClientAndChain } from "../../../utils/types.js";
 import { type ThirdwebContract, getContract } from "../../contract.js";
+import { fetchPublishedContractMetadata } from "../publisher.js";
 import { computeCreate2FactoryAddress } from "./create-2-factory.js";
 
 export type InfraContractId =
@@ -17,7 +24,7 @@ export type InfraContractId =
 export type GetDeployedInfraParams = Prettify<
   ClientAndChain & {
     contractId: InfraContractId;
-    constructorParams: unknown[];
+    constructorParams?: Record<string, unknown>;
     publisher?: string;
     version?: string;
   }
@@ -29,9 +36,31 @@ export type GetDeployedInfraParams = Prettify<
 export async function getDeployedInfraContract(
   options: GetDeployedInfraParams,
 ): Promise<ThirdwebContract | null> {
-  const address = await computePublishedContractAddress({
-    ...options,
+  const contractMetadata = await fetchPublishedContractMetadata({
+    client: options.client,
+    contractId: options.contractId,
+    publisher: options.publisher,
+    version: options.version,
+  });
+  return getDeployedInfraContractFromMetadata({
+    client: options.client,
+    chain: options.chain,
+    contractMetadata,
+    constructorParams: options.constructorParams,
   });
+}
+
+/**
+ * @internal
+ */
+export async function getDeployedInfraContractFromMetadata(options: {
+  client: ThirdwebClient;
+  chain: Chain;
+  contractMetadata: FetchDeployMetadataResult;
+  constructorParams?: Record<string, unknown>;
+  salt?: string;
+}): Promise<ThirdwebContract | null> {
+  const address = await computeContractAddress(options);
   const factory = getContract({
     ...options,
     address,
@@ -64,3 +93,30 @@ export function prepareInfraContractDeployTransaction(
     },
   });
 }
+
+/**
+ * @internal
+ */
+export function prepareInfraContractDeployTransactionFromMetadata(options: {
+  client: ThirdwebClient;
+  chain: Chain;
+  contractMetadata: FetchDeployMetadataResult;
+  constructorParams?: Record<string, unknown>;
+  salt?: string;
+}) {
+  const { client, chain } = options;
+  return prepareTransaction({
+    client,
+    chain,
+    to: () =>
+      computeCreate2FactoryAddress({
+        client,
+        chain,
+      }),
+    data: async () => {
+      const infraContractInfo =
+        await computeDeploymentInfoFromMetadata(options);
+      return infraContractInfo.initBytecodeWithsalt;
+    },
+  });
+}

package/src/contract/deployment/zksync/zkDeployContract.ts

@@ -4,9 +4,11 @@ import { parseEventLogs } from "../../../event/actions/parse-logs.js";
 import { contractDeployedEvent } from "../../../extensions/zksync/__generated__/ContractDeployer/events/ContractDeployed.js";
 import { sendAndConfirmTransaction } from "../../../transaction/actions/send-and-confirm-transaction.js";
 import { prepareTransaction } from "../../../transaction/prepare-transaction.js";
+import { normalizeFunctionParams } from "../../../utils/abi/normalizeFunctionParams.js";
 import { CONTRACT_DEPLOYER_ADDRESS } from "../../../utils/any-evm/zksync/constants.js";
 import type { Hex } from "../../../utils/encoding/hex.js";
 import type { ClientAndChainAndAccount } from "../../../utils/types.js";
+import { zkDeployContractDeterministic } from "./zkDeployDeterministic.js";
 
 /**
  * @internal
@@ -15,14 +17,23 @@ export async function zkDeployContract(
   options: ClientAndChainAndAccount & {
     abi: Abi;
     bytecode: Hex;
-    params?: unknown[];
+    params?: Record<string, unknown>;
+    salt?: string;
   },
 ) {
+  if (options.salt !== undefined) {
+    // if a salt is provided, use the deterministic deployer
+    return zkDeployContractDeterministic(options);
+  }
+
   const data = encodeDeployData({
     abi: options.abi,
     bytecode: options.bytecode,
     deploymentType: "create",
-    args: options.params,
+    args: normalizeFunctionParams(
+      options.abi.find((abi) => abi.type === "constructor"),
+      options.params,
+    ),
   });
 
   const receipt = await sendAndConfirmTransaction({

package/src/contract/deployment/zksync/zkDeployDeterministic.ts

@@ -1,9 +1,10 @@
-import { type Abi, parseAbi } from "abitype";
+import { type Abi, type AbiConstructor, parseAbi } from "abitype";
 import { hashBytecode } from "viem/zksync";
 import { sendAndConfirmTransaction } from "../../../transaction/actions/send-and-confirm-transaction.js";
 import { prepareContractCall } from "../../../transaction/prepare-contract-call.js";
 import { readContract } from "../../../transaction/read-contract.js";
 import { encodeAbiParameters } from "../../../utils/abi/encodeAbiParameters.js";
+import { normalizeFunctionParams } from "../../../utils/abi/normalizeFunctionParams.js";
 import { keccakId } from "../../../utils/any-evm/keccak-id.js";
 import { computeDeploymentAddress } from "../../../utils/any-evm/zksync/computeDeploymentAddress.js";
 import {
@@ -25,7 +26,7 @@ export async function zkDeployContractDeterministic(
   options: ClientAndChainAndAccount & {
     abi: Abi;
     bytecode: Hex;
-    params: unknown[];
+    params?: Record<string, unknown>;
     salt?: string;
   },
 ) {
@@ -34,7 +35,7 @@ export async function zkDeployContractDeterministic(
   ) || { inputs: [] };
   const encodedArgs = encodeAbiParameters(
     constructorAbi.inputs,
-    options.params || [],
+    normalizeFunctionParams(constructorAbi as AbiConstructor, options.params),
   );
   const create2FactoryAddress = await zkDeployCreate2Factory({
     client: options.client,

package/src/contract/deployment/zksync/zkDeployProxy.ts

@@ -44,10 +44,11 @@ export async function zkDeployProxy(
     account: options.account,
     abi: twProxyAbi,
     bytecode: twProxyBytecode,
-    params: [
-      implementationAddress,
-      await encode(options.initializeTransaction),
-    ],
+    params: {
+      _logic: implementationAddress,
+      _data: await encode(options.initializeTransaction),
+    },
+    salt: options.salt,
   });
 
   // return address of proxy

package/src/exports/deploys.ts

@@ -19,6 +19,17 @@ export {
   deployERC1155Contract,
 } from "../extensions/prebuilts/deploy-erc1155.js";
 
+export {
+  deploySplitContract,
+  type SplitContractParams,
+  type DeploySplitContractOptions,
+} from "../extensions/prebuilts/deploy-split.js";
+
+export {
+  deployMarketplaceContract,
+  type MarketplaceContractParams,
+} from "../extensions/prebuilts/deploy-marketplace.js";
+
 export {
   deployPublishedContract,
   type DeployPublishedContractOptions,
@@ -35,8 +46,4 @@ export {
   type PrepareDirectDeployTransactionOptions,
 } from "../contract/deployment/deploy-with-abi.js";
 export { computePublishedContractAddress } from "../utils/any-evm/compute-published-contract-address.js";
-export {
-  deploySplitContract,
-  type SplitContractParams,
-  type DeploySplitContractOptions,
-} from "../extensions/prebuilts/deploy-split.js";
+export { getRequiredTransactionCount } from "../extensions/prebuilts/get-required-transactions.js";

package/src/exports/modules.ts

@@ -1,20 +1,90 @@
 // Modules
+/**
+ * All functions related to the MintableERC20 module.
+ * @modules MintableERC20
+ */
 export * as MintableERC20 from "../extensions/modules/MintableERC20/index.js";
+/**
+ * All functions related to the MintableERC721 module.
+ * @modules MintableERC721
+ */
 export * as MintableERC721 from "../extensions/modules/MintableERC721/index.js";
+/**
+ * All functions related to the MintableERC1155 module.
+ * @modules MintableERC1155
+ */
 export * as MintableERC1155 from "../extensions/modules/MintableERC1155/index.js";
+/**
+ * All functions related to the ClaimableERC20 module.
+ * @modules ClaimableERC20
+ */
 export * as ClaimableERC20 from "../extensions/modules/ClaimableERC20/index.js";
+/**
+ * All functions related to the ClaimableERC721 module.
+ * @modules ClaimableERC721
+ */
 export * as ClaimableERC721 from "../extensions/modules/ClaimableERC721/index.js";
+/**
+ * All functions related to the ClaimableERC1155 module.
+ * @modules ClaimableERC1155
+ */
 export * as ClaimableERC1155 from "../extensions/modules/ClaimableERC1155/index.js";
+/**
+ * All functions related to the OpenEditionMetadataERC721 module.
+ * @modules OpenEditionMetadataERC721
+ */
 export * as OpenEditionMetadataERC721 from "../extensions/modules/OpenEditionMetadataERC721/index.js";
+/**
+ * All functions related to the BatchMetadataERC721 module.
+ * @modules BatchMetadataERC721
+ */
 export * as BatchMetadataERC721 from "../extensions/modules/BatchMetadataERC721/index.js";
+/**
+ * All functions related to the BatchMetadataERC1155 module.
+ * @modules BatchMetadataERC1155
+ */
 export * as BatchMetadataERC1155 from "../extensions/modules/BatchMetadataERC1155/index.js";
+/**
+ * All functions related to the SequentialTokenIdERC1155 module.
+ * @modules SequentialTokenIdERC1155
+ */
 export * as SequentialTokenIdERC1155 from "../extensions/modules/SequentialTokenIdERC1155/index.js";
+/**
+ * All functions related to the RoyaltyERC721 module.
+ * @modules RoyaltyERC721
+ */
 export * as RoyaltyERC721 from "../extensions/modules/RoyaltyERC721/index.js";
+/**
+ * All functions related to the RoyaltyERC1155 module.
+ * @modules RoyaltyERC1155
+ */
 export * as RoyaltyERC1155 from "../extensions/modules/RoyaltyERC1155/index.js";
-export * as TransferableERC20 from "../extensions/modules/TransferableERC721/index.js";
+/**
+ * All functions related to the TransferableERC20 module.
+ * @modules TransferableERC20
+ */
+export * as TransferableERC20 from "../extensions/modules/TransferableERC20/index.js";
+/**
+ * All functions related to the TransferableERC721 module.
+ * @modules TransferableERC721
+ */
 export * as TransferableERC721 from "../extensions/modules/TransferableERC721/index.js";
+/**
+ * All functions related to the TransferableERC1155 module.
+ * @modules TransferableERC1155
+ */
 export * as TransferableERC1155 from "../extensions/modules/TransferableERC1155/index.js";
 
+// deploy
+export {
+  deployModularContract,
+  type DeployModularContractOptions,
+  type CoreType,
+  type ModularContractParams,
+  type ModuleInstallData,
+  type ModuleInstaller,
+} from "../extensions/prebuilts/deploy-modular.js";
+
 // Common
 export { grantMinterRole } from "../extensions/modules/common/grantMinterRole.js";
 export {