ox 1.0.0-beta.8 → 1.0.0

package/src/core/internal/human-readable/runtime/utils.ts

@@ -0,0 +1,344 @@
+import type {
+  AbiItemType,
+  AbiType,
+  SolidityArray,
+  SolidityBytes,
+  SolidityString,
+  SolidityTuple,
+} from 'abitype'
+import { bytesRegex, execTyped, integerRegex, isTupleRegex } from '../regex.js'
+import { UnknownSolidityTypeError } from '../errors.js'
+import {
+  InvalidFunctionModifierError,
+  InvalidModifierError,
+  InvalidParameterError,
+  SolidityProtectedKeywordError,
+} from '../errors.js'
+import { InvalidSignatureError, UnknownSignatureError } from '../errors.js'
+import { InvalidParenthesisError } from '../errors.js'
+import type { FunctionModifier, Modifier } from '../types/signatures.js'
+import type { StructLookup } from '../types/structs.js'
+import { getParameterCacheKey, parameterCache } from './cache.js'
+import {
+  eventModifiers,
+  execConstructorSignature,
+  execErrorSignature,
+  execEventSignature,
+  execFallbackSignature,
+  execFunctionSignature,
+  functionModifiers,
+  isConstructorSignature,
+  isErrorSignature,
+  isEventSignature,
+  isFallbackSignature,
+  isFunctionSignature,
+  isReceiveSignature,
+} from './signatures.js'
+
+export function parseSignature(signature: string, structs: StructLookup = {}) {
+  if (isFunctionSignature(signature))
+    return parseFunctionSignature(signature, structs)
+
+  if (isEventSignature(signature))
+    return parseEventSignature(signature, structs)
+
+  if (isErrorSignature(signature))
+    return parseErrorSignature(signature, structs)
+
+  if (isConstructorSignature(signature))
+    return parseConstructorSignature(signature, structs)
+
+  if (isFallbackSignature(signature)) return parseFallbackSignature(signature)
+
+  if (isReceiveSignature(signature))
+    return {
+      type: 'receive',
+      stateMutability: 'payable',
+    }
+
+  throw new UnknownSignatureError({ signature })
+}
+
+export function parseFunctionSignature(
+  signature: string,
+  structs: StructLookup = {},
+) {
+  const match = execFunctionSignature(signature)
+  if (!match) throw new InvalidSignatureError({ signature, type: 'function' })
+
+  const inputParams = splitParameters(match.parameters)
+  const inputs = []
+  const inputLength = inputParams.length
+  for (let i = 0; i < inputLength; i++) {
+    inputs.push(
+      parseAbiParameter(inputParams[i]!, {
+        modifiers: functionModifiers,
+        structs,
+        type: 'function',
+      }),
+    )
+  }
+
+  const outputs = []
+  if (match.returns) {
+    const outputParams = splitParameters(match.returns)
+    const outputLength = outputParams.length
+    for (let i = 0; i < outputLength; i++) {
+      outputs.push(
+        parseAbiParameter(outputParams[i]!, {
+          modifiers: functionModifiers,
+          structs,
+          type: 'function',
+        }),
+      )
+    }
+  }
+
+  return {
+    name: match.name,
+    type: 'function',
+    stateMutability: match.stateMutability ?? 'nonpayable',
+    inputs,
+    outputs,
+  }
+}
+
+export function parseEventSignature(
+  signature: string,
+  structs: StructLookup = {},
+) {
+  const match = execEventSignature(signature)
+  if (!match) throw new InvalidSignatureError({ signature, type: 'event' })
+
+  const params = splitParameters(match.parameters)
+  const abiParameters = []
+  const length = params.length
+  for (let i = 0; i < length; i++)
+    abiParameters.push(
+      parseAbiParameter(params[i]!, {
+        modifiers: eventModifiers,
+        structs,
+        type: 'event',
+      }),
+    )
+  return { name: match.name, type: 'event', inputs: abiParameters }
+}
+
+export function parseErrorSignature(
+  signature: string,
+  structs: StructLookup = {},
+) {
+  const match = execErrorSignature(signature)
+  if (!match) throw new InvalidSignatureError({ signature, type: 'error' })
+
+  const params = splitParameters(match.parameters)
+  const abiParameters = []
+  const length = params.length
+  for (let i = 0; i < length; i++)
+    abiParameters.push(
+      parseAbiParameter(params[i]!, { structs, type: 'error' }),
+    )
+  return { name: match.name, type: 'error', inputs: abiParameters }
+}
+
+export function parseConstructorSignature(
+  signature: string,
+  structs: StructLookup = {},
+) {
+  const match = execConstructorSignature(signature)
+  if (!match)
+    throw new InvalidSignatureError({ signature, type: 'constructor' })
+
+  const params = splitParameters(match.parameters)
+  const abiParameters = []
+  const length = params.length
+  for (let i = 0; i < length; i++)
+    abiParameters.push(
+      parseAbiParameter(params[i]!, { structs, type: 'constructor' }),
+    )
+  return {
+    type: 'constructor',
+    stateMutability: match.stateMutability ?? 'nonpayable',
+    inputs: abiParameters,
+  }
+}
+
+export function parseFallbackSignature(signature: string) {
+  const match = execFallbackSignature(signature)
+  if (!match) throw new InvalidSignatureError({ signature, type: 'fallback' })
+
+  return {
+    type: 'fallback',
+    stateMutability: match.stateMutability ?? 'nonpayable',
+  }
+}
+
+const abiParameterWithoutTupleRegex =
+  /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*(?:\spayable)?)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/
+const abiParameterWithTupleRegex =
+  /^\((?<type>.+?)\)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/
+const dynamicIntegerRegex = /^u?int$/
+
+type ParseOptions = {
+  modifiers?: Set<Modifier>
+  structs?: StructLookup
+  type?: AbiItemType | 'struct'
+}
+
+export function parseAbiParameter(param: string, options?: ParseOptions) {
+  // optional namespace cache by `type`
+  const parameterCacheKey = getParameterCacheKey(
+    param,
+    options?.type,
+    options?.structs,
+  )
+  if (parameterCache.has(parameterCacheKey))
+    return parameterCache.get(parameterCacheKey)!
+
+  const isTuple = isTupleRegex.test(param)
+  const match = execTyped<{
+    array?: string
+    modifier?: Modifier
+    name?: string
+    type: string
+  }>(
+    isTuple ? abiParameterWithTupleRegex : abiParameterWithoutTupleRegex,
+    param,
+  )
+  if (!match) throw new InvalidParameterError({ param })
+
+  if (match.name && isSolidityKeyword(match.name))
+    throw new SolidityProtectedKeywordError({ param, name: match.name })
+
+  const name = match.name ? { name: match.name } : {}
+  const indexed = match.modifier === 'indexed' ? { indexed: true } : {}
+  const structs = options?.structs ?? {}
+  let type: string
+  let components = {}
+  if (isTuple) {
+    type = 'tuple'
+    const params = splitParameters(match.type)
+    const components_ = []
+    const length = params.length
+    for (let i = 0; i < length; i++) {
+      // remove `modifiers` from `options` to prevent from being added to tuple components
+      components_.push(parseAbiParameter(params[i]!, { structs }))
+    }
+    components = { components: components_ }
+  } else if (match.type in structs) {
+    type = 'tuple'
+    components = { components: structs[match.type] }
+  } else if (dynamicIntegerRegex.test(match.type)) {
+    type = `${match.type}256`
+  } else if (match.type === 'address payable') {
+    type = 'address'
+  } else {
+    type = match.type
+    if (!(options?.type === 'struct') && !isSolidityType(type))
+      throw new UnknownSolidityTypeError({ type })
+  }
+
+  if (match.modifier) {
+    // Check if modifier exists, but is not allowed (e.g. `indexed` in `functionModifiers`)
+    if (!options?.modifiers?.has?.(match.modifier))
+      throw new InvalidModifierError({
+        param,
+        type: options?.type,
+        modifier: match.modifier,
+      })
+
+    // Check if resolved `type` is valid if there is a function modifier
+    if (
+      functionModifiers.has(match.modifier as FunctionModifier) &&
+      !isValidDataLocation(type, !!match.array)
+    )
+      throw new InvalidFunctionModifierError({
+        param,
+        type: options?.type,
+        modifier: match.modifier,
+      })
+  }
+
+  const abiParameter = {
+    type: `${type}${match.array ?? ''}`,
+    ...name,
+    ...indexed,
+    ...components,
+  }
+  parameterCache.set(parameterCacheKey, abiParameter)
+  return abiParameter
+}
+
+// s/o latika for this
+export function splitParameters(
+  params: string,
+  result: string[] = [],
+  current = '',
+  depth = 0,
+): readonly string[] {
+  const length = params.trim().length
+  // biome-ignore lint/correctness/noUnreachable: recursive
+  for (let i = 0; i < length; i++) {
+    const char = params[i]
+    const tail = params.slice(i + 1)
+    switch (char) {
+      case ',':
+        return depth === 0
+          ? splitParameters(tail, [...result, current.trim()])
+          : splitParameters(tail, result, `${current}${char}`, depth)
+      case '(':
+        return splitParameters(tail, result, `${current}${char}`, depth + 1)
+      case ')':
+        return splitParameters(tail, result, `${current}${char}`, depth - 1)
+      default:
+        return splitParameters(tail, result, `${current}${char}`, depth)
+    }
+  }
+
+  if (current === '') return result
+  if (depth !== 0) throw new InvalidParenthesisError({ current, depth })
+
+  result.push(current.trim())
+  return result
+}
+
+export function isSolidityType(
+  type: string,
+): type is Exclude<AbiType, SolidityTuple | SolidityArray> {
+  return (
+    type === 'address' ||
+    type === 'bool' ||
+    type === 'function' ||
+    type === 'string' ||
+    bytesRegex.test(type) ||
+    integerRegex.test(type)
+  )
+}
+
+const protectedKeywordsRegex =
+  /^(?:after|alias|anonymous|apply|auto|byte|calldata|case|catch|constant|copyof|default|defined|error|event|external|false|final|function|immutable|implements|in|indexed|inline|internal|let|mapping|match|memory|mutable|null|of|override|partial|private|promise|public|pure|reference|relocatable|return|returns|sizeof|static|storage|struct|super|supports|switch|this|true|try|typedef|typeof|var|view|virtual)$/
+
+/** @internal */
+export function isSolidityKeyword(name: string) {
+  return (
+    name === 'address' ||
+    name === 'bool' ||
+    name === 'function' ||
+    name === 'string' ||
+    name === 'tuple' ||
+    bytesRegex.test(name) ||
+    integerRegex.test(name) ||
+    protectedKeywordsRegex.test(name)
+  )
+}
+
+/** @internal */
+export function isValidDataLocation(
+  type: string,
+  isArray: boolean,
+): type is Exclude<
+  AbiType,
+  SolidityString | Extract<SolidityBytes, 'bytes'> | SolidityArray
+> {
+  return isArray || type === 'bytes' || type === 'string' || type === 'tuple'
+}

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

