ox 1.0.0-beta.8 → 1.0.0

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

@@ -0,0 +1,92 @@
+import { expectTypeOf, test } from 'vp/test'
+
+import type { AbiParameter } from 'abitype'
+
+import type { FormatAbiParameters } from './formatAbiParameters.js'
+import { formatAbiParameters } from './formatAbiParameters.js'
+
+test('FormatAbiParameters', () => {
+  // @ts-expect-error must have at least one parameter
+  expectTypeOf<FormatAbiParameters<[]>>().toEqualTypeOf<never>()
+
+  // string
+  expectTypeOf<
+    FormatAbiParameters<
+      [
+        {
+          readonly type: 'address'
+          readonly name: 'from'
+        },
+      ]
+    >
+  >().toEqualTypeOf<'address from'>()
+  expectTypeOf<
+    FormatAbiParameters<
+      [
+        {
+          readonly type: 'address'
+          readonly name: 'from'
+          readonly indexed: true
+        },
+      ]
+    >
+  >().toEqualTypeOf<'address indexed from'>()
+
+  // Array
+  expectTypeOf<
+    FormatAbiParameters<
+      [
+        {
+          readonly type: 'tuple'
+          readonly components: readonly [
+            {
+              readonly name: 'name'
+              readonly type: 'string'
+            },
+          ]
+        },
+      ]
+    >
+  >().toEqualTypeOf<'(string name)'>()
+
+  expectTypeOf<
+    FormatAbiParameters<
+      [
+        {
+          readonly type: 'tuple'
+          readonly components: readonly [
+            {
+              readonly type: 'string'
+              readonly name: 'bar'
+            },
+          ]
+          readonly name: 'foo'
+        },
+      ]
+    >
+  >().toEqualTypeOf<'(string bar) foo'>()
+})
+
+test('formatAbiParameter', () => {
+  expectTypeOf(
+    formatAbiParameters([
+      {
+        type: 'tuple',
+        components: [{ type: 'string' }],
+      },
+    ]),
+  ).toEqualTypeOf<'(string)'>()
+
+  const param = { type: 'address' }
+  const param2: AbiParameter = param
+
+  expectTypeOf(formatAbiParameters([param])).toEqualTypeOf<string>()
+
+  expectTypeOf(
+    formatAbiParameters([param, param]),
+  ).toEqualTypeOf<`${string}, ${string}`>()
+
+  expectTypeOf(
+    formatAbiParameters([param2, param2]),
+  ).toEqualTypeOf<`${string}, ${string}`>()
+})

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

@@ -0,0 +1,32 @@
+import { expect, expectTypeOf, test } from 'vp/test'
+
+import { formatAbiParameters } from './formatAbiParameters.js'
+
+test('default', () => {
+  const result = formatAbiParameters([
+    { type: 'address', name: 'foo' },
+    { type: 'uint256', name: 'bar' },
+  ])
+  expect(result).toEqual('address foo, uint256 bar')
+  expectTypeOf(result).toEqualTypeOf<'address foo, uint256 bar'>()
+})
+
+test('tuple', () => {
+  const result = formatAbiParameters([
+    {
+      type: 'tuple',
+      components: [
+        { type: 'string', name: 'bar' },
+        { type: 'string', name: 'baz' },
+      ],
+      name: 'foo',
+    },
+    { type: 'uint256', name: 'bar' },
+  ])
+  expect(result).toMatchInlineSnapshot(
+    '"(string bar, string baz) foo, uint256 bar"',
+  )
+  expectTypeOf(
+    result,
+  ).toEqualTypeOf<'(string bar, string baz) foo, uint256 bar'>()
+})

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

@@ -0,0 +1,46 @@
+import type { AbiEventParameter, AbiParameter } from 'abitype'
+import type { Join } from './types.js'
+import {
+  type FormatAbiParameter,
+  formatAbiParameter,
+} from './formatAbiParameter.js'
+
+/**
+ * Formats `AbiParameter`s to human-readable ABI parameter.
+ *
+ * @param abiParameters - ABI parameters
+ * @returns Human-readable ABI parameters
+ */
+export type FormatAbiParameters<
+  abiParameters extends readonly [
+    AbiParameter | AbiEventParameter,
+    ...(readonly (AbiParameter | AbiEventParameter)[]),
+  ],
+> = Join<
+  {
+    [key in keyof abiParameters]: FormatAbiParameter<abiParameters[key]>
+  },
+  ', '
+>
+
+/**
+ * Formats `AbiParameter`s to human-readable ABI parameters.
+ *
+ * @param abiParameters - ABI parameters
+ * @returns Human-readable ABI parameters
+ */
+export function formatAbiParameters<
+  const abiParameters extends readonly [
+    AbiParameter | AbiEventParameter,
+    ...(readonly (AbiParameter | AbiEventParameter)[]),
+  ],
+>(abiParameters: abiParameters): FormatAbiParameters<abiParameters> {
+  let params = ''
+  const length = abiParameters.length
+  for (let i = 0; i < length; i++) {
+    const abiParameter = abiParameters[i]!
+    params += formatAbiParameter(abiParameter)
+    if (i !== length - 1) params += ', '
+  }
+  return params as FormatAbiParameters<abiParameters>
+}

