feat: add createRollupFetchTransactionHash

src/createRollup.integration.test.ts

@@ -1,76 +1,55 @@
-import { it, expect } from 'vitest';
+import { describe, it, expect } from 'vitest';
 import { createPublicClient, http, parseGwei, zeroAddress } from 'viem';
 
 import { nitroTestnodeL2 } from './chains';
-import { generateChainId } from './utils';
-import { prepareChainConfig } from './prepareChainConfig';
-import { createRollupPrepareConfig } from './createRollupPrepareConfig';
-import { createRollupPrepareTransaction } from './createRollupPrepareTransaction';
-import { createRollupPrepareTransactionRequest } from './createRollupPrepareTransactionRequest';
-import { createRollupPrepareTransactionReceipt } from './createRollupPrepareTransactionReceipt';
-
 import { getTestPrivateKeyAccount } from './testHelpers';
+import { createRollupFetchTransactionHash } from './createRollupFetchTransactionHash';
+import { createTestRollup } from './utils/testHelpers';
 
-const deployer = getTestPrivateKeyAccount();
-
-const batchPoster = deployer.address;
-const validators = [deployer.address];
-
+// public client
 const publicClient = createPublicClient({
   chain: nitroTestnodeL2,
   transport: http(),
 });
 
-it(`successfully deploys core contracts through rollup creator`, async () => {
-  // generate a random chain id
-  const chainId = generateChainId();
-
-  // create the chain config
-  const chainConfig = prepareChainConfig({
-    chainId,
-    arbitrum: { InitialChainOwner: deployer.address },
-  });
-
-  const config = createRollupPrepareConfig({
-    chainId: BigInt(chainId),
-    owner: deployer.address,
-    chainConfig,
-  });
+// test inputs
+const deployer = getTestPrivateKeyAccount();
+const batchPoster = deployer.address;
+const validators = [deployer.address];
 
-  // prepare the transaction for deploying the core contracts
-  const request = await createRollupPrepareTransactionRequest({
-    params: {
-      config,
-      batchPoster,
-      validators,
-    },
-    account: deployer.address,
+describe(`createRollup`, async () => {
+  // create test rollup
+  const createRollupInformation = await createTestRollup({
+    deployer,
+    batchPoster,
+    validators,
     publicClient,
   });
 
-  // sign and send the transaction
-  const txHash = await publicClient.sendRawTransaction({
-    serializedTransaction: await deployer.signTransaction(request),
+  it(`successfully deploys core contracts through rollup creator`, async () => {
+    // assert all inputs are correct
+    const [arg] = createRollupInformation.transaction.getInputs();
+    expect(arg.config).toEqual(createRollupInformation.config);
+    expect(arg.batchPoster).toEqual(batchPoster);
+    expect(arg.validators).toEqual(validators);
+    expect(arg.maxDataSize).toEqual(104_857n);
+    expect(arg.nativeToken).toEqual(zeroAddress);
+    expect(arg.deployFactoriesToL2).toEqual(true);
+    expect(arg.maxFeePerGasForRetryables).toEqual(parseGwei('0.1'));
+
+    // assert the transaction executed successfully
+    expect(createRollupInformation.transactionReceipt.status).toEqual('success');
+
+    // assert the core contracts were successfully obtained
+    expect(createRollupInformation.coreContracts).toBeDefined();
   });
 
-  // get the transaction
-  const tx = createRollupPrepareTransaction(await publicClient.getTransaction({ hash: txHash }));
-
-  const [arg] = tx.getInputs();
-  // assert all inputs are correct
-  expect(arg.config).toEqual(config);
-  expect(arg.batchPoster).toEqual(batchPoster);
-  expect(arg.validators).toEqual(validators);
-  expect(arg.maxDataSize).toEqual(104_857n);
-  expect(arg.nativeToken).toEqual(zeroAddress);
-  expect(arg.deployFactoriesToL2).toEqual(true);
-  expect(arg.maxFeePerGasForRetryables).toEqual(parseGwei('0.1'));
+  it('finds the transaction hash that created a specified deployed rollup contract', async () => {
+    const transactionHash = await createRollupFetchTransactionHash({
+      rollupAddress: createRollupInformation.coreContracts.rollup,
+      publicClient,
+    });
 
-  // get the transaction receipt after waiting for the transaction to complete
-  const txReceipt = createRollupPrepareTransactionReceipt(
-    await publicClient.waitForTransactionReceipt({ hash: txHash }),
-  );
-
-  expect(txReceipt.status).toEqual('success');
-  expect(() => txReceipt.getCoreContracts()).not.toThrowError();
+    expect(transactionHash).toEqual(createRollupInformation.transactionReceipt.transactionHash);
+  });
 });

src/createRollupFetchTransactionHash.ts

@@ -0,0 +1,63 @@
+import { Address, PublicClient } from 'viem';
+import { AbiEvent } from 'abitype';
+import { deploymentBlockNumber } from './generated';
+import { ParentChainId } from './types/ParentChain';
+
+export type CreateRollupFetchTransactionHashParams = {
+  rollupAddress: Address;
+  publicClient: PublicClient;
+};
+
+const RollupInitializedEventAbi: AbiEvent = {
+  anonymous: false,
+  inputs: [
+    {
+      indexed: false,
+      internalType: 'bytes32',
+      name: 'machineHash',
+      type: 'bytes32',
+    },
+    {
+      indexed: false,
+      internalType: 'uint256',
+      name: 'chainId',
+      type: 'uint256',
+    },
+  ],
+  name: 'RollupInitialized',
+  type: 'event',
+};
+
+export async function createRollupFetchTransactionHash({
+  rollupAddress,
+  publicClient,
+}: CreateRollupFetchTransactionHashParams) {
+  // Find the RollupInitialized event from that Rollup contract
+  const chainId = await publicClient.getChainId();
+  const fromBlock =
+    chainId in Object.keys(deploymentBlockNumber.RollupCreator)
+      ? deploymentBlockNumber.RollupCreator[chainId as ParentChainId]
+      : 'earliest';
+
+  const rollupInitializedEvents = await publicClient.getLogs({
+    address: rollupAddress,
+    event: RollupInitializedEventAbi,
+    fromBlock,
+    toBlock: 'latest',
+  });
+  if (rollupInitializedEvents.length !== 1) {
+    throw new Error(
+      `Expected to find 1 RollupInitialized event for rollup address ${rollupAddress} but found ${rollupInitializedEvents.length}`,
+    );
+  }
+
+  // Get the transaction hash that emitted that event
+  const transactionHash = rollupInitializedEvents[0].transactionHash;
+  if (!transactionHash) {
+    throw new Error(
+      `No transactionHash found in RollupInitialized event for rollup address ${rollupAddress}`,
+    );
+  }
+
+  return transactionHash;
+}

src/utils/testHelpers.ts

@@ -0,0 +1,86 @@
+import { Address, PrivateKeyAccount, PublicClient } from 'viem';
+import {
+  CreateRollupPrepareConfigResult,
+  createRollupPrepareConfig,
+} from '../createRollupPrepareConfig';
+import { createRollupPrepareTransactionRequest } from '../createRollupPrepareTransactionRequest';
+import { prepareChainConfig } from '../prepareChainConfig';
+import { generateChainId } from './generateChainId';
+import {
+  CreateRollupTransaction,
+  createRollupPrepareTransaction,
+} from '../createRollupPrepareTransaction';
+import {
+  CreateRollupTransactionReceipt,
+  createRollupPrepareTransactionReceipt,
+} from '../createRollupPrepareTransactionReceipt';
+import { CoreContracts } from '../types/CoreContracts';
+
+export type CreateTestRollupParams = {
+  deployer: PrivateKeyAccount;
+  batchPoster: Address;
+  validators: Address[];
+  publicClient: PublicClient;
+};
+
+export type CreateTestRollupResult = {
+  config: CreateRollupPrepareConfigResult;
+  transaction: CreateRollupTransaction;
+  transactionReceipt: CreateRollupTransactionReceipt;
+  coreContracts: CoreContracts;
+};
+
+export async function createTestRollup({
+  deployer,
+  batchPoster,
+  validators,
+  publicClient,
+}: CreateTestRollupParams): Promise<CreateTestRollupResult> {
+  // generate a random chain id
+  const chainId = generateChainId();
+
+  // create the chain config
+  const chainConfig = prepareChainConfig({
+    chainId,
+    arbitrum: { InitialChainOwner: deployer.address },
+  });
+
+  const config = createRollupPrepareConfig({
+    chainId: BigInt(chainId),
+    owner: deployer.address,
+    chainConfig,
+  });
+
+  // prepare the transaction for deploying the core contracts
+  const request = await createRollupPrepareTransactionRequest({
+    params: {
+      config,
+      batchPoster,
+      validators,
+    },
+    account: deployer.address,
+    publicClient,
+  });
+
+  // sign and send the transaction
+  const txHash = await publicClient.sendRawTransaction({
+    serializedTransaction: await deployer.signTransaction(request),
+  });
+
+  // get the transaction
+  const tx = createRollupPrepareTransaction(await publicClient.getTransaction({ hash: txHash }));
+
+  // get the transaction receipt after waiting for the transaction to complete
+  const txReceipt = createRollupPrepareTransactionReceipt(
+    await publicClient.waitForTransactionReceipt({ hash: txHash }),
+  );
+
+  const coreContracts = txReceipt.getCoreContracts();
+
+  return {
+    config,
+    transaction: tx,
+    transactionReceipt: txReceipt,
+    coreContracts,
+  };
+}

wagmi.config.ts

@@ -1,4 +1,6 @@
+import { Plugin } from '@wagmi/cli';
 import { erc, etherscan } from '@wagmi/cli/plugins';
+import dedent from 'dedent';
 import dotenv from 'dotenv';
 
 import { ParentChainId } from './src';
@@ -37,6 +39,7 @@ type ContractConfig = {
   name: string;
   version?: string;
   address: Record<ParentChainId, `0x${string}`> | `0x${string}`;
+  deploymentBlockNumber: Record<ParentChainId, bigint> | bigint;
 };
 
 const contracts: ContractConfig[] = [
@@ -51,6 +54,14 @@ const contracts: ContractConfig[] = [
       [nitroTestnodeL1.id]: '0x596eabe0291d4cdafac7ef53d16c92bf6922b5e0',
       [nitroTestnodeL2.id]: '0x3BaF9f08bAD68869eEdEa90F2Cc546Bd80F1A651',
     },
+    deploymentBlockNumber: {
+      // testnet
+      [sepolia.id]: 4741823n,
+      [arbitrumSepolia.id]: 654628n,
+      // local nitro-testnode (on "use-tokenbridge-creator" branch with --tokenbridge --l3node --l3-token-bridge flags)
+      [nitroTestnodeL1.id]: 0n,
+      [nitroTestnodeL2.id]: 0n,
+    },
   },
   {
     name: 'TokenBridgeCreator',
@@ -63,14 +74,24 @@ const contracts: ContractConfig[] = [
       [nitroTestnodeL1.id]: '0x4a2ba922052ba54e29c5417bc979daaf7d5fe4f4',
       [nitroTestnodeL2.id]: '0x38f35af53bf913c439eab06a367e09d6eb253492',
     },
+    deploymentBlockNumber: {
+      // testnet
+      [sepolia.id]: 4840577n,
+      [arbitrumSepolia.id]: 1633247n,
+      // local nitro-testnode (on "use-tokenbridge-creator" branch with --tokenbridge --l3node --l3-token-bridge flags)
+      [nitroTestnodeL1.id]: 0n,
+      [nitroTestnodeL2.id]: 0n,
+    },
   },
   {
     name: 'ArbOwner',
     address: '0x0000000000000000000000000000000000000070',
+    deploymentBlockNumber: 0n,
   },
   {
     name: 'ArbOwnerPublic',
     address: '0x000000000000000000000000000000000000006b',
+    deploymentBlockNumber: 0n,
   },
 ];
 
@@ -104,6 +125,40 @@ export async function assertContractAbisMatch(contract: ContractConfig) {
   console.log(`- ${contract.name} ✔`);
 }
 
+// https://wagmi.sh/cli/plugins#creating-plugins
+type DeploymentBlockNumberPluginConfig = {
+  contracts: ContractConfig[];
+};
+type DeploymentBlockNumberPluginResult = Required<Pick<Plugin, 'run'>> & Omit<Plugin, 'run'>;
+
+function deploymentBlockNumberPlugin(
+  config: DeploymentBlockNumberPluginConfig,
+): DeploymentBlockNumberPluginResult {
+  return {
+    name: 'DeploymentBlockNumber',
+    async run({ contracts, isTypeScript, outputs }) {
+      const pluginOutput = dedent`
+        export const deploymentBlockNumber = {
+          ${config.contracts.map((contract) => {
+            return typeof contract.deploymentBlockNumber === 'bigint'
+              ? `${contract.name}: ${contract.deploymentBlockNumber}n`
+              : dedent`
+                ${contract.name}: {
+                  ${Object.keys(contract.deploymentBlockNumber).map((parentChainId) => {
+                    return `${parentChainId}: ${contract.deploymentBlockNumber[parentChainId]}n`;
+                  })}
+                }`;
+          })}
+        } as const
+      `;
+
+      return {
+        content: pluginOutput,
+      };
+    },
+  };
+}
+
 export default async function () {
   console.log(`Checking if contract ABIs match...`);
 
@@ -126,6 +181,9 @@ export default async function () {
         contracts,
         cacheDuration: 0,
       }),
+      deploymentBlockNumberPlugin({
+        contracts,
+      }),
     ],
   };
 }