created isSuperchain and isCrosschain flag in favour of case switch statement

Author: GWSzeto

apps/dashboard/src/app/(dashboard)/(chain)/[chain_id]/[contractAddress]/cross-chain/data-table.tsx

@@ -135,14 +135,16 @@ export function DataTable({
       deployStatusModal.setViewContractLink("");
       deployStatusModal.open(steps);
 
+      const isCrosschain = !!modulesMetadata?.find(
+        (m) => m.name === "SuperChainInterop",
+      );
+
       const crosschainContractAddress = await deployContractfromDeployMetadata({
         account: activeAccount,
         chain,
         client,
-        deployMetadata: {
-          ...coreMetadata,
-          deployType: "crosschain" as const,
-        },
+        deployMetadata: coreMetadata,
+        isCrosschain,
         initializeData,
         salt,
       });
@@ -153,93 +155,95 @@ export function DataTable({
         client,
       });
 
-      const owner = await readContract({
-        contract: coreContract,
-        method: "function owner() view returns (address)",
-        params: [],
-      });
+      if (isCrosschain) {
+        const owner = await readContract({
+          contract: coreContract,
+          method: "function owner() view returns (address)",
+          params: [],
+        });
 
-      const moduleInitializeParams = modulesMetadata.reduce(
-        (acc, mod) => {
-          const params = getModuleInstallParams(mod);
-          const paramNames = params
-            .map((param) => param.name)
-            .filter((p) => p !== undefined);
-          const returnVal: Record<string, string> = {};
+        const moduleInitializeParams = modulesMetadata.reduce(
+          (acc, mod) => {
+            const params = getModuleInstallParams(mod);
+            const paramNames = params
+              .map((param) => param.name)
+              .filter((p) => p !== undefined);
+            const returnVal: Record<string, string> = {};
 
-          // set connected wallet address as default "royaltyRecipient"
-          if (showRoyaltyFieldset(paramNames)) {
-            returnVal.royaltyRecipient = owner || "";
-            returnVal.royaltyBps = "0";
-            returnVal.transferValidator = ZERO_ADDRESS;
-          }
+            // set connected wallet address as default "royaltyRecipient"
+            if (showRoyaltyFieldset(paramNames)) {
+              returnVal.royaltyRecipient = owner || "";
+              returnVal.royaltyBps = "0";
+              returnVal.transferValidator = ZERO_ADDRESS;
+            }
 
-          // set connected wallet address as default "primarySaleRecipient"
-          else if (showPrimarySaleFiedset(paramNames)) {
-            returnVal.primarySaleRecipient = owner || "";
-          }
+            // set connected wallet address as default "primarySaleRecipient"
+            else if (showPrimarySaleFiedset(paramNames)) {
+              returnVal.primarySaleRecipient = owner || "";
+            }
 
-          // set superchain bridge address
-          else if (showSuperchainBridgeFieldset(paramNames)) {
-            returnVal.superchainBridge =
-              "0x4200000000000000000000000000000000000010"; // OP Superchain Bridge
-          }
+            // set superchain bridge address
+            else if (showSuperchainBridgeFieldset(paramNames)) {
+              returnVal.superchainBridge =
+                "0x4200000000000000000000000000000000000010"; // OP Superchain Bridge
+            }
 
-          acc[mod.name] = returnVal;
-          return acc;
-        },
-        {} as Record<string, Record<string, string>>,
-      );
+            acc[mod.name] = returnVal;
+            return acc;
+          },
+          {} as Record<string, Record<string, string>>,
+        );
 
-      const moduleDeployData = modulesMetadata.map((m) => ({
-        deployMetadata: m,
-        initializeParams: moduleInitializeParams[m.name],
-      }));
+        const moduleDeployData = modulesMetadata.map((m) => ({
+          deployMetadata: m,
+          initializeParams: moduleInitializeParams[m.name],
+        }));
 
-      const contract = getContract({
-        address: crosschainContractAddress,
-        chain,
-        client,
-      });
+        const contract = getContract({
+          address: crosschainContractAddress,
+          chain,
+          client,
+        });
 
-      await Promise.all(
-        moduleDeployData.map(async (m) => {
-          let moduleData: `0x${string}` | undefined;
+        await Promise.all(
+          moduleDeployData.map(async (m) => {
+            let moduleData: `0x${string}` | undefined;
 
-          const moduleInstallParams = m.deployMetadata.abi.find(
-            (abiType) =>
-              (abiType as AbiFunction).name === "encodeBytesOnInstall",
-          ) as AbiFunction | undefined;
+            const moduleInstallParams = m.deployMetadata.abi.find(
+              (abiType) =>
+                (abiType as AbiFunction).name === "encodeBytesOnInstall",
+            ) as AbiFunction | undefined;
 
-          if (m.initializeParams && moduleInstallParams) {
-            moduleData = encodeAbiParameters(
-              (
-                moduleInstallParams.inputs as { name: string; type: string }[]
-              ).map((p) => ({
-                name: p.name,
-                type: p.type,
-              })),
-              Object.values(m.initializeParams),
-            );
-          }
+            if (m.initializeParams && moduleInstallParams) {
+              moduleData = encodeAbiParameters(
+                (
+                  moduleInstallParams.inputs as { name: string; type: string }[]
+                ).map((p) => ({
+                  name: p.name,
+                  type: p.type,
+                })),
+                Object.values(m.initializeParams),
+              );
+            }
 
-          const installTransaction = installPublishedModule({
-            contract,
-            account: activeAccount,
-            moduleName: m.deployMetadata.name,
-            publisher: m.deployMetadata.publisher,
-            version: m.deployMetadata.version,
-            moduleData,
-          });
+            const installTransaction = installPublishedModule({
+              contract,
+              account: activeAccount,
+              moduleName: m.deployMetadata.name,
+              publisher: m.deployMetadata.publisher,
+              version: m.deployMetadata.version,
+              moduleData,
+            });
 
-          const txResult = await sendTransaction({
-            transaction: installTransaction,
-            account: activeAccount,
-          });
+            const txResult = await sendTransaction({
+              transaction: installTransaction,
+              account: activeAccount,
+            });
 
-          return await waitForReceipt(txResult);
-        }),
-      );
+            return await waitForReceipt(txResult);
+          }),
+        );
+      }
 
       deployStatusModal.nextStep();
       deployStatusModal.setViewContractLink(

apps/dashboard/src/components/contract-components/contract-deploy-form/custom-contract.tsx

@@ -466,6 +466,7 @@ export const CustomContractForm: React.FC<CustomContractFormProps> = ({
         deployMetadata: metadata,
         initializeParams,
         salt,
+        isSuperchainInterop,
         modules: isSuperchainInterop
           ? // remove modules for superchain interop in order to deploy deterministically deploy just the core contract
             []

packages/thirdweb/src/extensions/prebuilts/deploy-published.ts

@@ -123,6 +123,8 @@ export type DeployContractfromDeployMetadataOptions = {
   initializeParams?: Record<string, unknown>;
   initializeData?: `0x${string}`;
   implementationConstructorParams?: Record<string, unknown>;
+  isSuperchainInterop?: boolean;
+  isCrosschain?: boolean;
   modules?: {
     deployMetadata: FetchDeployMetadataResult;
     initializeParams?: Record<string, unknown>;
@@ -143,6 +145,8 @@ export async function deployContractfromDeployMetadata(
     initializeParams,
     initializeData,
     deployMetadata,
+    isSuperchainInterop, // TODO: Remove this once the updated Clone Factory has been published
+    isCrosschain,
     implementationConstructorParams,
     modules,
     salt,
@@ -166,7 +170,7 @@ export async function deployContractfromDeployMetadata(
         import("../../contract/deployment/deploy-via-autofactory.js"),
         import("../../contract/deployment/utils/bootstrap.js"),
       ]);
-      const { cloneFactoryContract: _, implementationContract } =
+      const { cloneFactoryContract, implementationContract } =
         await getOrDeployInfraForPublishedContract({
           chain,
           client,
@@ -181,15 +185,9 @@ export async function deployContractfromDeployMetadata(
           publisher: deployMetadata.publisher,
         });
 
-      const initializeTransaction = await getInitializeTransaction({
-        client,
-        chain,
-        deployMetadata,
-        implementationContract,
-        initializeParams,
-        account,
-        modules,
-      });
+      console.error("is superchain interop", isSuperchainInterop);
+      console.error("is crosschain: ", isCrosschain);
+      console.error("initialize data: ", initializeData);
 
       // TODO: remove this once the modified version of TWCloneFactory
       // has been published under the thirdweb wallet
@@ -199,51 +197,37 @@ export async function deployContractfromDeployMetadata(
         chain,
       });
 
-      return await deployViaAutoFactory({
-        client,
-        chain,
-        account,
-        cloneFactoryContract: modifiedCloneFactoryContract,
-        initializeTransaction,
-        salt,
-      });
-    }
-    case "crosschain": {
-      const { getOrDeployInfraForPublishedContract } = await import(
-        "../../contract/deployment/utils/bootstrap.js"
-      );
-      const { cloneFactoryContract: _, implementationContract } =
-        await getOrDeployInfraForPublishedContract({
+      if (isCrosschain) {
+        return await deployViaAutoFactoryWithImplementationParams({
+          client,
           chain,
+          account,
+          cloneFactoryContract: modifiedCloneFactoryContract,
+          implementationAddress: implementationContract.address,
+          initializeData,
+          salt,
+        });
+      } else {
+        const initializeTransaction = await getInitializeTransaction({
           client,
+          chain,
+          deployMetadata,
+          implementationContract,
+          initializeParams,
           account,
-          contractId: deployMetadata.name,
-          constructorParams:
-            implementationConstructorParams ||
-            (await getAllDefaultConstructorParamsForImplementation({
-              chain,
-              client,
-            })),
-          publisher: deployMetadata.publisher,
+          modules,
         });
-
-      // TODO: remove this once the modified version of TWCloneFactory
-      // has been published under the thirdweb wallet
-      const modifiedCloneFactoryContract = getContract({
-        client,
-        address: "0xB83db4b940e4796aA1f53DBFC824B9B1865835D5", // only deployed on OP and zora testnets
-        chain,
-      });
-
-      return await deployViaAutoFactoryWithImplementationParams({
-        client,
-        chain,
-        account,
-        cloneFactoryContract: modifiedCloneFactoryContract,
-        implementationAddress: implementationContract.address,
-        initializeData,
-        salt,
-      });
+        return await deployViaAutoFactory({
+          client,
+          chain,
+          account,
+          cloneFactoryContract: isSuperchainInterop // TODO: remove this once the updated clone factory is publsihed
+            ? modifiedCloneFactoryContract
+            : cloneFactoryContract,
+          initializeTransaction,
+          salt,
+        });
+      }
     }
     case "customFactory": {
       if (!deployMetadata?.factoryDeploymentData?.customFactoryInput) {