package/src/core/internal/human-readable/human-readable.bench-d.ts

@@ -0,0 +1,58 @@
+import { attest } from '@ark/attest'
+import { Abi, AbiItem, AbiParameter, AbiParameters } from 'ox'
+import { describe, test } from 'vp/test'
+import type { seaportHumanReadableAbi } from '../../../../test/abis/human-readable.js'
+
+describe('human-readable ABI type instantiations', () => {
+  test('Abi.from.ReturnType: erc20-sized ABI', () => {
+    type Result = Abi.from.ReturnType<
+      [
+        'function name() view returns (string)',
+        'function symbol() view returns (string)',
+        'function decimals() view returns (uint8)',
+        'function totalSupply() view returns (uint256)',
+        'function balanceOf(address owner) view returns (uint256)',
+        'function transfer(address to, uint256 amount) returns (bool)',
+        'function transferFrom(address from, address to, uint256 amount) returns (bool)',
+        'function approve(address spender, uint256 amount) returns (bool)',
+        'function allowance(address owner, address spender) view returns (uint256)',
+        'event Transfer(address indexed from, address indexed to, uint256 amount)',
+        'event Approval(address indexed owner, address indexed spender, uint256 amount)',
+      ]
+    >
+    attest.instantiations([45_000, 'instantiations'])
+    attest<Result>({} as Result)
+  })
+
+  test('Abi.from.ReturnType: seaport human-readable ABI', () => {
+    type Result = Abi.from.ReturnType<typeof seaportHumanReadableAbi>
+    attest.instantiations([5_000_000, 'instantiations'])
+    attest<Result>({} as Result)
+  })
+
+  test('AbiItem.from.ReturnType: struct item', () => {
+    type Result = AbiItem.from.ReturnType<
+      [
+        'struct Foo { address spender; uint256 amount; }',
+        'function approve(Foo foo) returns (bool)',
+      ]
+    >
+    attest.instantiations([15_000, 'instantiations'])
+    attest<Result>({} as Result)
+  })
+
+  test('AbiParameters.from.ReturnType: nested tuple parameters', () => {
+    type Result =
+      AbiParameters.from.ReturnType<'(uint8 a, uint8[] b, (uint8 x, uint8 y)[] c) s, (uint x, uint y) t, uint256 a'>
+    attest.instantiations([20_000, 'instantiations'])
+    attest<Result>({} as Result)
+  })
+
+  test('AbiParameter.from.ReturnType: struct parameter', () => {
+    type Result = AbiParameter.from.ReturnType<
+      ['struct Foo { address spender; uint256 amount; }', 'Foo foo']
+    >
+    attest.instantiations([10_000, 'instantiations'])
+    attest<Result>({} as Result)
+  })
+})

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

@@ -0,0 +1,68 @@
+import { expect, test } from 'vp/test'
+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)
+})

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

