ox 1.0.0-beta.8 → 1.0.0

package/src/core/internal/human-readable/parseAbiParameter.test.ts

@@ -0,0 +1,207 @@
+import { assertType, expect, test } from 'vp/test'
+
+import { parseAbiParameter } from './parseAbiParameter.js'
+
+test('parseAbiParameter', () => {
+  // @ts-expect-error invalid signature type
+  expect(() => parseAbiParameter('')).toThrowErrorMatchingInlineSnapshot(
+    `[HumanReadableAbi.InvalidParameterError: Invalid ABI parameter.]`,
+  )
+  // @ts-expect-error invalid signature type
+  expect(() => parseAbiParameter([])).toThrowErrorMatchingInlineSnapshot(
+    `
+    [AbiParameter.InvalidAbiParameterError: Failed to parse ABI parameter.
+
+    Details: parseAbiParameter([])
+    See: https://oxlib.sh/api/AbiParameter/from]
+  `,
+  )
+  expect(() =>
+    parseAbiParameter(['struct Foo { string name; }']),
+  ).toThrowErrorMatchingInlineSnapshot(
+    `
+    [AbiParameter.InvalidAbiParameterError: Failed to parse ABI parameter.
+
+    Details: parseAbiParameter([
+      "struct Foo { string name; }"
+    ])
+    See: https://oxlib.sh/api/AbiParameter/from]
+  `,
+  )
+
+  expect(() =>
+    parseAbiParameter(['struct Foo { string memory bar; }', 'Foo indexed foo']),
+  ).toThrowErrorMatchingInlineSnapshot(
+    `
+    [HumanReadableAbi.InvalidModifierError: Invalid ABI parameter.
+
+    Modifier "memory" not allowed in "struct" type.
+
+    Details: string memory bar]
+  `,
+  )
+
+  expect([parseAbiParameter('address from')]).toMatchInlineSnapshot(`
+  [
+    {
+      "name": "from",
+      "type": "address",
+    },
+  ]
+`)
+})
+
+test.each([
+  { signature: 'string', expected: { type: 'string' } },
+  { signature: 'string foo', expected: { name: 'foo', type: 'string' } },
+  {
+    signature: 'string indexed foo',
+    expected: { name: 'foo', type: 'string', indexed: true },
+  },
+  {
+    signature: 'string calldata foo',
+    expected: { name: 'foo', type: 'string' },
+  },
+  {
+    signature: '(string)',
+    expected: { type: 'tuple', components: [{ type: 'string' }] },
+  },
+  {
+    signature: '(string foo)',
+    expected: { type: 'tuple', components: [{ name: 'foo', type: 'string' }] },
+  },
+  {
+    signature: '(string bar) foo',
+    expected: {
+      type: 'tuple',
+      name: 'foo',
+      components: [{ name: 'bar', type: 'string' }],
+    },
+  },
+  {
+    signature: '(string bar, string baz) foo',
+    expected: {
+      type: 'tuple',
+      name: 'foo',
+      components: [
+        { name: 'bar', type: 'string' },
+        { name: 'baz', type: 'string' },
+      ],
+    },
+  },
+  { signature: 'string[]', expected: { type: 'string[]' } },
+])('parseAbiParameter($signature)', ({ signature, expected }) => {
+  expect(parseAbiParameter(signature)).toEqual(expected)
+})
+
+test.each([
+  {
+    signatures: ['struct Foo { string bar; }', 'Foo'],
+    expected: { type: 'tuple', components: [{ name: 'bar', type: 'string' }] },
+  },
+  {
+    signatures: ['struct Foo { string bar; }', 'Foo foo'],
+    expected: {
+      type: 'tuple',
+      name: 'foo',
+      components: [{ name: 'bar', type: 'string' }],
+    },
+  },
+  {
+    signatures: ['struct Foo { string bar; }', 'Foo indexed foo'],
+    expected: {
+      type: 'tuple',
+      name: 'foo',
+      indexed: true,
+      components: [{ name: 'bar', type: 'string' }],
+    },
+  },
+])('parseAbiParameter($signatures)', ({ signatures, expected }) => {
+  expect(parseAbiParameter(signatures)).toEqual(expected)
+})
+
+test('nested tuple', () => {
+  const result = parseAbiParameter('((((string baz) bar)[1] foo) boo)')
+  expect(result).toMatchInlineSnapshot(`
+    {
+      "components": [
+        {
+          "components": [
+            {
+              "components": [
+                {
+                  "components": [
+                    {
+                      "name": "baz",
+                      "type": "string",
+                    },
+                  ],
+                  "name": "bar",
+                  "type": "tuple",
+                },
+              ],
+              "name": "foo",
+              "type": "tuple[1]",
+            },
+          ],
+          "name": "boo",
+          "type": "tuple",
+        },
+      ],
+      "type": "tuple",
+    }
+  `)
+  assertType<{
+    type: 'tuple'
+    components: readonly [
+      {
+        type: 'tuple'
+        components: readonly [
+          {
+            type: 'tuple[1]'
+            components: readonly [
+              {
+                type: 'tuple'
+                components: readonly [
+                  {
+                    type: 'string'
+                    name: 'baz'
+                  },
+                ]
+                name: 'bar'
+              },
+            ]
+            name: 'foo'
+          },
+        ]
+        name: 'boo'
+      },
+    ]
+  }>(result)
+})
+
+test('struct name collision', () => {
+  const result1 = parseAbiParameter(['struct Foo { string bar; }', 'Foo'])
+  expect(result1).toEqual({
+    type: 'tuple',
+    components: [{ name: 'bar', type: 'string' }],
+  })
+
+  const result2 = parseAbiParameter(['struct Foo { address bar; }', 'Foo'])
+  expect(result2).toEqual({
+    type: 'tuple',
+    components: [{ name: 'bar', type: 'address' }],
+  })
+
+  const result3 = parseAbiParameter([
+    'struct Foo { uint256 amount; address token; }',
+    'Foo',
+  ])
+  expect(result3).toEqual({
+    type: 'tuple',
+    components: [
+      { name: 'amount', type: 'uint256' },
+      { name: 'token', type: 'address' },
+    ],
+  })
+})

