feat: add arb owner and arb gas info actions

.github/workflows/build-test.yml

@@ -62,6 +62,46 @@ jobs:
       - name: Test
         run: yarn test:unit
 
+  test-integration:
+    name: Test (Integration)
+    runs-on: ubuntu-latest
+    needs: install
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18
+
+      - name: Restore node_modules
+        uses: OffchainLabs/actions/node-modules/restore@main
+
+      - name: Set up the local node
+        uses: OffchainLabs/actions/run-nitro-test-node@main
+
+      - name: Generate
+        run: yarn generate
+        with:
+          nitro-testnode-ref: transfer-ownership
+          # Use simple mode
+          no-simple: false
+          # RollupCreator on L1 is deployed by default
+          # RollupCreator on L2 is deployed with --l3node
+          l3-node: true
+          # L3 node with custom fee token when using --l3-fee-token
+          args: --l3-fee-token
+
+      - name: Copy .env
+        run: cp ./.env.example ./.env
+
+      - name: Build
+        run: yarn build
+
+      - name: Test
+        run: yarn test:integration
+
   test-integration:
     name: Test (Integration)
     runs-on: ubuntu-latest

examples/arb-owner/index.ts

@@ -0,0 +1,120 @@
+import { Chain, createPublicClient, http } from 'viem';
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
+import { arbitrumSepolia } from 'viem/chains';
+import {
+  createRollupPrepareConfig,
+  prepareChainConfig,
+  createRollupPrepareTransactionRequest,
+  createRollupPrepareTransactionReceipt,
+  arbOwnerPublicActions,
+} from '@arbitrum/orbit-sdk';
+import { generateChainId } from '@arbitrum/orbit-sdk/utils';
+
+function sanitizePrivateKey(privateKey: string): `0x${string}` {
+  if (!privateKey.startsWith('0x')) {
+    return `0x${privateKey}`;
+  }
+
+  return privateKey as `0x${string}`;
+}
+
+function withFallbackPrivateKey(privateKey: string | undefined): `0x${string}` {
+  if (typeof privateKey === 'undefined') {
+    return generatePrivateKey();
+  }
+
+  return sanitizePrivateKey(privateKey);
+}
+
+function getBlockExplorerUrl(chain: Chain) {
+  return chain.blockExplorers?.default.url;
+}
+
+if (typeof process.env.DEPLOYER_PRIVATE_KEY === 'undefined') {
+  throw new Error(
+    `Please provide the "DEPLOYER_PRIVATE_KEY" environment variable`
+  );
+}
+
+// load or generate a random batch poster account
+const batchPosterPrivateKey = withFallbackPrivateKey(
+  process.env.BATCH_POSTER_PRIVATE_KEY
+);
+const batchPoster = privateKeyToAccount(batchPosterPrivateKey).address;
+
+// load or generate a random validator account
+const validatorPrivateKey = withFallbackPrivateKey(
+  process.env.VALIDATOR_PRIVATE_KEY
+);
+const validator = privateKeyToAccount(validatorPrivateKey).address;
+
+// set the parent chain and create a public client for it
+const parentChain = arbitrumSepolia;
+const publicClient = createPublicClient({
+  chain: parentChain,
+  transport: http(),
+}).extend(arbOwnerPublicActions);
+
+// load the deployer account
+const deployer = privateKeyToAccount(
+  sanitizePrivateKey(process.env.DEPLOYER_PRIVATE_KEY)
+);
+
+async function main() {
+  const publicClient = createPublicClient({
+    chain: arbitrumSepolia,
+    transport: http(),
+  }).extend(arbOwnerPublicActions);
+
+  publicClient.arbOwnerPrepareTransactionRequest({
+    functionName: 'setL1BaseFeeEstimateInertia',
+    args: [BigInt(0)],
+    account: deployer.address,
+  });
+
+  // generate a random chain id
+  const chainId = generateChainId();
+
+  // create the chain config
+  const chainConfig = prepareChainConfig({
+    chainId,
+    arbitrum: {
+      InitialChainOwner: deployer.address,
+      DataAvailabilityCommittee: true,
+    },
+  });
+
+  // prepare the transaction for deploying the core contracts
+  const request = await createRollupPrepareTransactionRequest({
+    params: {
+      config: createRollupPrepareConfig({
+        chainId: BigInt(chainId),
+        owner: deployer.address,
+        chainConfig,
+      }),
+      batchPoster,
+      validators: [validator],
+      nativeToken: '0xf861378b543525ae0c47d33c90c954dc774ac1f9', // $ARB
+    },
+    account: deployer.address,
+    publicClient: publicClient,
+  });
+
+  // sign and send the transaction
+  const txHash = await publicClient.sendRawTransaction({
+    serializedTransaction: await deployer.signTransaction(request),
+  });
+
+  // get the transaction receipt after waiting for the transaction to complete
+  const txReceipt = createRollupPrepareTransactionReceipt(
+    await publicClient.waitForTransactionReceipt({ hash: txHash })
+  );
+
+  console.log(
+    `Deployed in ${getBlockExplorerUrl(parentChain)}/tx/${
+      txReceipt.transactionHash
+    }`
+  );
+}
+
+main();