@@ -0,0 +1,188 @@
+import { expectTypeOf, test } from 'vp/test'
+
+import type { Abi } from 'abitype'
+
+import { seaportHumanReadableAbi } from '../../../../test/abis/human-readable.js'
+import type { IsAbi } from 'abitype'
+import type { ParseAbi } from './parseAbi.js'
+import { parseAbi } from './parseAbi.js'
+
+test('ParseAbi', () => {
+  type SeaportAbi = ParseAbi<typeof seaportHumanReadableAbi>
+  expectTypeOf<IsAbi<SeaportAbi>>().toEqualTypeOf<true>()
+
+  expectTypeOf<ParseAbi<[]>>().toEqualTypeOf<never>()
+  expectTypeOf<
+    ParseAbi<['struct Foo { string name; }']>
+  >().toEqualTypeOf<never>()
+
+  expectTypeOf<
+    ParseAbi<
+      [
+        'function foo()',
+        'function bar(Foo, bytes32)',
+        'struct Foo { string name; }',
+      ]
+    >
+  >().toEqualTypeOf<
+    readonly [
+      {
+        readonly name: 'foo'
+        readonly type: 'function'
+        readonly stateMutability: 'nonpayable'
+        readonly inputs: readonly []
+        readonly outputs: readonly []
+      },
+      {
+        readonly name: 'bar'
+        readonly type: 'function'
+        readonly stateMutability: 'nonpayable'
+        readonly inputs: readonly [
+          {
+            readonly type: 'tuple'
+            readonly components: readonly [
+              {
+                readonly name: 'name'
+                readonly type: 'string'
+              },
+            ]
+          },
+          {
+            readonly type: 'bytes32'
+          },
+        ]
+        readonly outputs: readonly []
+      },
+    ]
+  >()
+
+  expectTypeOf<
+    ParseAbi<
+      [
+        'function balanceOf(address owner) view returns (uint256)',
+        'event Transfer(address indexed from, address indexed to, uint256 amount)',
+      ]
+    >
+  >().toEqualTypeOf<
+    readonly [
+      {
+        readonly name: 'balanceOf'
+        readonly type: 'function'
+        readonly stateMutability: 'view'
+        readonly inputs: readonly [
+          {
+            readonly name: 'owner'
+            readonly type: 'address'
+          },
+        ]
+        readonly outputs: readonly [
+          {
+            readonly type: 'uint256'
+          },
+        ]
+      },
+      {
+        readonly name: 'Transfer'
+        readonly type: 'event'
+        readonly inputs: readonly [
+          {
+            readonly name: 'from'
+            readonly type: 'address'
+            readonly indexed: true
+          },
+          {
+            readonly name: 'to'
+            readonly type: 'address'
+            readonly indexed: true
+          },
+          {
+            readonly name: 'amount'
+            readonly type: 'uint256'
+          },
+        ]
+      },
+    ]
+  >()
+
+  expectTypeOf<ParseAbi<['function foo ()']>>().toEqualTypeOf<never>()
+})
+
+test('parseAbi', () => {
+  // @ts-expect-error empty array not allowed
+  expectTypeOf(parseAbi([])).toEqualTypeOf<never>()
+  expectTypeOf(parseAbi(['struct Foo { string name; }'])).toEqualTypeOf<never>()
+
+  // Array
+  const res2 = parseAbi([
+    'function bar(Foo, bytes32)',
+    'struct Foo { string name; }',
+  ])
+  expectTypeOf<typeof res2>().toEqualTypeOf<
+    readonly [
+      {
+        readonly name: 'bar'
+        readonly type: 'function'
+        readonly stateMutability: 'nonpayable'
+        readonly inputs: readonly [
+          {
+            readonly type: 'tuple'
+            readonly components: readonly [
+              {
+                readonly name: 'name'
+                readonly type: 'string'
+              },
+            ]
+          },
+          {
+            readonly type: 'bytes32'
+          },
+        ]
+        readonly outputs: readonly []
+      },
+    ]
+  >()
+
+  const abi2 = [
+    'function foo()',
+    'function bar(Foo, bytes32)',
+    'struct Foo { string name; }',
+  ]
+  expectTypeOf(parseAbi(abi2)).toEqualTypeOf<Abi>()
+
+  // @ts-expect-error invalid signature
+  expectTypeOf(parseAbi(['function foo ()'])).toEqualTypeOf<never>()
+
+  const param: string[] = abi2
+  expectTypeOf(parseAbi(param)).toEqualTypeOf<Abi>()
+
+  const getOrderType = parseAbi(seaportHumanReadableAbi)[10]
+  expectTypeOf<typeof getOrderType>().toEqualTypeOf<{
+    readonly name: 'getOrderStatus'
+    readonly type: 'function'
+    readonly stateMutability: 'view'
+    readonly inputs: readonly [
+      {
+        readonly type: 'bytes32'
+        readonly name: 'orderHash'
+      },
+    ]
+    readonly outputs: readonly [
+      {
+        readonly type: 'bool'
+        readonly name: 'isValidated'
+      },
+      {
+        readonly type: 'bool'
+        readonly name: 'isCancelled'
+      },
+      {
+        readonly type: 'uint256'
+        readonly name: 'totalFilled'
+      },
+      {
+        readonly type: 'uint256'
+        readonly name: 'totalSize'
+      },
+    ]
+  }>()
+})

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