package/src/core/internal/human-readable/parseAbiParameter.ts

@@ -0,0 +1,95 @@
+import type { AbiParameter } from 'abitype'
+import type { Narrow } from 'abitype'
+import type { Error, Filter } from './types.js'
+import { InvalidAbiParameterError } from './errors.js'
+import { isStructSignature, modifiers } from './runtime/signatures.js'
+import { parseStructs } from './runtime/structs.js'
+import { parseAbiParameter as parseAbiParameter_ } from './runtime/utils.js'
+import type { IsStructSignature, Modifier } from './types/signatures.js'
+import type { ParseStructs } from './types/structs.js'
+import type { ParseAbiParameter as ParseAbiParameter_ } from './types/utils.js'
+
+/**
+ * Parses human-readable ABI parameter into `AbiParameter`.
+ *
+ * @param param - Human-readable ABI parameter
+ * @returns Parsed `AbiParameter`.
+ */
+export type ParseAbiParameter<
+  param extends string | readonly string[] | readonly unknown[],
+> =
+  | (param extends string
+      ? param extends ''
+        ? never
+        : string extends param
+          ? AbiParameter
+          : ParseAbiParameter_<param, { modifier: Modifier }>
+      : never)
+  | (param extends readonly string[]
+      ? string[] extends param
+        ? AbiParameter // Return generic AbiParameter item since type was no inferrable
+        : ParseStructs<param> extends infer structs
+          ? {
+              [key in keyof param]: param[key] extends string
+                ? IsStructSignature<param[key]> extends true
+                  ? never
+                  : ParseAbiParameter_<
+                      param[key],
+                      { modifier: Modifier; structs: structs }
+                    >
+                : never
+            } extends infer mapped extends readonly unknown[]
+            ? Filter<mapped, never>[0] extends infer result
+              ? result extends undefined
+                ? never
+                : result
+              : never
+            : never
+          : never
+      : never)
+
+/**
+ * Parses human-readable ABI parameter into `AbiParameter`.
+ *
+ * @param param - Human-readable ABI parameter
+ * @returns Parsed `AbiParameter`.
+ */
+export function parseAbiParameter<
+  param extends string | readonly string[] | readonly unknown[],
+>(
+  param: Narrow<param> &
+    (
+      | (param extends string
+          ? param extends ''
+            ? Error<'Empty string is not allowed.'>
+            : unknown
+          : never)
+      | (param extends readonly string[]
+          ? param extends readonly [] // empty array
+            ? Error<'At least one parameter required.'>
+            : string[] extends param
+              ? unknown
+              : unknown // TODO: Validate param string
+          : never)
+    ),
+): ParseAbiParameter<param> {
+  let abiParameter: AbiParameter | undefined
+  if (typeof param === 'string')
+    abiParameter = parseAbiParameter_(param, {
+      modifiers,
+    }) as ParseAbiParameter<param>
+  else {
+    const structs = parseStructs(param as readonly string[])
+    const length = param.length as number
+    for (let i = 0; i < length; i++) {
+      const signature = (param as readonly string[])[i]!
+      if (isStructSignature(signature)) continue
+      abiParameter = parseAbiParameter_(signature, { modifiers, structs })
+      break
+    }
+  }
+
+  if (!abiParameter) throw new InvalidAbiParameterError({ param })
+
+  return abiParameter as ParseAbiParameter<param>
+}

