successfully deploys using the initialize data from the event

Author: GWSzeto

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

@@ -42,12 +42,12 @@ export function DataTable({
   data,
   coreMetadata,
   modulesMetadata,
-  initializerCalldata,
+  initializeData,
 }: {
   data: CrossChain[];
   coreMetadata: FetchDeployMetadataResult;
   modulesMetadata: FetchDeployMetadataResult[];
-  initializerCalldata: `0x${string}`;
+  initializeData?: `0x${string}`;
 }) {
   const activeAccount = useActiveAccount();
   const switchChain = useSwitchActiveWalletChain();
@@ -116,14 +116,14 @@ export function DataTable({
         account: activeAccount,
         chain,
         client,
-        deployMetadata: coreMetadata,
-        initializeParams: coreInitializeParams,
+        deployMetadata: {
+          ...coreMetadata,
+          deployType: "crosschain" as const,
+        },
+        initializeData,
         salt,
-        modules: modulesMetadata.map((m) => ({
-          deployMetadata: m,
-          initializeParams: moduleInitializeParams[m.name],
-        })),
       });
+      console.log("crosschain contract address", crosschainContractAddress);
 
       await verifyContract({
         address: crosschainContractAddress,

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

@@ -1,6 +1,5 @@
 import { fetchPublishedContractsFromDeploy } from "components/contract-components/fetchPublishedContractsFromDeploy";
 import { notFound, redirect } from "next/navigation";
-import { readContract } from "thirdweb";
 import { getContractEvents, prepareEvent } from "thirdweb";
 import { defineChain, getChainMetadata, localhost } from "thirdweb/chains";
 import { type FetchDeployMetadataResult, getContract } from "thirdweb/contract";
@@ -109,42 +108,30 @@ export default async function Page(props: {
     ),
   )) as FetchDeployMetadataResult[];
 
-  const _erc20InitialData = await Promise.all([
-    readContract({
-      contract: contract,
-      method: "function name() view returns (string)",
-    }),
-    readContract({
-      contract: contract,
-      method: "function symbol() view returns (string)",
-    }),
-    readContract({
-      contract: contract,
-      method: "function contractURI() view returns (string)",
-    }),
-    readContract({
-      contract: contract,
-      method: "function owner() view returns (address)",
-    }),
-  ]);
-
   const ProxyDeployedEvent = prepareEvent({
     signature:
       "event ProxyDeployed(address indexed implementation, address proxy, address indexed deployer, bytes data)",
   });
 
+  const twCloneFactoryContract = getContract({
+    address: "0xB83db4b940e4796aA1f53DBFC824B9B1865835D5",
+    chain: contract.chain,
+    client: contract.client,
+  });
+
   // TODO: figure out how to fetch the events properly
-  const [event] = await getContractEvents({
-    contract,
+  const events = await getContractEvents({
+    contract: twCloneFactoryContract,
     events: [ProxyDeployedEvent],
     blockRange: 123456n,
   });
+  const event = events.find((e) => e.args.proxy === params.contractAddress);
 
   return (
     <DataTable
       coreMetadata={coreMetadata}
       modulesMetadata={modulesMetadata}
-      initializerCalldata={event?.args.data}
+      initializeData={event?.args.data}
       data={chainsDeployedOn}
     />
   );

apps/dashboard/src/app/(dashboard)/(chain)/[chain_id]/[contractAddress]/modules/components/ModuleForm.tsx

@@ -252,7 +252,6 @@ export const InstallModuleForm = (props: InstallModuleFormProps) => {
     module: selectedModuleMeta,
     isQueryEnabled: !!selectedModule && !!isModuleCompatibleQuery.data,
   });
-  console.log("moduleInstallParams", moduleInstallParams.data);
 
   return (
     <FormProvider {...form}>

packages/thirdweb/src/contract/deployment/deploy-via-autofactory.ts

@@ -47,11 +47,13 @@ export function prepareAutoFactoryDeployTransaction(
       if (!implementation) {
         throw new Error("initializeTransaction must have a 'to' field set");
       }
-      return {
+      const asd = {
         data: await encode(args.initializeTransaction),
         implementation,
         salt,
       } as const;
+      console.error("core contract deploy params: ", asd);
+      return asd;
     },
   });
 }
@@ -108,3 +110,61 @@ export async function deployViaAutoFactory(
   }
   return decodedEvent[0]?.args.proxy;
 }
+
+/**
+ * @internal
+ */
+export async function deployViaAutoFactoryWithImplementationParams(
+  options: ClientAndChainAndAccount & {
+    cloneFactoryContract: ThirdwebContract;
+    initializeData?: `0x${string}`;
+    implementationAddress: string;
+    salt?: string;
+  },
+): Promise<string> {
+  const {
+    client,
+    chain,
+    account,
+    cloneFactoryContract,
+    initializeData,
+    implementationAddress,
+    salt,
+  } = options;
+
+  const rpcRequest = getRpcClient({
+    client,
+    chain,
+  });
+  const blockNumber = await eth_blockNumber(rpcRequest);
+  const parsedSalt = salt
+    ? salt.startsWith("0x") && salt.length === 66
+      ? (salt as `0x${string}`)
+      : keccakId(salt)
+    : toHex(blockNumber, {
+        size: 32,
+      });
+
+  const asd = {
+    contract: cloneFactoryContract,
+    data: initializeData || "0x",
+    implementation: implementationAddress,
+    salt: parsedSalt,
+  };
+  console.error("cross chain contract deploy params: ", asd);
+  const tx = deployProxyByImplementation(asd);
+  const receipt = await sendAndConfirmTransaction({
+    transaction: tx,
+    account,
+  });
+  const decodedEvent = parseEventLogs({
+    events: [proxyDeployedEvent()],
+    logs: receipt.logs,
+  });
+  if (decodedEvent.length === 0 || !decodedEvent[0]) {
+    throw new Error(
+      `No ProxyDeployed event found in transaction: ${receipt.transactionHash}`,
+    );
+  }
+  return decodedEvent[0]?.args.proxy;
+}

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

@@ -2,6 +2,7 @@ import type { AbiFunction } from "abitype";
 import type { Chain } from "../../chains/types.js";
 import type { ThirdwebClient } from "../../client/client.js";
 import { type ThirdwebContract, getContract } from "../../contract/contract.js";
+import { deployViaAutoFactoryWithImplementationParams } from "../../contract/deployment/deploy-via-autofactory.js";
 import { fetchPublishedContractMetadata } from "../../contract/deployment/publisher.js";
 import { getOrDeployInfraContractFromMetadata } from "../../contract/deployment/utils/bootstrap.js";
 import { sendAndConfirmTransaction } from "../../transaction/actions/send-and-confirm-transaction.js";
@@ -120,6 +121,7 @@ export type DeployContractfromDeployMetadataOptions = {
   account: Account;
   deployMetadata: FetchDeployMetadataResult;
   initializeParams?: Record<string, unknown>;
+  initializeData?: `0x${string}`;
   implementationConstructorParams?: Record<string, unknown>;
   modules?: {
     deployMetadata: FetchDeployMetadataResult;
@@ -139,6 +141,7 @@ export async function deployContractfromDeployMetadata(
     account,
     chain,
     initializeParams,
+    initializeData,
     deployMetadata,
     implementationConstructorParams,
     modules,
@@ -205,6 +208,43 @@ export async function deployContractfromDeployMetadata(
         salt,
       });
     }
+    case "crosschain": {
+      const { getOrDeployInfraForPublishedContract } = await import(
+        "../../contract/deployment/utils/bootstrap.js"
+      );
+      const { cloneFactoryContract: _, implementationContract } =
+        await getOrDeployInfraForPublishedContract({
+          chain,
+          client,
+          account,
+          contractId: deployMetadata.name,
+          constructorParams:
+            implementationConstructorParams ||
+            (await getAllDefaultConstructorParamsForImplementation({
+              chain,
+              client,
+            })),
+          publisher: deployMetadata.publisher,
+        });
+
+      // 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,
+      });
+    }
     case "customFactory": {
       if (!deployMetadata?.factoryDeploymentData?.customFactoryInput) {
         throw new Error("No custom factory info found");

packages/thirdweb/src/utils/any-evm/deploy-metadata.ts

@@ -207,7 +207,7 @@ export type ExtendedMetadata = {
         factoryAddresses?: Record<string, string>;
       }
     | undefined;
-  deployType?: "standard" | "autoFactory" | "customFactory";
+  deployType?: "standard" | "autoFactory" | "customFactory" | "crosschain";
   routerType?: "none" | "plugin" | "dynamic" | "modular";
   networksForDeployment?: {
     allNetworks?: boolean;