@@ -0,0 +1,82 @@
+import { expect, test } from 'vp/test'
+
+import { seaportHumanReadableAbi } from '../../../../test/abis/human-readable.js'
+import { parseAbi } from './parseAbi.js'
+
+const customSolidityErrorsHumanReadableAbi = [
+  'constructor()',
+  'error ApprovalCallerNotOwnerNorApproved()',
+  'error ApprovalQueryForNonexistentToken()',
+] as const
+
+test('parseAbi', () => {
+  const result = parseAbi(seaportHumanReadableAbi)
+  expect(result).toMatchSnapshot()
+
+  expect(parseAbi(customSolidityErrorsHumanReadableAbi)).toMatchInlineSnapshot(`
+    [
+      {
+        "inputs": [],
+        "stateMutability": "nonpayable",
+        "type": "constructor",
+      },
+      {
+        "inputs": [],
+        "name": "ApprovalCallerNotOwnerNorApproved",
+        "type": "error",
+      },
+      {
+        "inputs": [],
+        "name": "ApprovalQueryForNonexistentToken",
+        "type": "error",
+      },
+    ]
+  `)
+})
+
+test('busts cache', () => {
+  const result1 = parseAbi([
+    'function balanceOf(Baz baz)',
+    'struct Baz {uint amount; string role;}',
+  ])
+  expect(result1[0].inputs).toMatchInlineSnapshot(`
+    [
+      {
+        "components": [
+          {
+            "name": "amount",
+            "type": "uint256",
+          },
+          {
+            "name": "role",
+            "type": "string",
+          },
+        ],
+        "name": "baz",
+        "type": "tuple",
+      },
+    ]
+  `)
+  const result2 = parseAbi([
+    'function balanceOf(Baz baz)',
+    'struct Baz {uint price; string role;}',
+  ])
+  expect(result2[0].inputs).toMatchInlineSnapshot(`
+    [
+      {
+        "components": [
+          {
+            "name": "price",
+            "type": "uint256",
+          },
+          {
+            "name": "role",
+            "type": "string",
+          },
+        ],
+        "name": "baz",
+        "type": "tuple",
+      },
+    ]
+  `)
+})

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

@@ -0,0 +1,59 @@
+import type { Abi } from 'abitype'
+import type { Error, Filter } from './types.js'
+import { isStructSignature } from './runtime/signatures.js'
+import { parseStructs } from './runtime/structs.js'
+import { parseSignature } from './runtime/utils.js'
+import type { Signatures } from './types/signatures.js'
+import type { ParseStructs } from './types/structs.js'
+import type { ParseSignature } from './types/utils.js'
+
+/**
+ * Parses human-readable ABI into JSON `Abi`.
+ *
+ * @param signatures - Human-readable ABI
+ * @returns Parsed `Abi`.
+ */
+export type ParseAbi<signatures extends readonly string[]> =
+  string[] extends signatures
+    ? Abi // If `T` was not able to be inferred (e.g. just `string[]`), return `Abi`
+    : signatures extends readonly string[]
+      ? signatures extends Signatures<signatures> // Validate signatures
+        ? ParseStructs<signatures> extends infer structs
+          ? {
+              [key in keyof signatures]: signatures[key] extends string
+                ? ParseSignature<signatures[key], structs>
+                : never
+            } extends infer mapped extends readonly unknown[]
+            ? Filter<mapped, never> extends infer result
+              ? result extends readonly []
+                ? never
+                : result
+              : never
+            : never
+          : never
+        : never
+      : never
+
+/**
+ * Parses human-readable ABI into JSON `Abi`.
+ *
+ * @param signatures - Human-Readable ABI
+ * @returns Parsed `Abi`.
+ */
+export function parseAbi<const signatures extends readonly string[]>(
+  signatures: signatures['length'] extends 0
+    ? Error<'At least one signature required'>
+    : Signatures<signatures> extends signatures
+      ? signatures
+      : Signatures<signatures>,
+): ParseAbi<signatures> {
+  const structs = parseStructs(signatures as readonly string[])
+  const abi = []
+  const length = signatures.length as number
+  for (let i = 0; i < length; i++) {
+    const signature = (signatures as readonly string[])[i]!
+    if (isStructSignature(signature)) continue
+    abi.push(parseSignature(signature, structs))
+  }
+  return abi as unknown as ParseAbi<signatures>
+}