package/src/core/internal/human-readable/parseAbiParameters.test-d.ts

@@ -0,0 +1,160 @@
+import { expectTypeOf, test } from 'vp/test'
+
+import type { AbiParameter } from 'abitype'
+import type { ParseAbiParameters } from './parseAbiParameters.js'
+import { parseAbiParameters } from './parseAbiParameters.js'
+
+test('ParseAbiParameters', () => {
+  expectTypeOf<ParseAbiParameters<''>>().toEqualTypeOf<never>()
+  expectTypeOf<ParseAbiParameters<[]>>().toEqualTypeOf<never>()
+  expectTypeOf<
+    ParseAbiParameters<['struct Foo { string name; }']>
+  >().toEqualTypeOf<never>()
+
+  // string
+  expectTypeOf<
+    ParseAbiParameters<'address from, address to, uint256 amount'>
+  >().toEqualTypeOf<
+    readonly [
+      {
+        readonly type: 'address'
+        readonly name: 'from'
+      },
+      {
+        readonly type: 'address'
+        readonly name: 'to'
+      },
+      {
+        readonly type: 'uint256'
+        readonly name: 'amount'
+      },
+    ]
+  >()
+  expectTypeOf<
+    ParseAbiParameters<'address indexed from, address indexed to, uint256 indexed amount'>
+  >().toEqualTypeOf<
+    readonly [
+      {
+        readonly type: 'address'
+        readonly name: 'from'
+        readonly indexed: true
+      },
+      {
+        readonly type: 'address'
+        readonly name: 'to'
+        readonly indexed: true
+      },
+      {
+        readonly type: 'uint256'
+        readonly name: 'amount'
+        readonly indexed: true
+      },
+    ]
+  >()
+  expectTypeOf<
+    ParseAbiParameters<'address calldata foo, address memory bar, uint256 storage baz'>
+  >().toEqualTypeOf<
+    readonly [
+      {
+        readonly type: 'address'
+        readonly name: 'foo'
+      },
+      {
+        readonly type: 'address'
+        readonly name: 'bar'
+      },
+      {
+        readonly type: 'uint256'
+        readonly name: 'baz'
+      },
+    ]
+  >()
+
+  // Array
+  expectTypeOf<
+    ParseAbiParameters<['Foo, bytes32', 'struct Foo { string name; }']>
+  >().toEqualTypeOf<
+    readonly [
+      {
+        readonly type: 'tuple'
+        readonly components: readonly [
+          {
+            readonly name: 'name'
+            readonly type: 'string'
+          },
+        ]
+      },
+      { readonly type: 'bytes32' },
+    ]
+  >()
+})
+
+test('parseAbiParameters', () => {
+  // @ts-expect-error empty array not allowed
+  expectTypeOf(parseAbiParameters([])).toEqualTypeOf<never>()
+  expectTypeOf(
+    parseAbiParameters(['struct Foo { string name; }']),
+  ).toEqualTypeOf<never>()
+
+  expectTypeOf(parseAbiParameters('(string)')).toEqualTypeOf<
+    readonly [
+      {
+        readonly type: 'tuple'
+        readonly components: readonly [{ readonly type: 'string' }]
+      },
+    ]
+  >()
+
+  const param: string = 'address, string'
+  expectTypeOf(parseAbiParameters(param)).toEqualTypeOf<
+    readonly AbiParameter[]
+  >()
+
+  expectTypeOf(parseAbiParameters(['(uint256 a),(uint256 b)'])).toEqualTypeOf<
+    readonly [
+      {
+        readonly type: 'tuple'
+        readonly components: readonly [
+          {
+            readonly type: 'uint256'
+            readonly name: 'a'
+          },
+        ]
+      },
+      {
+        readonly type: 'tuple'
+        readonly components: readonly [
+          {
+            readonly type: 'uint256'
+            readonly name: 'b'
+          },
+        ]
+      },
+    ]
+  >()
+
+  expectTypeOf(
+    parseAbiParameters(['(uint256 a)', '(uint256 b)']),
+  ).toEqualTypeOf<
+    readonly [
+      {
+        readonly type: 'tuple'
+        readonly components: readonly [
+          {
+            readonly type: 'uint256'
+            readonly name: 'a'
+          },
+        ]
+      },
+      {
+        readonly type: 'tuple'
+        readonly components: readonly [
+          {
+            readonly type: 'uint256'
+            readonly name: 'b'
+          },
+        ]
+      },
+    ]
+  >()
+})

