feat: add arb owner and arb gas info actions

src/arbGasInfoReadContract.ts

@@ -0,0 +1,30 @@
+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<
+  TChain extends Chain | undefined,
+  TFunctionName extends ArbGasInfoFunctionName,
+>(
+  client: PublicClient<Transport, TChain>,
+  params: ArbGasInfoReadContractParameters<TFunctionName>,
+): Promise<ArbGasInfoReadContractReturnType<TFunctionName>> {
+  // @ts-ignore (todo: fix viem type issue)
+  return client.readContract({
+    address: arbGasInfo.address,
+    abi: arbGasInfo.abi,
+    functionName: params.functionName,
+    args: params.args,
+  });
+}

src/arbOwnerPrepareTransactionRequest.ts

@@ -0,0 +1,81 @@
+import {
+  PublicClient,
+  encodeFunctionData,
+  EncodeFunctionDataParameters,
+  Address,
+  Chain,
+  Transport,
+} from 'viem';
+
+import { arbOwner } from './contracts';
+import { upgradeExecutorEncodeFunctionData } from './upgradeExecutor';
+import { 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 (todo: fix viem type issue)
+  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,30 @@
+import { Chain, 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<
+  TChain extends Chain | undefined,
+  TFunctionName extends ArbOwnerPublicFunctionName,
+>(
+  client: PublicClient<Transport, TChain>,
+  params: ArbOwnerReadContractParameters<TFunctionName>,
+): Promise<ArbOwnerReadContractReturnType<TFunctionName>> {
+  // @ts-ignore (todo: fix viem type issue)
+  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,23 @@
+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 {
+    arbGasInfoReadContract: (args) => arbGasInfoReadContract(client, args),
+  };
+}

src/decorators/arbOwnerPublicActions.integration.test.ts

@@ -0,0 +1,122 @@
+import { it, expect } from 'vitest';
+import { createPublicClient, http } from 'viem';
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
+
+import { nitroTestnodeL2 } from '../chains';
+import { arbOwnerPublicActions } from './arbOwnerPublicActions';
+import { getNitroTestnodePrivateKeyAccounts } from '../testHelpers';
+
+// l2 owner private key
+const devPrivateKey = getNitroTestnodePrivateKeyAccounts().l2RollupOwner.privateKey;
+
+const owner = privateKeyToAccount(devPrivateKey);
+const randomAccount = privateKeyToAccount(generatePrivateKey());
+
+const client = createPublicClient({
+  chain: nitroTestnodeL2,
+  transport: http(),
+}).extend(arbOwnerPublicActions);
+
+it('successfully fetches network fee receiver', async () => {
+  const result = await client.arbOwnerReadContract({
+    functionName: 'getNetworkFeeAccount',
+  });
+
+  expect(result).toEqual(owner.address);
+});
+
+it('succesfully fetches chain owners', async () => {
+  const result = await client.arbOwnerReadContract({
+    functionName: 'getAllChainOwners',
+  });
+
+  expect(result).toContain(owner.address);
+});
+
+it('succesfully adds chain owner', async () => {
+  const isOwnerInitially = await client.arbOwnerReadContract({
+    functionName: 'isChainOwner',
+    args: [randomAccount.address],
+  });
+
+  // assert account is not already an owner
+  expect(isOwnerInitially).toEqual(false);
+
+  const transactionRequest = await client.arbOwnerPrepareTransactionRequest({
+    functionName: 'addChainOwner',
+    args: [randomAccount.address],
+    upgradeExecutor: false,
+    account: owner.address,
+  });
+
+  // submit tx to add chain owner
+  await client.sendRawTransaction({
+    serializedTransaction: await owner.signTransaction(transactionRequest),
+  });
+
+  const isOwner = await client.arbOwnerReadContract({
+    functionName: 'isChainOwner',
+    args: [randomAccount.address],
+  });
+
+  // assert account is now owner
+  expect(isOwner).toEqual(true);
+});
+
+it('succesfully removes chain owner', async () => {
+  const isOwnerInitially = await client.arbOwnerReadContract({
+    functionName: 'isChainOwner',
+    args: [randomAccount.address],
+  });
+
+  // assert account is an owner
+  expect(isOwnerInitially).toEqual(true);
+
+  const transactionRequest = await client.arbOwnerPrepareTransactionRequest({
+    functionName: 'removeChainOwner',
+    args: [randomAccount.address],
+    upgradeExecutor: false,
+    account: owner.address,
+  });
+
+  // submit tx to remove chain owner
+  await client.sendRawTransaction({
+    serializedTransaction: await owner.signTransaction(transactionRequest),
+  });
+
+  const isOwner = await client.arbOwnerReadContract({
+    functionName: 'isChainOwner',
+    args: [randomAccount.address],
+  });
+
+  // assert account is no longer chain owner
+  expect(isOwner).toEqual(false);
+});
+
+it('succesfully updates infra fee receiver', async () => {
+  const initialInfraFeeReceiver = await client.arbOwnerReadContract({
+    functionName: 'getInfraFeeAccount',
+  });
+
+  // assert account is not already infra fee receiver
+  expect(initialInfraFeeReceiver).not.toEqual(randomAccount.address);
+
+  const transactionRequest = await client.arbOwnerPrepareTransactionRequest({
+    functionName: 'setInfraFeeAccount',
+    args: [randomAccount.address],
+    upgradeExecutor: false,
+    account: owner.address,
+  });
+
+  // submit tx to update infra fee receiver
+  await client.sendRawTransaction({
+    serializedTransaction: await owner.signTransaction(transactionRequest),
+  });
+
+  const infraFeeReceiver = await client.arbOwnerReadContract({
+    functionName: 'getInfraFeeAccount',
+  });
+
+  // assert account is now infra fee receiver
+  expect(infraFeeReceiver).toEqual(randomAccount.address);
+});

src/decorators/arbOwnerPublicActions.ts

@@ -0,0 +1,33 @@
+import { Transport, Chain, PrepareTransactionRequestReturnType, PublicClient } from 'viem';
+
+import {
+  arbOwnerReadContract,
+  ArbOwnerPublicFunctionName,
+  ArbOwnerReadContractParameters,
+  ArbOwnerReadContractReturnType,
+} from '../arbOwnerReadContract';
+import {
+  arbOwnerPrepareTransactionRequest,
+  ArbOwnerPrepareTransactionRequestParameters,
+} from '../arbOwnerPrepareTransactionRequest';
+
+export type ArbOwnerPublicActions<TChain extends Chain | undefined = Chain | undefined> = {
+  arbOwnerReadContract: <TFunctionName extends ArbOwnerPublicFunctionName>(
+    args: ArbOwnerReadContractParameters<TFunctionName>,
+  ) => Promise<ArbOwnerReadContractReturnType<TFunctionName>>;
+
+  arbOwnerPrepareTransactionRequest: (
+    args: ArbOwnerPrepareTransactionRequestParameters,
+  ) => Promise<PrepareTransactionRequestReturnType<TChain> & { chainId: number }>;
+};
+
+export function arbOwnerPublicActions<
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+>(client: PublicClient<TTransport, TChain>): ArbOwnerPublicActions<TChain> {
+  return {
+    arbOwnerReadContract: (args) => arbOwnerReadContract(client, args),
+
+    arbOwnerPrepareTransactionRequest: (args) => arbOwnerPrepareTransactionRequest(client, args),
+  };
+}