@@ -0,0 +1,255 @@
+import { assertType, expectTypeOf, test } from 'vp/test'
+
+import type {
+  IsConstructorSignature,
+  IsErrorSignature,
+  IsEventSignature,
+  IsFallbackSignature,
+  IsFunctionSignature,
+  IsName,
+  IsSignature,
+  IsSolidityKeyword,
+  IsStructSignature,
+  IsValidCharacter,
+  Signature,
+  Signatures,
+  SolidityKeywords,
+  ValidateName,
+} from './signatures.js'
+
+test('IsErrorSignature', () => {
+  // basic
+  assertType<IsErrorSignature<'error Foo()'>>(true)
+
+  // params
+  assertType<IsErrorSignature<'error Foo(string bar)'>>(true)
+  assertType<IsErrorSignature<'error Foo(string bar, string baz)'>>(true)
+  assertType<IsErrorSignature<'error Foo(string bar, (string baz))'>>(true)
+
+  // invalid
+  assertType<IsErrorSignature<'error ()'>>(false)
+  assertType<IsErrorSignature<'Foo()'>>(false)
+  assertType<IsErrorSignature<'error Foo(string bar'>>(false)
+  assertType<IsErrorSignature<'event Foo((string) indexed name)'>>(false)
+})
+
+test('IsEventSignature', () => {
+  // basic
+  assertType<IsEventSignature<'event Foo()'>>(true)
+
+  // params
+  assertType<IsEventSignature<'event Foo(string bar)'>>(true)
+  assertType<IsEventSignature<'event Foo(string bar, string baz)'>>(true)
+  assertType<IsEventSignature<'event Foo(string bar, (string baz))'>>(true)
+
+  // invalid
+  assertType<IsEventSignature<'event ()'>>(false)
+  assertType<IsEventSignature<'Foo()'>>(false)
+  assertType<IsEventSignature<'event Foo(string bar'>>(false)
+})
+
+test('IsFunctionSignature', () => {
+  // basic
+  assertType<IsFunctionSignature<'function foo()'>>(true)
+  assertType<IsFunctionSignature<'function foo() returns (uint256)'>>(true)
+  assertType<IsFunctionSignature<'function foo() returns(uint256)'>>(true)
+  assertType<IsFunctionSignature<'function foo() view'>>(true)
+  assertType<IsFunctionSignature<'function foo() public'>>(true)
+  // combinations
+  assertType<IsFunctionSignature<'function foo() view returns (uint256)'>>(true)
+  assertType<IsFunctionSignature<'function foo() view returns(uint256)'>>(true)
+  assertType<IsFunctionSignature<'function foo() public view'>>(true)
+  assertType<
+    IsFunctionSignature<'function foo() public view returns (uint256)'>
+  >(true)
+  assertType<
+    IsFunctionSignature<'function foo() public view returns(uint256)'>
+  >(true)
+  // params
+  assertType<IsFunctionSignature<'function foo(uint256, uint256)'>>(true)
+  assertType<IsFunctionSignature<'function foo(uint256) returns (uint256)'>>(
+    true,
+  )
+  assertType<IsFunctionSignature<'function foo(uint256) returns(uint256)'>>(
+    true,
+  )
+  assertType<IsFunctionSignature<'function foo(uint256) view'>>(true)
+  assertType<IsFunctionSignature<'function foo(uint256) public'>>(true)
+  assertType<
+    IsFunctionSignature<'function foo(uint256) view returns (uint256)'>
+  >(true)
+  assertType<
+    IsFunctionSignature<'function foo(uint256) view returns(uint256)'>
+  >(true)
+  assertType<IsFunctionSignature<'function foo(uint256) public view'>>(true)
+  assertType<
+    IsFunctionSignature<'function foo(uint256) public view returns (uint256)'>
+  >(true)
+  assertType<
+    IsFunctionSignature<'function foo(uint256) public view returns(uint256)'>
+  >(true)
+  assertType<
+    IsFunctionSignature<'function foo(uint256) public view returns (uint256 tokenId)'>
+  >(true)
+  assertType<
+    IsFunctionSignature<'function foo(uint256) public view returns(uint256 tokenId)'>
+  >(true)
+  assertType<
+    IsFunctionSignature<'function foo(uint256) public view returns (uint256 tokenId, uint256 balance)'>
+  >(true)
+  assertType<
+    IsFunctionSignature<'function foo(uint256) public view returns(uint256 tokenId, uint256 balance)'>
+  >(true)
+
+  // invalid
+  assertType<IsFunctionSignature<'function ()'>>(false)
+  assertType<IsFunctionSignature<'function foo() '>>(false)
+  assertType<IsFunctionSignature<'function foo()  public'>>(false)
+  assertType<IsFunctionSignature<'function foo() re turns (uint256)'>>(false)
+  assertType<IsFunctionSignature<'function foo() re tur ns (uint256)'>>(false)
+  assertType<IsFunctionSignature<'foo()'>>(false)
+})
+
+test('IsStructSignature', () => {
+  // basic
+  assertType<IsStructSignature<'struct Foo {}'>>(true)
+
+  // properties
+  assertType<IsStructSignature<'struct Foo { string bar; }'>>(true)
+  assertType<IsStructSignature<'struct Foo { string bar; string baz; }'>>(true)
+  assertType<IsStructSignature<'struct Foo { string bar; (string baz) baz; }'>>(
+    true,
+  )
+
+  // invalid
+  assertType<IsStructSignature<'struct {}'>>(false)
+  assertType<IsStructSignature<'Foo {}'>>(false)
+  assertType<IsStructSignature<'struct Foo {string bar'>>(false)
+})
+
+test('IsConstructorSignature', () => {
+  assertType<IsConstructorSignature<'constructor()'>>(true)
+  assertType<IsConstructorSignature<'constructor() payable'>>(true)
+  assertType<IsConstructorSignature<'constructor(string)'>>(true)
+  assertType<IsConstructorSignature<'constructor(string name)'>>(true)
+  assertType<IsConstructorSignature<'constructor(string name, string symbol)'>>(
+    true,
+  )
+  assertType<IsConstructorSignature<'constructor(string memory name)'>>(true)
+  assertType<IsConstructorSignature<'constructor(string memory name) payable'>>(
+    true,
+  )
+
+  assertType<IsConstructorSignature<'constructor()payable'>>(false)
+  assertType<IsConstructorSignature<'constructor(string'>>(false)
+})
+
+test('IsFallbackSignature', () => {
+  assertType<IsFallbackSignature<'fallback() external'>>(true)
+  assertType<IsFallbackSignature<'fallback() external payable'>>(true)
+
+  assertType<IsFallbackSignature<'fallback() externalpayable'>>(false)
+  assertType<IsFallbackSignature<'fallback() external nonpayable'>>(false)
+  assertType<IsFallbackSignature<'fallback()'>>(false)
+})
+
+test('IsSignature', () => {
+  // basic
+  assertType<IsSignature<'function foo()'>>(true)
+  assertType<IsSignature<'constructor()'>>(true)
+  assertType<IsSignature<'fallback() external'>>(true)
+  assertType<IsSignature<'receive() external payable'>>(true)
+  assertType<IsSignature<'event Foo()'>>(true)
+  assertType<IsSignature<'error Foo()'>>(true)
+  assertType<IsSignature<'struct Foo {}'>>(true)
+
+  // invalid
+  assertType<IsSignature<'foo()'>>(false)
+  assertType<IsSignature<'function ()'>>(false)
+  assertType<IsSignature<'constructor ()'>>(false)
+  assertType<IsSignature<'fallback ()'>>(false)
+  assertType<IsSignature<'receive() payable'>>(false)
+  assertType<IsSignature<'event ()'>>(false)
+  assertType<IsSignature<'error ()'>>(false)
+  assertType<IsSignature<'struct {}'>>(false)
+})
+
+test('Signature', () => {
+  assertType<Signature<'function foo()'>>('function foo()')
+  assertType<Signature<'function foo ()'>>([
+    'Error: Signature "function foo ()" is invalid.',
+  ])
+  // assertType<Signature<'function foo??()'>>([
+  //   'Error: Signature "function foo??()" is invalid.',
+  // ])
+})
+
+test('Signatures', () => {
+  assertType<Signatures<['function foo()']>>(['function foo()'])
+  assertType<Signatures<['function foo ()']>>([
+    ['Error: Signature "function foo ()" is invalid at position 0.'],
+  ])
+})
+
+test('IsName', () => {
+  expectTypeOf<IsName<''>>().toEqualTypeOf<false>()
+  expectTypeOf<IsName<'   '>>().toEqualTypeOf<false>()
+  expectTypeOf<IsName<'foo'>>().toEqualTypeOf<true>()
+  // no whitespace
+  expectTypeOf<IsName<' foo'>>().toEqualTypeOf<false>()
+  expectTypeOf<IsName<'foo '>>().toEqualTypeOf<false>()
+  expectTypeOf<IsName<' foo '>>().toEqualTypeOf<false>()
+  // no solidity keywords
+  expectTypeOf<IsName<'alias'>>().toEqualTypeOf<false>()
+  expectTypeOf<IsName<'copyof'>>().toEqualTypeOf<false>()
+  expectTypeOf<IsName<'virtual'>>().toEqualTypeOf<false>()
+  // no number strings
+  expectTypeOf<IsName<'123'>>().toEqualTypeOf<false>()
+  expectTypeOf<IsName<'12foo'>>().toEqualTypeOf<false>()
+  // no invalid characters
+  // expectTypeOf<IsName<'foo?'>>().toEqualTypeOf<false>()
+  // expectTypeOf<IsName<'foo,'>>().toEqualTypeOf<false>()
+})
+
+test('ValidateName', () => {
+  expectTypeOf<ValidateName<'foo'>>().toEqualTypeOf<'foo'>()
+  expectTypeOf<ValidateName<'foo$', true>>().toEqualTypeOf<'foo$'>()
+  expectTypeOf<ValidateName<'foo bar'>>().toEqualTypeOf<
+    ['Error: Identifier "foo bar" cannot contain whitespace.']
+  >()
+  expectTypeOf<ValidateName<'alias'>>().toEqualTypeOf<
+    ['Error: "alias" is a protected Solidity keyword.']
+  >()
+  expectTypeOf<ValidateName<'123'>>().toEqualTypeOf<
+    ['Error: Identifier "123" cannot be a number string.']
+  >()
+  expectTypeOf<ValidateName<'12foo'>>().toEqualTypeOf<
+    ['Error: Identifier "12foo" cannot start with a number.']
+  >()
+  expectTypeOf<ValidateName<'foo?', true>>().toEqualTypeOf<
+    ['Error: "foo?" contains invalid character.']
+  >()
+})
+
+test('IsSolidityKeyword', () => {
+  expectTypeOf<IsSolidityKeyword<SolidityKeywords>>().toEqualTypeOf<true>()
+  expectTypeOf<IsSolidityKeyword<'calldata'>>().toEqualTypeOf<true>()
+  expectTypeOf<IsSolidityKeyword<'byte'>>().toEqualTypeOf<true>()
+  expectTypeOf<IsSolidityKeyword<'memory'>>().toEqualTypeOf<true>()
+
+  expectTypeOf<IsSolidityKeyword<'foo'>>().toEqualTypeOf<false>()
+  expectTypeOf<IsSolidityKeyword<'bar'>>().toEqualTypeOf<false>()
+})
+
+test('IsValidCharacter', () => {
+  expectTypeOf<IsValidCharacter<'A'>>().toEqualTypeOf<true>()
+  expectTypeOf<IsValidCharacter<'foobarbaz'>>().toEqualTypeOf<true>()
+  expectTypeOf<IsValidCharacter<'123123'>>().toEqualTypeOf<true>()
+  expectTypeOf<IsValidCharacter<'___'>>().toEqualTypeOf<true>()
+  expectTypeOf<IsValidCharacter<'$$$'>>().toEqualTypeOf<true>()
+  expectTypeOf<IsValidCharacter<'foo_123'>>().toEqualTypeOf<true>()
+  expectTypeOf<IsValidCharacter<'foo_123?'>>().toEqualTypeOf<false>()
+  expectTypeOf<IsValidCharacter<'foo!123'>>().toEqualTypeOf<false>()
+  expectTypeOf<IsValidCharacter<''>>().toEqualTypeOf<false>()
+  expectTypeOf<IsValidCharacter<'         '>>().toEqualTypeOf<false>()
+})