package/src/core/internal/human-readable/parseAbiParameters.test.ts

@@ -0,0 +1,80 @@
+import { expect, test } from 'vp/test'
+
+import { parseAbiParameters } from './parseAbiParameters.js'
+
+test('parseAbiParameters', () => {
+  // @ts-expect-error invalid signature type
+  expect(() => parseAbiParameters('')).toThrowErrorMatchingInlineSnapshot(
+    `
+    [AbiParameters.InvalidAbiParametersError: Failed to parse ABI parameters.
+
+    Details: parseAbiParameters("")
+    See: https://oxlib.sh/api/AbiParameters/from]
+  `,
+  )
+  // @ts-expect-error invalid signature type
+  expect(() => parseAbiParameters([])).toThrowErrorMatchingInlineSnapshot(
+    `
+    [AbiParameters.InvalidAbiParametersError: Failed to parse ABI parameters.
+
+    Details: parseAbiParameters([])
+    See: https://oxlib.sh/api/AbiParameters/from]
+  `,
+  )
+  expect(() =>
+    parseAbiParameters(['struct Foo { string name; }']),
+  ).toThrowErrorMatchingInlineSnapshot(
+    `
+    [AbiParameters.InvalidAbiParametersError: Failed to parse ABI parameters.
+
+    Details: parseAbiParameters([
+      "struct Foo { string name; }"
+    ])
+    See: https://oxlib.sh/api/AbiParameters/from]
+  `,
+  )
+
+  expect(parseAbiParameters('address from')).toMatchInlineSnapshot(`
+    [
+      {
+        "name": "from",
+        "type": "address",
+      },
+    ]
+  `)
+})
+
+test.each([
+  {
+    signatures: 'string, string',
+    expected: [{ type: 'string' }, { type: 'string' }],
+  },
+  {
+    signatures: 'string foo, string bar',
+    expected: [
+      { type: 'string', name: 'foo' },
+      { type: 'string', name: 'bar' },
+    ],
+  },
+])('parseAbiParameters($signatures)', ({ signatures, expected }) => {
+  expect(parseAbiParameters(signatures)).toEqual(expected)
+})
+
+test.each([
+  {
+    signatures: ['struct Foo { string bar; }', 'Foo, string'],
+    expected: [
+      { type: 'tuple', components: [{ name: 'bar', type: 'string' }] },
+      { type: 'string' },
+    ],
+  },
+  {
+    signatures: ['string foo, string bar'],
+    expected: [
+      { name: 'foo', type: 'string' },
+      { name: 'bar', type: 'string' },
+    ],
+  },
+])('parseAbiParameters($signatures)', ({ signatures, expected }) => {
+  expect(parseAbiParameters(signatures)).toEqual(expected)
+})

package/src/core/internal/human-readable/parseAbiParameters.ts