examples/arb-owner/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "arb-owner",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "tsc --outDir dist && node ./dist/index.js"
+  },
+  "devDependencies": {
+    "@types/node": "^20.9.0",
+    "typescript": "^5.2.2"
+  }
+}

examples/arb-owner/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../tsconfig.base.json",
+  "include": ["./**/*"]
+}

src/arbGasInfoReadContract.ts

@@ -0,0 +1,29 @@
+import { Chain, GetFunctionArgs, PublicClient, ReadContractReturnType, Transport } from 'viem';
+
+import { arbGasInfo } from './contracts';
+import { GetFunctionName } from './types/utils';
+
+export type ArbGasInfoAbi = typeof arbGasInfo.abi;
+export type ArbGasInfoFunctionName = GetFunctionName<ArbGasInfoAbi>;
+
+export type ArbGasInfoReadContractParameters<TFunctionName extends ArbGasInfoFunctionName> = {
+  functionName: TFunctionName;
+} & GetFunctionArgs<ArbGasInfoAbi, TFunctionName>;
+
+export type ArbGasInfoReadContractReturnType<TFunctionName extends ArbGasInfoFunctionName> =
+  ReadContractReturnType<ArbGasInfoAbi, TFunctionName>;
+
+export function arbGasInfoReadContract<TFunctionName extends ArbGasInfoFunctionName>(
+  client: PublicClient<Transport>,
+  params: ArbGasInfoReadContractParameters<TFunctionName>,
+): Promise<ArbGasInfoReadContractReturnType<TFunctionName>> {
+  //
+  // todo: fix this weird type issue
+  // @ts-ignore
+  return client.readContract({
+    address: arbGasInfo.address,
+    abi: arbGasInfo.abi,
+    functionName: params.functionName,
+    args: params.args,
+  });
+}

src/arbOwnerPrepareTransactionRequest.ts

@@ -0,0 +1,91 @@
+import {
+  PublicClient,
+  encodeFunctionData,
+  EncodeFunctionDataParameters,
+  Address,
+  PrepareTransactionRequestReturnType,
+  zeroAddress,
+  Chain,
+  Transport,
+  Abi,
+} from 'viem';
+
+import { arbOwner } from './contracts';
+import { upgradeExecutorEncodeFunctionData } from './upgradeExecutor';
+import { GetFunctionName, Prettify } from './types/utils';
+
+type ArbOwnerEncodeFunctionDataParameters = Prettify<
+  Omit<EncodeFunctionDataParameters<typeof arbOwner.abi, string>, 'abi'>
+>;
+
+function arbOwnerEncodeFunctionData({
+  functionName,
+  args,
+}: ArbOwnerEncodeFunctionDataParameters) {
+  return encodeFunctionData({
+    abi: arbOwner.abi,
+    functionName,
+    args,
+  });
+}
+
+function arbOwnerPrepareFunctionData(
+  params: ArbOwnerEncodeFunctionDataParameters & {
+    upgradeExecutor: Address | false;
+  }
+) {
+  const { upgradeExecutor } = params;
+
+  if (!upgradeExecutor) {
+    return {
+      to: arbOwner.address,
+      data: arbOwnerEncodeFunctionData(params),
+      value: BigInt(0),
+    };
+  }
+
+  return {
+    to: upgradeExecutor,
+    data: upgradeExecutorEncodeFunctionData({
+      functionName: 'executeCall',
+      args: [
+        arbOwner.address, // target
+        arbOwnerEncodeFunctionData(params), // targetCallData
+      ],
+    }),
+    value: BigInt(0),
+  };
+}
+
+export type ArbOwnerPrepareTransactionRequestParameters = Prettify<
+  ArbOwnerEncodeFunctionDataParameters & {
+    upgradeExecutor: Address | false;
+    account: Address;
+  }
+>;
+
+export async function arbOwnerPrepareTransactionRequest<
+  TChain extends Chain | undefined
+>(
+  client: PublicClient<Transport, TChain>,
+  params: ArbOwnerPrepareTransactionRequestParameters
+) {
+  if (typeof client.chain === 'undefined') {
+    throw new Error(
+      '[arbOwnerPrepareTransactionRequest] client.chain is undefined'
+    );
+  }
+
+  const { to, data, value } = arbOwnerPrepareFunctionData(params);
+
+  //@ts-ignore
+  const request = await client.prepareTransactionRequest({
+    chain: client.chain,
+    to,
+    data,
+    value,
+    account: params.account,
+  });
+
+  return { ...request, chainId: client.chain.id };
+}

