enable for direct deploys

Author: kumaryash90

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

@@ -46,10 +46,12 @@ import { useForm } from "react-hook-form";
 import {
   ZERO_ADDRESS,
   defineChain,
+  eth_getCode,
   eth_getTransactionCount,
   getContract,
   getRpcClient,
   prepareContractCall,
+  prepareTransaction,
   readContract,
   sendAndConfirmTransaction,
   sendTransaction,
@@ -77,7 +79,14 @@ type CrossChain = {
   status: "DEPLOYED" | "NOT_DEPLOYED";
 };
 
-type ChainId = "84532" | "11155420" | "919" | "111557560" | "999999999";
+type ChainId =
+  | "84532"
+  | "11155420"
+  | "919"
+  | "111557560"
+  | "999999999"
+  | "11155111"
+  | "421614";
 
 const formSchema = z.object({
   amounts: z.object({
@@ -100,13 +109,15 @@ export function DataTable({
   modulesMetadata,
   initializeData,
   inputSalt,
+  initCode,
 }: {
   data: CrossChain[];
   coreMetadata: FetchDeployMetadataResult;
   coreContract: ThirdwebContract;
   modulesMetadata?: FetchDeployMetadataResult[];
   initializeData?: `0x${string}`;
   inputSalt?: `0x${string}`;
+  initCode?: `0x${string}`;
 }) {
   const activeAccount = useActiveAccount();
   const switchChain = useSwitchActiveWalletChain();
@@ -285,121 +296,148 @@ export function DataTable({
         (m) => m.name === "SuperChainInterop",
       );
 
-      const crosschainContractAddress = await deployContractfromDeployMetadata({
-        account: activeAccount,
-        chain,
-        client,
-        deployMetadata: coreMetadata,
-        isCrosschain: true,
-        initializeData,
-        salt,
-      });
-
-      verifyContract({
-        address: crosschainContractAddress,
-        chain,
-        client,
-      });
-
-      if (isCrosschain && modulesMetadata) {
-        const owner = await readContract({
-          contract: coreContract,
-          method: "function owner() view returns (address)",
-          params: [],
+      let crosschainContractAddress: string | undefined;
+      if (initCode) {
+        const tx = prepareTransaction({
+          client,
+          chain,
+          to: "0x4e59b44847b379578588920cA78FbF26c0B4956C",
+          data: initCode,
         });
 
-        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 "primarySaleRecipient"
-            else if (showPrimarySaleFieldset(paramNames)) {
-              returnVal.primarySaleRecipient = owner || "";
-            }
-
-            // set superchain bridge address
-            else if (showSuperchainBridgeFieldset(paramNames)) {
-              returnVal.superchainBridge =
-                "0x4200000000000000000000000000000000000028"; // OP Superchain Bridge
-            }
+        await sendAndConfirmTransaction({
+          transaction: tx,
+          account: activeAccount,
+        });
 
-            acc[mod.name] = returnVal;
-            return acc;
+        const code = await eth_getCode(
+          getRpcClient({
+            client,
+            chain,
+          }),
+          {
+            address: coreContract.address,
           },
-          {} as Record<string, Record<string, string>>,
         );
 
-        const moduleDeployData = modulesMetadata.map((m) => ({
-          deployMetadata: m,
-          initializeParams: moduleInitializeParams[m.name],
-        }));
-
-        const contract = getContract({
-          address: crosschainContractAddress,
+        if (code && code.length > 2) {
+          crosschainContractAddress = coreContract.address;
+        }
+      } else {
+        crosschainContractAddress = await deployContractfromDeployMetadata({
+          account: activeAccount,
           chain,
           client,
+          deployMetadata: coreMetadata,
+          isCrosschain: true,
+          initializeData,
+          salt,
         });
 
-        const rpcRequest = getRpcClient({
-          client,
+        verifyContract({
+          address: crosschainContractAddress,
           chain,
+          client,
         });
-        const currentNonce = await eth_getTransactionCount(rpcRequest, {
-          address: activeAccount.address,
-        });
+        if (isCrosschain && modulesMetadata) {
+          const owner = await readContract({
+            contract: coreContract,
+            method: "function owner() view returns (address)",
+            params: [],
+          });
 
-        for (const [i, m] of moduleDeployData.entries()) {
-          let moduleData: `0x${string}` | 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),
-            );
-          }
+          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 "primarySaleRecipient"
+              else if (showPrimarySaleFieldset(paramNames)) {
+                returnVal.primarySaleRecipient = owner || "";
+              }
+
+              // set superchain bridge address
+              else if (showSuperchainBridgeFieldset(paramNames)) {
+                returnVal.superchainBridge =
+                  "0x4200000000000000000000000000000000000028"; // OP Superchain Bridge
+              }
+
+              acc[mod.name] = returnVal;
+              return acc;
+            },
+            {} as Record<string, Record<string, string>>,
+          );
 
-          const installTransaction = installPublishedModule({
-            contract,
-            account: activeAccount,
-            moduleName: m.deployMetadata.name,
-            publisher: m.deployMetadata.publisher,
-            version: m.deployMetadata.version,
-            moduleData,
-            nonce: currentNonce + i,
+          const moduleDeployData = modulesMetadata.map((m) => ({
+            deployMetadata: m,
+            initializeParams: moduleInitializeParams[m.name],
+          }));
+
+          const contract = getContract({
+            address: crosschainContractAddress,
+            chain,
+            client,
           });
 
-          const txResult = await sendTransaction({
-            transaction: installTransaction,
-            account: activeAccount,
+          const rpcRequest = getRpcClient({
+            client,
+            chain,
+          });
+          const currentNonce = await eth_getTransactionCount(rpcRequest, {
+            address: activeAccount.address,
           });
 
-          await waitForReceipt(txResult);
-          // can't handle parallel transactions, so wait a bit
-          await new Promise((resolve) => setTimeout(resolve, 1000));
+          for (const [i, m] of moduleDeployData.entries()) {
+            let moduleData: `0x${string}` | 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),
+              );
+            }
+
+            const installTransaction = installPublishedModule({
+              contract,
+              account: activeAccount,
+              moduleName: m.deployMetadata.name,
+              publisher: m.deployMetadata.publisher,
+              version: m.deployMetadata.version,
+              moduleData,
+              nonce: currentNonce + i,
+            });
+
+            const txResult = await sendTransaction({
+              transaction: installTransaction,
+              account: activeAccount,
+            });
+
+            await waitForReceipt(txResult);
+            // can't handle parallel transactions, so wait a bit
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+          }
         }
       }
-
       deployStatusModal.nextStep();
       deployStatusModal.setViewContractLink(
         `/${chain.id}/${crosschainContractAddress}`,

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

@@ -1,6 +1,10 @@
 import { fetchPublishedContractsFromDeploy } from "components/contract-components/fetchPublishedContractsFromDeploy";
 import { notFound } from "next/navigation";
-import { getContractEvents, prepareEvent } from "thirdweb";
+import {
+  eth_getTransactionByHash,
+  getContractEvents,
+  prepareEvent,
+} from "thirdweb";
 import { defineChain, getChainMetadata, localhost } from "thirdweb/chains";
 import {
   type FetchDeployMetadataResult,
@@ -52,12 +56,38 @@ export default async function Page(props: {
     },
   );
 
+  let initCode: `0x${string}` = "0x";
+  try {
+    const res = await fetch(
+      `https://contract.thirdweb-dev.com/creation/${contract.chain.id}/${contract.address}`,
+    );
+    const creationData = await res.json();
+
+    if (creationData.status === "1" && creationData.result[0]?.txHash) {
+      const creationTx = await eth_getTransactionByHash(
+        getRpcClient({
+          client: contract.client,
+          chain: defineChain(84532),
+        }),
+        { hash: creationData.result[0]?.txHash },
+      );
+
+      if (creationTx.to === "0x4e59b44847b379578588920cA78FbF26c0B4956C") {
+        initCode = creationTx.input;
+      }
+    }
+  } catch (e) {
+    console.debug(e);
+  }
+
   const topOPStackTestnetChainIds = [
     84532, // Base
     11155420, // OP testnet
     919, // Mode Network
     111557560, // Cyber
     999999999, // Zora
+    11155111, // sepolia
+    421614,
   ];
 
   const chainsDeployedOn = await Promise.all(
@@ -143,6 +173,7 @@ export default async function Page(props: {
       inputSalt={event?.args.inputSalt}
       data={chainsDeployedOn}
       coreContract={contract}
+      initCode={initCode}
     />
   );
 }