feat: adds rollup data fetching from Orbit template

.github/ISSUE_TEMPLATE/add-orbit-chain-request.yml

@@ -119,13 +119,6 @@ body:
     attributes:
       value: |
         Please fill out this section with your chain configuration details and contract addresses. As a reminder, you can get all contract addresses by running [getAllContracts](https://github.com/OffchainLabs/arbitrum-orbit-sdk/blob/feat-add-verification-scripts/examples/verify-rollup/README.md#get-all-contracts).
-  - type: input
-    id: confirmPeriodBlocks
-    attributes:
-      label: confirmPeriodBlocks
-      placeholder: ex. 45818
-    validations:
-      required: true
 
   - type: markdown
     attributes:
@@ -135,34 +128,11 @@ body:
     attributes:
       value: |
         You can find this information under the `"coreContracts" : {...}` key.
-  - type: input
-    id: bridge
-    attributes:
-      label: bridge
-    validations:
-      required: true    
-  - type: input
-    id: inbox
-    attributes:
-      label: inbox
-    validations:
-      required: true
-  - type: input
-    id: outbox
-    attributes:
-      label: outbox
-    validations:
-      required: true
   - type: input
     id: rollup
     attributes:
       label: rollup
-    validations:
-      required: true
-  - type: input
-    id: sequencerInbox
-    attributes:
-      label: sequencerInbox
+      description: Please provide the address of the rollup contract. Other core contract addresses will be fetched automatically.
     validations:
       required: true
 

packages/scripts/src/addOrbitChain/network.ts

@@ -0,0 +1,101 @@
+import { ethers } from "ethers";
+
+export async function getProvider(rpcUrl: string) {
+  console.log(`Connecting to provider at ${rpcUrl}`);
+  try {
+    const provider = new ethers.providers.JsonRpcProvider(rpcUrl);
+    await provider.getNetwork(); // Test the connection
+    console.log("Successfully connected to the provider");
+    return provider;
+  } catch (error) {
+    console.error("Failed to connect to the provider:", error);
+    throw error;
+  }
+}
+
+export async function getRollupContract(
+  rollupAddress: string,
+  provider: ethers.providers.Provider
+) {
+  console.log(`Creating rollup contract instance at address ${rollupAddress}`);
+  const rollupABI = [
+    "function bridge() view returns (address)",
+    "function inbox() view returns (address)",
+    "function sequencerInbox() view returns (address)",
+    "function outbox() view returns (address)",
+    "function confirmPeriodBlocks() view returns (uint256)",
+  ];
+  return new ethers.Contract(rollupAddress, rollupABI, provider);
+}
+
+async function callContractMethod(
+  contract: ethers.Contract,
+  methodName: string
+) {
+  console.log(`Calling ${methodName} method on contract`);
+  try {
+    const result = await contract[methodName]();
+    console.log(`${methodName} call successful:`, result);
+    return result;
+  } catch (error) {
+    console.error(`Error calling ${methodName}:`, error);
+    throw error;
+  }
+}
+
+export async function getBridge(rollupContract: ethers.Contract) {
+  return await callContractMethod(rollupContract, "bridge");
+}
+
+export async function getInbox(rollupContract: ethers.Contract) {
+  return await callContractMethod(rollupContract, "inbox");
+}
+
+export async function getSequencerInbox(rollupContract: ethers.Contract) {
+  return await callContractMethod(rollupContract, "sequencerInbox");
+}
+
+export async function getOutbox(rollupContract: ethers.Contract) {
+  return await callContractMethod(rollupContract, "outbox");
+}
+
+export async function getConfirmPeriodBlocks(rollupContract: ethers.Contract) {
+  const confirmPeriodBlocks = await callContractMethod(
+    rollupContract,
+    "confirmPeriodBlocks"
+  );
+  return confirmPeriodBlocks.toNumber();
+}
+
+export async function fetchRollupContractData(
+  rollupAddress: string,
+  rpcUrl: string
+) {
+  console.log(`Fetching rollup contract data for address ${rollupAddress}`);
+  try {
+    const provider = await getProvider(rpcUrl);
+    const rollupContract = await getRollupContract(rollupAddress, provider);
+
+    console.log("Fetching contract data...");
+    const [bridge, inbox, sequencerInbox, outbox, confirmPeriodBlocks] =
+      await Promise.all([
+        getBridge(rollupContract),
+        getInbox(rollupContract),
+        getSequencerInbox(rollupContract),
+        getOutbox(rollupContract),
+        getConfirmPeriodBlocks(rollupContract),
+      ]);
+
+    console.log("Successfully fetched all contract data");
+    return {
+      bridge,
+      inbox,
+      sequencerInbox,
+      outbox,
+      confirmPeriodBlocks,
+    };
+  } catch (error) {
+    console.error("Error fetching rollup contract data:", error);
+    throw error;
+  }
+}

packages/scripts/src/addOrbitChain/tests/__mocks__/chainDataMocks.ts

@@ -180,7 +180,7 @@ export const mockIncomingChainData: IncomingChainData = {
   description: "This is a test chain.",
   chainLogo: "https://example.com/testchain.png",
   color: "#FF0000",
-  rpcUrl: "https://testrpc.com",
+  rpcUrl: "https://sepolia-rollup.arbitrum.io/rpc",
   explorerUrl: "https://testexplorer.com",
   parentChainId: "421614",
   confirmPeriodBlocks: "150",
@@ -191,7 +191,7 @@ export const mockIncomingChainData: IncomingChainData = {
   bridge: "0x0000000000000000000000000000000000000001",
   inbox: "0x0000000000000000000000000000000000000002",
   outbox: "0x0000000000000000000000000000000000000003",
-  rollup: "0x0000000000000000000000000000000000000004",
+  rollup: "0xeedE9367Df91913ab149e828BDd6bE336df2c892",
   sequencerInbox: "0x0000000000000000000000000000000000000005",
   parentGatewayRouter: "0x0000000000000000000000000000000000000009",
   childGatewayRouter: "0x0000000000000000000000000000000000000016",

packages/scripts/src/addOrbitChain/tests/__snapshots__/transforms.test.ts.snap

@@ -56,11 +56,11 @@ exports[`Transforms > transformIncomingDataToOrbitChain > should transform incom
   "chainId": 1234567890,
   "confirmPeriodBlocks": 150,
   "ethBridge": {
-    "bridge": "0x0000000000000000000000000000000000000001",
-    "inbox": "0x0000000000000000000000000000000000000002",
-    "outbox": "0x0000000000000000000000000000000000000003",
-    "rollup": "0x0000000000000000000000000000000000000004",
-    "sequencerInbox": "0x0000000000000000000000000000000000000005",
+    "bridge": "0x6c7FAC4edC72E86B3388B48979eF37Ecca5027e6",
+    "inbox": "0x6396825803B720bc6A43c63caa1DcD7B31EB4dd0",
+    "outbox": "0xc7491a559b416540427f9f112C5c98b1412c5d51",
+    "rollup": "0xeedE9367Df91913ab149e828BDd6bE336df2c892",
+    "sequencerInbox": "0x529a2061A1973be80D315770bA9469F3Da40D938",
   },
   "explorerUrl": "https://testexplorer.com",
   "isArbitrum": true,
@@ -70,7 +70,7 @@ exports[`Transforms > transformIncomingDataToOrbitChain > should transform incom
   "nativeToken": "0x0000000000000000000000000000000000000006",
   "parentChainId": 421614,
   "retryableLifetimeSeconds": 604800,
-  "rpcUrl": "https://testrpc.com",
+  "rpcUrl": "https://sepolia-rollup.arbitrum.io/rpc",
   "slug": "test-chain",
   "tokenBridge": {
     "childCustomGateway": "0x0000000000000000000000000000000000000014",

packages/scripts/src/addOrbitChain/tests/network.ts

@@ -0,0 +1,91 @@
+import {
+  fetchRollupContractData,
+  getProvider,
+  getRollupContract,
+} from "../network";
+
+describe("Network Functions", () => {
+  it("fetches rollup contract data for an Arbitrum Orbit chain", async () => {
+    const parentChainRpcUrl = "https://sepolia-rollup.arbitrum.io/rpc";
+    const orbitChainRollupAddress =
+      "0xeedE9367Df91913ab149e828BDd6bE336df2c892";
+
+    console.log("Starting test with the following parameters:");
+    console.log("Parent Chain RPC URL:", parentChainRpcUrl);
+    console.log("Orbit Chain Rollup Address:", orbitChainRollupAddress);
+
+    try {
+      // check if we can connect to the provider
+      const provider = await getProvider(parentChainRpcUrl);
+      const network = await provider.getNetwork();
+      console.log(
+        "Connected to network:",
+        network.name,
+        "chainId:",
+        network.chainId
+      );
+
+      // check if the contract exists
+      const code = await provider.getCode(orbitChainRollupAddress);
+      if (code === "0x") {
+        throw new Error("No contract found at the given address");
+      }
+      console.log("Contract found at the given address");
+
+      // ry to interact with the contract
+      const contract = await getRollupContract(
+        orbitChainRollupAddress,
+        provider
+      );
+
+      // try to call each method individually and log the result
+      for (const method of [
+        "bridge",
+        "inbox",
+        "sequencerInbox",
+        "outbox",
+        "confirmPeriodBlocks",
+      ]) {
+        try {
+          const result = await contract[method]();
+          console.log(`${method}() call successful:`, result);
+        } catch (error) {
+          console.error(`Error calling ${method}():`, error);
+        }
+      }
+
+      const rollupData = await fetchRollupContractData(
+        orbitChainRollupAddress,
+        parentChainRpcUrl
+      );
+
+      // Log the fetched data
+      console.log(
+        "Fetched Rollup Contract Data:",
+        JSON.stringify(rollupData, null, 2)
+      );
+
+      // Assertions to verify the structure and content of the fetched data
+      expect(rollupData).toHaveProperty("bridge");
+      expect(rollupData).toHaveProperty("inbox");
+      expect(rollupData).toHaveProperty("sequencerInbox");
+      expect(rollupData).toHaveProperty("outbox");
+      expect(rollupData).toHaveProperty("confirmPeriodBlocks");
+
+      // Check that the addresses are valid Ethereum addresses
+      const addressRegex = /^0x[a-fA-F0-9]{40}$/;
+      expect(rollupData.bridge).toMatch(addressRegex);
+      expect(rollupData.inbox).toMatch(addressRegex);
+      expect(rollupData.sequencerInbox).toMatch(addressRegex);
+      expect(rollupData.outbox).toMatch(addressRegex);
+
+      // Check that confirmPeriodBlocks is a positive number
+      expect(rollupData.confirmPeriodBlocks).toBeGreaterThan(0);
+
+      console.log("All assertions passed successfully");
+    } catch (error) {
+      console.error("Test failed with error:", error);
+      throw error;
+    }
+  }, 30000); // Increase timeout to 30 seconds for network calls
+});

packages/scripts/src/addOrbitChain/tests/transforms.test.ts

@@ -25,11 +25,11 @@ describe("Transforms", () => {
   });
 
   describe("transformIncomingDataToOrbitChain", () => {
-    it("should transform incoming chain data to OrbitChain format", () => {
+    it("should transform incoming chain data to OrbitChain format", async () => {
       const chainLogoPath = "/images/mockChain_Logo.png";
       const nativeTokenLogoPath = "/images/mockChain_NativeTokenLogo.png";
 
-      const result = transformIncomingDataToOrbitChain(
+      const result = await transformIncomingDataToOrbitChain(
         mockIncomingChainData as IncomingChainData,
         chainLogoPath,
         nativeTokenLogoPath

packages/scripts/src/addOrbitChain/transforms.ts

@@ -14,6 +14,7 @@ import {
   getIssue,
   updateContent,
 } from "./github";
+import { fetchRollupContractData } from "./network";
 import {
   chainDataLabelToKey,
   IncomingChainData,
@@ -116,7 +117,7 @@ export const createAndValidateOrbitChain = async (
 ) => {
   core.startGroup("Orbit Chain Creation and Validation");
   console.log("Creating OrbitChain object...");
-  const orbitChain = transformIncomingDataToOrbitChain(
+  const orbitChain = await transformIncomingDataToOrbitChain(
     validatedIncomingData,
     chainLogoPath,
     nativeTokenLogoPath
@@ -129,7 +130,7 @@ export const createAndValidateOrbitChain = async (
 };
 
 export const updateAndValidateOrbitChainsList = async (
-  orbitChain: ReturnType<typeof transformIncomingDataToOrbitChain>,
+  orbitChain: OrbitChain,
   targetJsonPath: string
 ) => {
   core.startGroup("Orbit ChainsList Update and Validation");
@@ -151,7 +152,7 @@ export const commitChangesAndCreatePR = async (
   branchName: string,
   targetJsonPath: string,
   updatedOrbitChainsList: ReturnType<typeof updateOrbitChainsFile>,
-  orbitChain: ReturnType<typeof transformIncomingDataToOrbitChain>
+  orbitChain: OrbitChain
 ) => {
   core.startGroup("Commit Changes and Create Pull Request");
   console.log("Preparing to commit changes...");
@@ -170,7 +171,7 @@ export const commitChangesAndCreatePR = async (
 
 export const setOutputs = (
   branchName: string,
-  orbitChain: ReturnType<typeof transformIncomingDataToOrbitChain>,
+  orbitChain: OrbitChain,
   targetJsonPath: string
 ) => {
   core.startGroup("Set Outputs");
@@ -279,23 +280,29 @@ export const fetchAndSaveImage = async (
   return `/${imageSavePath}`;
 };
 
-export const transformIncomingDataToOrbitChain = (
+export const transformIncomingDataToOrbitChain = async (
   chainData: IncomingChainData,
   chainLogoPath: string,
   nativeTokenLogoPath?: string
-): OrbitChain => {
+): Promise<OrbitChain> => {
   const parentChainId = parseInt(chainData.parentChainId, 10);
   const isTestnet = TESTNET_PARENT_CHAIN_IDS.includes(parentChainId);
 
+  // Fetch rollup contract data
+  const rollupData = await fetchRollupContractData(
+    chainData.rollup,
+    chainData.rpcUrl
+  );
+
   return {
     chainId: parseInt(chainData.chainId, 10),
-    confirmPeriodBlocks: parseInt(chainData.confirmPeriodBlocks, 10),
+    confirmPeriodBlocks: rollupData.confirmPeriodBlocks,
     ethBridge: {
-      bridge: chainData.bridge,
-      inbox: chainData.inbox,
-      outbox: chainData.outbox,
+      bridge: rollupData.bridge,
+      inbox: rollupData.inbox,
+      outbox: rollupData.outbox,
       rollup: chainData.rollup,
-      sequencerInbox: chainData.sequencerInbox,
+      sequencerInbox: rollupData.sequencerInbox,
     },
     nativeToken: chainData.nativeTokenAddress,
     explorerUrl: chainData.explorerUrl,