src/arbOwnerReadContract.ts

@@ -0,0 +1,39 @@
+import {
+  GetFunctionArgs,
+  PublicClient,
+  ReadContractReturnType,
+  Transport,
+} from 'viem';
+
+import { arbOwnerPublic } from './contracts';
+import { GetFunctionName } from './types/utils';
+
+export type ArbOwnerPublicAbi = typeof arbOwnerPublic.abi;
+export type ArbOwnerPublicFunctionName = GetFunctionName<ArbOwnerPublicAbi>;
+
+export type ArbOwnerReadContractParameters<
+  TFunctionName extends ArbOwnerPublicFunctionName
+> = {
+  functionName: TFunctionName;
+} & GetFunctionArgs<ArbOwnerPublicAbi, TFunctionName>;
+
+export type ArbOwnerReadContractReturnType<
+  TFunctionName extends ArbOwnerPublicFunctionName
+> = ReadContractReturnType<ArbOwnerPublicAbi, TFunctionName>;
+
+export function arbOwnerReadContract<
+  TFunctionName extends ArbOwnerPublicFunctionName
+>(
+  client: PublicClient<Transport>,
+  params: ArbOwnerReadContractParameters<TFunctionName>
+): Promise<ArbOwnerReadContractReturnType<TFunctionName>> {
+  //
+  // todo: fix this weird type issue
+  // @ts-ignore
+  return client.readContract({
+    address: arbOwnerPublic.address,
+    abi: arbOwnerPublic.abi,
+    functionName: params.functionName,
+    args: params.args,
+  });
+}

src/contracts.ts

@@ -6,6 +6,7 @@ import {
   arbOwnerPublicConfig,
   rollupCreatorConfig,
   tokenBridgeCreatorConfig,
+  arbGasInfoConfig,
 } from './generated';
 
 export const erc20 = {
@@ -17,6 +18,11 @@ export const arbOwner = {
   address: Object.values(arbOwnerConfig.address)[0],
 } as const;
 
+export const arbGasInfo = {
+  ...arbGasInfoConfig,
+  address: Object.values(arbGasInfoConfig.address)[0],
+} as const;
+
 export const arbOwnerPublic = {
   ...arbOwnerPublicConfig,
   address: Object.values(arbOwnerPublicConfig.address)[0],

src/decorators/arbGasInfoPublicActions.ts

@@ -0,0 +1,24 @@
+import { Transport, Chain, PublicClient } from 'viem';
+
+import {
+  arbGasInfoReadContract,
+  ArbGasInfoFunctionName,
+  ArbGasInfoReadContractParameters,
+  ArbGasInfoReadContractReturnType,
+} from '../arbGasInfoReadContract';
+
+export type ArbGasInfoPublicActions<TChain extends Chain | undefined = Chain | undefined> = {
+  arbGasInfoReadContract: <TFunctionName extends ArbGasInfoFunctionName>(
+    args: ArbGasInfoReadContractParameters<TFunctionName>,
+  ) => Promise<ArbGasInfoReadContractReturnType<TFunctionName>>;
+};
+
+export function arbGasInfoPublicActions<
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+>(client: PublicClient<TTransport, TChain>): ArbGasInfoPublicActions<TChain> {
+  return {
+    // @ts-ignore
+    arbGasInfoReadContract: (args) => arbGasInfoReadContract(client, args),
+  };
+}