@@ -0,0 +1,123 @@
+import type { AbiParameter } from 'abitype'
+import type { Narrow } from 'abitype'
+import type { Error, Filter } from './types.js'
+import { InvalidAbiParametersError } from './errors.js'
+import { isStructSignature, modifiers } from './runtime/signatures.js'
+import { parseStructs } from './runtime/structs.js'
+import { splitParameters } from './runtime/utils.js'
+import { parseAbiParameter as parseAbiParameter_ } from './runtime/utils.js'
+import type { IsStructSignature, Modifier } from './types/signatures.js'
+import type { ParseStructs } from './types/structs.js'
+import type { SplitParameters } from './types/utils.js'
+import type { ParseAbiParameters as ParseAbiParameters_ } from './types/utils.js'
+
+/**
+ * Parses human-readable ABI parameters into `AbiParameter`s.
+ *
+ * @param params - Human-readable ABI parameters
+ * @returns Parsed `AbiParameter`s.
+ */
+export type ParseAbiParameters<
+  params extends string | readonly string[] | readonly unknown[],
+> =
+  | (params extends string
+      ? params extends ''
+        ? never
+        : string extends params
+          ? readonly AbiParameter[]
+          : ParseAbiParameters_<SplitParameters<params>, { modifier: Modifier }>
+      : never)
+  | (params extends readonly string[]
+      ? string[] extends params
+        ? AbiParameter // Return generic AbiParameter item since type was no inferrable
+        : ParseStructs<params> extends infer structs
+          ? {
+              [key in keyof params]: params[key] extends string
+                ? IsStructSignature<params[key]> extends true
+                  ? never
+                  : ParseAbiParameters_<
+                      SplitParameters<params[key]>,
+                      { modifier: Modifier; structs: structs }
+                    >
+                : never
+            } extends infer mapped extends readonly unknown[]
+            ? Filter<mapped, never> extends readonly [...infer content]
+              ? content['length'] extends 0
+                ? never
+                : DeepFlatten<content>
+              : never
+            : never
+          : never
+      : never)
+
+/**
+ * Flatten all members of `T`.
+ *
+ * @param T - List of items to flatten
+ * @param Acc - The accumulator used while recursing
+ * @returns The flattened array
+ */
+type DeepFlatten<
+  T extends readonly unknown[],
+  Acc extends readonly unknown[] = readonly [],
+> = T extends readonly [infer head, ...infer tail]
+  ? tail extends undefined
+    ? never
+    : head extends readonly unknown[]
+      ? DeepFlatten<tail, readonly [...Acc, ...DeepFlatten<head>]>
+      : DeepFlatten<tail, readonly [...Acc, head]>
+  : Acc
+
+/**
+ * Parses human-readable ABI parameters into `AbiParameter`s.
+ *
+ * @param params - Human-readable ABI parameters
+ * @returns Parsed `AbiParameter`s.
+ */
+export function parseAbiParameters<
+  params extends string | readonly string[] | readonly unknown[],
+>(
+  params: Narrow<params> &
+    (
+      | (params extends string
+          ? params extends ''
+            ? Error<'Empty string is not allowed.'>
+            : unknown
+          : never)
+      | (params extends readonly string[]
+          ? params extends readonly [] // empty array
+            ? Error<'At least one parameter required.'>
+            : string[] extends params
+              ? unknown
+              : unknown // TODO: Validate param string
+          : never)
+    ),
+): ParseAbiParameters<params> {
+  const abiParameters: AbiParameter[] = []
+  if (typeof params === 'string') {
+    const parameters = splitParameters(params)
+    const length = parameters.length
+    for (let i = 0; i < length; i++) {
+      abiParameters.push(parseAbiParameter_(parameters[i]!, { modifiers }))
+    }
+  } else {
+    const structs = parseStructs(params as readonly string[])
+    const length = params.length as number
+    for (let i = 0; i < length; i++) {
+      const signature = (params as readonly string[])[i]!
+      if (isStructSignature(signature)) continue
+      const parameters = splitParameters(signature)
+      const length = parameters.length
+      for (let k = 0; k < length; k++) {
+        abiParameters.push(
+          parseAbiParameter_(parameters[k]!, { modifiers, structs }),
+        )
+      }
+    }
+  }
+
+  if (abiParameters.length === 0)
+    throw new InvalidAbiParametersError({ params })
+
+  return abiParameters as ParseAbiParameters<params>
+}

package/src/core/internal/human-readable/regex.ts

@@ -0,0 +1,15 @@
+/** @internal */
+export function execTyped<type>(regex: RegExp, string: string) {
+  const match = regex.exec(string)
+  return match?.groups as type | undefined
+}
+
+/** @internal */
+export const bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/
+
+/** @internal */
+export const integerRegex =
+  /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/
+
+/** @internal */
+export const isTupleRegex = /^\(.+?\).*?$/