Allow actions to be called manually

Author: chrstph-dvx

src/decorators/arbOwnerPublicActions.ts

@@ -24,21 +24,34 @@ export type ArbOwnerPublicActions<
     TFunctionName extends ArbOwnerPublicFunctionName<TArbOsVersion>,
   >(
     args: ArbOwnerPrepareTransactionRequestParameters<TArbOsVersion, TFunctionName>,
-  ) => Promise<PrepareTransactionRequestReturnType<TChain>>;
+  ) => Promise<PrepareTransactionRequestReturnType<TChain> & { chainId: number }>;
 };
 
 const defaultArbOsVersion = 20;
 
-// arbOsVersion is passed as a parameter `client.extend(arbOwnerPublicActions({ arbOsVersion: 10 }))`
+// Client is passed explicitly
+// `arbOwnerPublicActions(client)`, `arbOwnerPublicActions(client, { arbOsVersion: 20 })`
+export function arbOwnerPublicActions<
+  TArbOsVersion extends ArbOSVersions,
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends Account | undefined = Account | undefined,
+>(
+  client: Client<TTransport, TChain, TAccount>,
+  { arbOsVersion }: { arbOsVersion: TArbOsVersion },
+): ArbOwnerPublicActions<TArbOsVersion, TChain>;
+// arbOsVersion is passed as a parameter
+// `client.extend(arbOwnerPublicActions({ arbOsVersion: 10 }))`
 export function arbOwnerPublicActions<
   TArbOsVersion extends ArbOSVersions,
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,
   TAccount extends Account | undefined = Account | undefined,
 >(param: {
   arbOsVersion: TArbOsVersion;
-}): (client: Client) => ArbOwnerPublicActions<TArbOsVersion, TChain>;
-// No parameter are passed `client.extend(arbOwnerPublicActions)`
+}): (client: Client<TTransport, TChain, TAccount>) => ArbOwnerPublicActions<TArbOsVersion, TChain>;
+// No parameter are passed
+// `client.extend(arbOwnerPublicActions)`
 export function arbOwnerPublicActions<
   TArbOsVersion extends ArbOSVersions,
   TTransport extends Transport = Transport,
@@ -52,7 +65,11 @@ export function arbOwnerPublicActions<
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,
   TAccount extends Account | undefined = Account | undefined,
