fix: parse abi item fallback parsing (#261)

* fix: parse abi item fallback parsing * ci: apply automated fixes * refactor: extract parse signature functions, and test them * chore: tweaks * chore: tweaks * Update .changeset/red-turtles-refuse.md --------- Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com> Co-authored-by: Tom Meagher <[email protected]>
wevm · Dec 21, 2024 · 889e85d · 889e85d
1 parent eed89ed
commit 889e85d
Show file tree

Hide file tree

Showing 10 changed files with 307 additions and 92 deletions.
diff --git a/.changeset/red-turtles-refuse.md b/.changeset/red-turtles-refuse.md
@@ -0,0 +1,5 @@
+---
+"abitype": patch
+---
+
+Fixed `parseAbiItem` fallback signature parsing
diff --git a/.github/workflows/verify.yml b/.github/workflows/verify.yml
@@ -50,7 +50,7 @@ jobs:
     timeout-minutes: 5
     strategy:
       matrix:
-        version: ['5.0.4', '5.1.6', '5.2.2', '5.3.3', '5.4.5', '5.5.2', 'latest']
+        version: ['5.0.4', '5.1.6', '5.2.2', '5.3.3', '5.4.5', '5.5.2', '5.6', 'latest']
 
     steps:
       - name: Clone repository

diff --git a/packages/abitype/src/human-readable/integration.test.ts b/packages/abitype/src/human-readable/integration.test.ts
@@ -0,0 +1,68 @@
+import { expect, test } from 'vitest'
+import { formatAbiItem } from './formatAbiItem.js'
+import { parseAbiItem } from './parseAbiItem.js'
+
+test.each([
+  {
+    type: 'fallback',
+    stateMutability: 'payable',
+  } as const,
+  {
+    type: 'fallback',
+    stateMutability: 'nonpayable',
+  } as const,
+  {
+    type: 'receive',
+    stateMutability: 'payable',
+  } as const,
+  {
+    type: 'function',
+    name: 'foo',
+    inputs: [{ type: 'string' }],
+    outputs: [],
+    stateMutability: 'nonpayable',
+  } as const,
+  {
+    type: 'event',
+    name: 'Foo',
+    inputs: [
+      { type: 'address', name: 'from', indexed: true },
+      { type: 'address', name: 'to', indexed: true },
+      { type: 'uint256', name: 'amount' },
+    ],
+  } as const,
+  {
+    type: 'constructor',
+    stateMutability: 'nonpayable',
+    inputs: [{ type: 'string' }],
+  } as const,
+  {
+    type: 'constructor',
+    stateMutability: 'payable',
+    inputs: [{ type: 'string' }],
+  } as const,
+  {
+    type: 'function',
+    name: 'initWormhole',
+    inputs: [
+      {
+        type: 'tuple[]',
+        name: 'configs',
+        components: [
+          {
+            type: 'uint256',
+            name: 'chainId',
+          },
+          {
+            type: 'uint16',
+            name: 'wormholeChainId',
+          },
+        ],
+      },
+    ],
+    outputs: [],
+    stateMutability: 'nonpayable',
+  } as const,
+])('use of parseAbiItem - formatAbiItem should be reversible', (abiItem) => {
+  expect(parseAbiItem(formatAbiItem(abiItem))).toEqual(abiItem)
+})
diff --git a/packages/abitype/src/human-readable/parseAbiItem.test-d.ts b/packages/abitype/src/human-readable/parseAbiItem.test-d.ts
@@ -155,6 +155,22 @@ test('parseAbiItem', () => {
 
   const signature: string = 'function foo()'
   expectTypeOf(parseAbiItem(signature)).toEqualTypeOf<Abi[number]>()
+
+  // fallback
+  expectTypeOf(parseAbiItem('fallback() external')).toEqualTypeOf<{
+    readonly type: 'fallback'
+    readonly stateMutability: 'nonpayable'
+  }>()
+  expectTypeOf(parseAbiItem('fallback() external payable')).toEqualTypeOf<{
+    readonly type: 'fallback'
+    readonly stateMutability: 'payable'
+  }>()
+
+  // receive
+  expectTypeOf(parseAbiItem('receive() external payable')).toEqualTypeOf<{
+    readonly type: 'receive'
+    readonly stateMutability: 'payable'
+  }>()
 })
 
 test('nested tuples', () => {

diff --git a/packages/abitype/src/human-readable/parseAbiItem.test.ts b/packages/abitype/src/human-readable/parseAbiItem.test.ts
@@ -65,6 +65,14 @@ test.each([
     signature: ['fallback() external'],
     expected: {
       type: 'fallback',
+      stateMutability: 'nonpayable',
+    },
+  },
+  {
+    signature: ['fallback() external payable'],
+    expected: {
+      type: 'fallback',
+      stateMutability: 'payable',
     },
   },
 ])('parseAbiItem($signature)', ({ signature, expected }) => {

diff --git a/packages/abitype/src/human-readable/runtime/signatures.ts b/packages/abitype/src/human-readable/runtime/signatures.ts
@@ -79,6 +79,12 @@ const fallbackSignatureRegex =
 export function isFallbackSignature(signature: string) {
   return fallbackSignatureRegex.test(signature)
 }
+export function execFallbackSignature(signature: string) {
+  return execTyped<{
+    parameters: string
+    stateMutability?: Extract<AbiStateMutability, 'payable'>
+  }>(fallbackSignatureRegex, signature)
+}
 
 // https://regexr.com/78u1k
 const receiveSignatureRegex = /^receive\(\) external payable$/

diff --git a/packages/abitype/src/human-readable/runtime/utils.test.ts b/packages/abitype/src/human-readable/runtime/utils.test.ts
@@ -6,6 +6,11 @@ import {
   isSolidityType,
   isValidDataLocation,
   parseAbiParameter,
+  parseConstructorSignature,
+  parseErrorSignature,
+  parseEventSignature,
+  parseFallbackSignature,
+  parseFunctionSignature,
   parseSignature,
   splitParameters,
 } from './utils.js'
@@ -93,6 +98,20 @@ test.each([
       stateMutability: 'payable',
     },
   },
+  {
+    signature: 'fallback() external payable',
+    expected: {
+      type: 'fallback',
+      stateMutability: 'payable',
+    },
+  },
+  {
+    signature: 'fallback() external',
+    expected: {
+      type: 'fallback',
+      stateMutability: 'nonpayable',
+    },
+  },
 ])('parseSignature($signature)', ({ signature, expected }) => {
   expect(parseSignature(signature)).toEqual(expected)
 })
@@ -154,12 +173,56 @@ test('invalid signature', () => {
   )
 
   expect(() =>
-    parseSignature('method foo_(string)'),
+    parseFunctionSignature('function foo() invalid'),
   ).toThrowErrorMatchingInlineSnapshot(
     `
-    [UnknownSignatureError: Unknown signature.
+    [InvalidSignatureError: Invalid function signature.
+
+    Details: function foo() invalid
+    Version: [email protected]]
+  `,
+  )
+
+  expect(() =>
+    parseEventSignature('event Foo(string memory foo) invalid'),
+  ).toThrowErrorMatchingInlineSnapshot(
+    `
+    [InvalidSignatureError: Invalid event signature.
+
+    Details: event Foo(string memory foo) invalid
+    Version: [email protected]]
+  `,
+  )
+
+  expect(() => {
+    parseErrorSignature('error Foo(string memory foo) invalid')
+  }).toThrowErrorMatchingInlineSnapshot(
+    `
+    [InvalidSignatureError: Invalid error signature.
+
+    Details: error Foo(string memory foo) invalid
+    Version: [email protected]]
+    `,
+  )
+
+  expect(() => {
+    parseConstructorSignature('constructor() invalid')
+  }).toThrowErrorMatchingInlineSnapshot(
+    `
+    [InvalidSignatureError: Invalid constructor signature.
+
+    Details: constructor() invalid
+    Version: [email protected]]
+    `,
+  )
+
+  expect(() => {
+    parseFallbackSignature('fallback() external invalid')
+  }).toThrowErrorMatchingInlineSnapshot(
+    `
+    [InvalidSignatureError: Invalid fallback signature.
 
-    Details: method foo_(string)
+    Details: fallback() external invalid
     Version: [email protected]]
   `,
   )