feat: support 3.2.0 upgrade action

src/getNitroContractVersions.ts

@@ -1,6 +1,7 @@
 import type { Address } from 'viem';
 
 import { runChainVersioner } from '@arbitrum/chain-actions';
+import { verifyFoundryBinaries } from './utils/verifyFoundry';
 
 export type GetNitroContractVersionsResult = {
   versions: Record<string, string | null>;
@@ -37,6 +38,8 @@ export async function getNitroContractVersions(
   inboxAddress: Address,
   parentChainRpc: string,
 ): Promise<GetNitroContractVersionsResult> {
+  await verifyFoundryBinaries();
+
   const result = await runChainVersioner(inboxAddress, parentChainRpc, true);
 
   return parseNitroContractVersionsResult(result);

src/index.ts

@@ -207,6 +207,15 @@ import {
 } from './utils/erc20';
 import { prepareArbitrumNetwork } from './utils/registerNewNetwork';
 import { getNitroContractVersions } from './getNitroContractVersions';
+import {
+  NitroContractsUpgradeVersion,
+  DeployNitroContractsUpgradeActionParameters,
+  ExecuteNitroContractsUpgradeParameters,
+  VerifyNitroContractsUpgradeParameters,
+  deployNitroContractsUpgradeAction,
+  executeNitroContractsUpgrade,
+  verifyNitroContractsUpgrade,
+} from './nitroContractsUpgrade';
 
 export {
   arbOwnerPublicActions,
@@ -383,6 +392,13 @@ export {
   prepareArbitrumNetwork,
   //
   getNitroContractVersions,
+  NitroContractsUpgradeVersion,
+  deployNitroContractsUpgradeAction,
+  DeployNitroContractsUpgradeActionParameters,
+  executeNitroContractsUpgrade,
+  ExecuteNitroContractsUpgradeParameters,
+  verifyNitroContractsUpgrade,
+  VerifyNitroContractsUpgradeParameters,
 };
 
 export * from './scripting/scriptUtils';

src/nitroContractsUpgrade.ts

@@ -0,0 +1,97 @@
+import { dirname, resolve } from 'node:path';
+
+import type { Address } from 'viem';
+
+import { runForgeScript, type RunForgeScriptResult } from './utils/runForgeScript';
+
+export enum NitroContractsUpgradeVersion {
+  V3_2_0 = '3.2.0',
+}
+
+export type DeployNitroContractsUpgradeActionParameters = {
+  version: NitroContractsUpgradeVersion;
+  parentChainRpcUrl: string;
+  forgeArgs?: string[];
+};
+
+export type ExecuteNitroContractsUpgradeParameters = DeployNitroContractsUpgradeActionParameters & {
+  rollupAddress: Address;
+  parentUpgradeExecutorAddress: Address;
+  upgradeActionAddress: Address;
+};
+
+export type VerifyNitroContractsUpgradeParameters = DeployNitroContractsUpgradeActionParameters & {
+  rollupAddress: Address;
+};
+
+type UpgradeOperation = 'Deploy' | 'Execute' | 'Verify';
+
+const upgradeScripts = {
+  [NitroContractsUpgradeVersion.V3_2_0]: {
+    Deploy: require.resolve(
+      '@arbitrum/chain-actions/scripts/foundry/contract-upgrades/3.2.0/DeployNitroContracts3Point2Point0UpgradeAction.s.sol',
+    ),
+    Execute: require.resolve(
+      '@arbitrum/chain-actions/scripts/foundry/contract-upgrades/3.2.0/ExecuteNitroContracts3Point2Point0Upgrade.s.sol',
+    ),
+    Verify: require.resolve(
+      '@arbitrum/chain-actions/scripts/foundry/contract-upgrades/3.2.0/VerifyNitroContracts3Point2Point0Upgrade.s.sol',
+    ),
+  },
+} satisfies Record<NitroContractsUpgradeVersion, Record<UpgradeOperation, string>>;
+
+function runUpgradeScript(
+  operation: UpgradeOperation,
+  params: DeployNitroContractsUpgradeActionParameters,
+  scriptEnvironment: Record<string, string> = {},
+): Promise<RunForgeScriptResult> {
+  const chainActionsRoot = resolve(dirname(require.resolve('@arbitrum/chain-actions')), '../../..');
+  const upgradeExecutorRoot = resolve(
+    dirname(
+      require.resolve('@offchainlabs/upgrade-executor/src/IUpgradeExecutor.sol', {
+        paths: [chainActionsRoot],
+      }),
+    ),
+    '..',
+  );
+
+  return runForgeScript({
+    script: upgradeScripts[params.version][operation],
+    rpcUrl: params.parentChainRpcUrl,
+    forgeArgs: [
+      '--root',
+      chainActionsRoot,
+      '--remappings',
+      `@offchainlabs/upgrade-executor/=${upgradeExecutorRoot}/`,
+      ...(params.forgeArgs ?? []),
+    ],
+    env: scriptEnvironment,
+  });
+}
+
+/** Deploys the upgrade action for a Nitro contracts version. */
+export function deployNitroContractsUpgradeAction(
+  params: DeployNitroContractsUpgradeActionParameters,
+): Promise<RunForgeScriptResult> {
+  return runUpgradeScript('Deploy', params);
+}
+
+/** Executes a Nitro contracts upgrade through the parent chain UpgradeExecutor. */
+export function executeNitroContractsUpgrade(
+  params: ExecuteNitroContractsUpgradeParameters,
+): Promise<RunForgeScriptResult> {
+  return runUpgradeScript('Execute', params, {
+    ROLLUP_ADDRESS: params.rollupAddress,
+    PARENT_UPGRADE_EXECUTOR_ADDRESS: params.parentUpgradeExecutorAddress,
+    UPGRADE_ACTION_ADDRESS: params.upgradeActionAddress,
+  });
+}
+
+/** Verifies that a Nitro contracts upgrade was applied to the rollup. */
+export function verifyNitroContractsUpgrade(
+  params: VerifyNitroContractsUpgradeParameters,
+): Promise<RunForgeScriptResult> {
+  return runUpgradeScript('Verify', params, {
+    ROLLUP_ADDRESS: params.rollupAddress,
+  });
+}

src/scripting/commands.ts

@@ -130,8 +130,8 @@ import {
   schema as deployFullChainSchema,
   execute as deployFullChainExecute,
 } from './workflows/deployFullChain';
-import { getChainContractVersions } from '../getChainContractVersions';
-import { getChainContractVersionsSchema } from './schemas/getChainContractVersions';
+import { getNitroContractVersions } from '../getNitroContractVersions';
+import { getNitroContractVersionsSchema } from './schemas/getNitroContractVersions';
 
 import { contractRegistry } from './contractRegistry';
 import { buildContractCommandSchema } from './contractCommandSchema';
@@ -368,5 +368,5 @@ export const commands: readonly Command[] = [
   ),
 
   ...contractCommands,
-  command('getChainContractVersions', getChainContractVersionsSchema, getChainContractVersions),
+  command('getNitroContractVersions', getNitroContractVersionsSchema, getNitroContractVersions),
 ];

src/scripting/schemaCoverage.ts

@@ -407,8 +407,8 @@ vi.mock('viem', async (importOriginal) => {
   };
 });
 
-vi.mock('../getChainContractVersions', () => ({
-  getChainContractVersions: _mocks.fn('getChainContractVersions'),
+vi.mock('../getNitroContractVersions', () => ({
+  getNitroContractVersions: _mocks.fn('getNitroContractVersions'),
 }));
 /**
  * A testable leaf of a schema -- a scalar field the harness will vary when

src/scripting/schemas/getChainContractVersions.ts → src/scripting/schemas/getNitroContractVersions.ts

@@ -1,16 +1,16 @@
 import { z } from 'zod';
 
-import { getChainContractVersions } from '../../getChainContractVersions';
+import { getNitroContractVersions } from '../../getNitroContractVersions';
 import { addressSchema } from './common';
 
-export const getChainContractVersionsSchema = z
+export const getNitroContractVersionsSchema = z
   .object({
     inboxAddress: addressSchema,
     parentChainRpc: z.url(),
   })
   .strict()
   .transform(
-    (input): Parameters<typeof getChainContractVersions> => [
+    (input): Parameters<typeof getNitroContractVersions> => [
       input.inboxAddress,
       input.parentChainRpc,
     ],

src/scripting/schemas/index.ts

@@ -81,4 +81,4 @@ export {
   isAllowListEnabledSchema,
   isAllowedSchema,
 } from './actions';
-export { getChainContractVersionsSchema } from './getChainContractVersions';
+export { getNitroContractVersionsSchema } from './getNitroContractVersions';

src/utils/runForgeScript.ts

@@ -0,0 +1,84 @@
+import { spawn } from 'node:child_process';
+
+import { verifyFoundryBinaries } from './verifyFoundry';
+
+export type RunForgeScriptParameters = {
+  script: string;
+  rpcUrl: string;
+  cwd?: string;
+  forgeArgs?: string[];
+  env?: Record<string, string | undefined>;
+};
+
+export type RunForgeScriptResult = {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+};
+
+/** Runs a Forge script after verifying that Foundry is installed. */
+export async function runForgeScript({
+  script,
+  rpcUrl,
+  cwd,
+  forgeArgs = [],
+  env = {},
+}: RunForgeScriptParameters): Promise<RunForgeScriptResult> {
+  await verifyFoundryBinaries();
+
+  const args = ['script', script, '--rpc-url', rpcUrl, ...forgeArgs];
+  const environment = {
+    ...process.env,
+    ...Object.fromEntries(
+      Object.entries(env).filter((entry): entry is [string, string] => entry[1] !== undefined),
+    ),
+  };
+
+  return new Promise((resolve, reject) => {
+    const child = spawn('forge', args, {
+      cwd,
+      env: environment,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', (chunk: string) => {
+      stdout += chunk;
+    });
+    child.stderr.on('data', (chunk: string) => {
+      stderr += chunk;
+    });
+
+    child.once('error', (cause) => {
+      reject(
+        Object.assign(new Error(`Unable to start Forge script: ${cause.message}`), {
+          name: 'RunForgeScriptError',
+          stdout,
+          stderr,
+          exitCode: 1,
+          cause,
+        }),
+      );
+    });
+
+    child.once('close', (exitCode, signal) => {
+      if (exitCode !== 0) {
+        const reason = signal ? `signal ${signal}` : `exit code ${exitCode ?? 1}`;
+        reject(
+          Object.assign(new Error(`Forge script failed with ${reason}`), {
+            name: 'RunForgeScriptError',
+            stdout,
+            stderr,
+            exitCode: exitCode ?? 1,
+          }),
+        );
+        return;
+      }
+
+      resolve({ stdout, stderr, exitCode });
+    });
+  });
+}