->(paramOrClient: { arbOsVersion: TArbOsVersion } | Client<TTransport, TChain, TAccount>) {
+>(
+  paramOrClient: { arbOsVersion: TArbOsVersion } | Client<TTransport, TChain, TAccount>,
+  options?: { arbOsVersion: TArbOsVersion },
+) {
+  // arbOsVersion is passed as a parameter, return actions with curried arbOsVersion
   if ('arbOsVersion' in paramOrClient) {
     const result: (
       client: Client<TTransport, TChain, TAccount>,
@@ -70,15 +87,24 @@ export function arbOwnerPublicActions<
     return result;
   }
 
-  const result: ArbOwnerPublicActions<typeof defaultArbOsVersion, TChain> = {
+  /**
+   * Parameter is a client, we either have:
+   * - client.extend(arbOwnerPublicActions)
+   * - arbOwnerPublicActions(client)
+   * - arbOwnerPublicActions(client, { arbOsVersion: X })
+   *
+   * If we don't have arbOsVersion (the 2 first cases), default the version to defaultArbOsVersion
+   */
+  const version = options?.arbOsVersion ?? defaultArbOsVersion;
+  const result: ArbOwnerPublicActions<typeof version, TChain> = {
     arbOwnerReadContract: (args) =>
       // @ts-ignore (todo: fix viem type issue)
-      arbOwnerReadContract(paramOrClient, { ...args, arbOsVersion: defaultArbOsVersion }),
+      arbOwnerReadContract(paramOrClient, { ...args, arbOsVersion: version }),
     arbOwnerPrepareTransactionRequest: (args) =>
       // @ts-ignore (todo: fix viem type issue)
       arbOwnerPrepareTransactionRequest(paramOrClient, {
         ...args,
-        arbOsVersion: defaultArbOsVersion,
+        arbOsVersion: version,
       }),
   };
   return result;

src/decorators/arbOwnerPublicActions.unit.test.ts

@@ -24,8 +24,15 @@ const client20 = createPublicClient({
 const randomAccount = privateKeyToAccount(generatePrivateKey());
 const upgradeExecutorAddress = '0x24198F8A339cd3C47AEa3A764A20d2dDaB4D1b5b';
 
+const client = createPublicClient({
+  chain: nitroTestnodeL2,
+  transport: http(),
+});
+const actionsWithVersion = arbOwnerPublicActions(client, { arbOsVersion: 11 });
+const actionsWithDefaultVersion = arbOwnerPublicActions(client);
+
 describe('Accept function name based on arbOSVersion', async () => {
-  it('Version 10', () => {
+  it('Client with actions (version 10)', () => {
     expectTypeOf<typeof client10.arbOwnerReadContract<'onlyOnArbOS10'>>().toBeCallableWith({
       functionName: 'onlyOnArbOS10',
     });
@@ -46,7 +53,7 @@ describe('Accept function name based on arbOSVersion', async () => {
       }),
     ).rejects.toThrowError(AbiFunctionNotFoundError);
   });
-  it('Version 11', () => {
+  it('Client with actions (version 11)', () => {
     expectTypeOf<typeof client11.arbOwnerReadContract<'onlyOnArbOS11'>>().toBeCallableWith({
       functionName: 'onlyOnArbOS11',
     });
@@ -67,7 +74,7 @@ describe('Accept function name based on arbOSVersion', async () => {
       }),
     ).rejects.toThrowError(AbiFunctionNotFoundError);
   });
-  it('Version 20', () => {
+  it('Client with actions (version 20)', () => {
     expectTypeOf<typeof client20.arbOwnerReadContract<'getInfraFeeAccount'>>().toBeCallableWith({
       functionName: 'getInfraFeeAccount',
     });
@@ -88,7 +95,7 @@ describe('Accept function name based on arbOSVersion', async () => {
       }),
     ).rejects.toThrowError(AbiFunctionNotFoundError);
   });
-  it('Default version (20)', () => {
+  it('Client with actions (default version)', () => {
     // arbOwnerPublicActions without params is defaulted to arbOsVersion 20
     expectTypeOf<
       typeof clientWithoutParam.arbOwnerReadContract<'getInfraFeeAccount'>
@@ -112,37 +119,97 @@ describe('Accept function name based on arbOSVersion', async () => {
       }),
     ).rejects.toThrowError(AbiFunctionNotFoundError);
   });
+  it('Standalone actions (version 11) ', () => {
+    expectTypeOf<
+      typeof actionsWithVersion.arbOwnerReadContract<'onlyOnArbOS11'>
+    >().toBeCallableWith({
+      functionName: 'onlyOnArbOS11',
+    });
+
+    expectTypeOf<
+      typeof actionsWithVersion.arbOwnerPrepareTransactionRequest<'setL1PricingRewardRecipient'>
+    >().toBeCallableWith({
+      functionName: 'setL1PricingRewardRecipient',
+      account: randomAccount.address,
+      upgradeExecutor: upgradeExecutorAddress,
+      args: [100n],
+    });
+
+    expect(
+      actionsWithVersion.arbOwnerReadContract({
+        // @ts-expect-error Not available for version 11
+        functionName: 'onlyOnArbOS20',
+      }),
+    ).rejects.toThrowError(AbiFunctionNotFoundError);
+  });
+  it('Standalone actions (default version) ', () => {
+    expectTypeOf<
+      typeof actionsWithDefaultVersion.arbOwnerReadContract<'getInfraFeeAccount'>
+    >().toBeCallableWith({
+      functionName: 'getInfraFeeAccount',
+    });
+
+    expectTypeOf<
+      typeof actionsWithDefaultVersion.arbOwnerPrepareTransactionRequest<'setL1PricingRewardRecipient'>
+    >().toBeCallableWith({
+      functionName: 'setL1PricingRewardRecipient',
+      account: randomAccount.address,
+      upgradeExecutor: upgradeExecutorAddress,
+      args: [randomAccount.address],
+    });
+
+    expect(
+      actionsWithDefaultVersion.arbOwnerReadContract({
+        // @ts-expect-error Not available for version 20
+        functionName: 'onlyOnArbOS10',
+      }),
+    ).rejects.toThrowError(AbiFunctionNotFoundError);
+  });
 });
 
 // Those tests won't fail if the return type is wrong
 // But they will display an error in the IDE
 describe('Type return values for function in multiple versions', () => {
-  it('Version 10', () => {
+  it('Client with actions (Version 10)', () => {
     expectTypeOf(
       client10.arbOwnerReadContract({
         functionName: 'getAllChainOwners',
       }),
     ).resolves.toEqualTypeOf<`0x${string}`>();
   });
-  it('Version 11', () => {
+  it('Client with actions (Version 11)', () => {
     expectTypeOf(
       client11.arbOwnerReadContract({
         functionName: 'getAllChainOwners',
       }),
     ).resolves.toEqualTypeOf<bigint>();
   });
-  it('Version 20', () => {
+  it('Client with actions (Version 20)', () => {
     expectTypeOf(
       client20.arbOwnerReadContract({
         functionName: 'getAllChainOwners',
       }),
     ).resolves.toEqualTypeOf<readonly `0x${string}`[]>();
   });
-  it('Default version (20)', () => {
+  it('Client with actions (default version)', () => {
     expectTypeOf(
       clientWithoutParam.arbOwnerReadContract({
         functionName: 'getAllChainOwners',
       }),
     ).resolves.toEqualTypeOf<readonly `0x${string}`[]>();
   });
+  it('Standalone actions (version 11)', () => {
+    expectTypeOf(
+      actionsWithVersion.arbOwnerReadContract({
+        functionName: 'getAllChainOwners',
+      }),
+    ).resolves.toEqualTypeOf<bigint>();
+  });
+  it('Standalone actions (default version)', () => {
+    expectTypeOf(
+      actionsWithDefaultVersion.arbOwnerReadContract({
+        functionName: 'getAllChainOwners',
+      }),
+    ).resolves.toEqualTypeOf<readonly `0x${string}`[]>();
+  });
 });