Function parseEvmType

packages/typechain/src/parser/parseEvmType.ts:76–154

(rawType: string, components?: EvmSymbol[], internalType?: string)

const isBytesTypeRegex = /^bytes([0-9]+)$/

export function parseEvmType(rawType: string, components?: EvmSymbol[], internalType?: string): EvmType {
  const lastChar = rawType[rawType.length - 1]

  // first we parse array type
  if (lastChar === ']') {
    let finishArrayTypeIndex = rawType.length - 2
    while (rawType[finishArrayTypeIndex] !== '[') {
      finishArrayTypeIndex--
    }

    const arraySizeRaw = rawType.slice(finishArrayTypeIndex + 1, rawType.length - 1)
    const arraySize = arraySizeRaw !== '' ? parseInt(arraySizeRaw) : undefined

    const restOfTheType = rawType.slice(0, finishArrayTypeIndex)

    const result: ArrayType = {
      type: 'array',
      itemType: parseEvmType(restOfTheType, components, internalType),
      originalType: rawType,
    }
    if (arraySize) result.size = arraySize
    const structName = extractStructNameIfAvailable(internalType)
    if (structName) result.structName = structName

    return result
  }

  // otherwise this has to be primitive type

  // deal with simple to parse types
  switch (rawType) {
    case 'bool':
      return { type: 'boolean', originalType: rawType }
    case 'address':
      return { type: 'address', originalType: rawType }
    case 'string':
      return { type: 'string', originalType: rawType }
    case 'byte':
      return { type: 'bytes', size: 1, originalType: rawType }
    case 'bytes':
      return { type: 'dynamic-bytes', originalType: rawType }
    case 'tuple':
      if (!components) throw new Error('Tuple specified without components!')
      const result: TupleType = { type: 'tuple', components, originalType: rawType }
      const structName = extractStructNameIfAvailable(internalType)
      if (structName) result.structName = structName
      return result
  }

  if (isUIntTypeRegex.test(rawType)) {
    const match = isUIntTypeRegex.exec(rawType)
    return { type: 'uinteger', bits: parseInt(match![1] || '256'), originalType: rawType }
  }

  if (isIntTypeRegex.test(rawType)) {
    const match = isIntTypeRegex.exec(rawType)
    return { type: 'integer', bits: parseInt(match![1] || '256'), originalType: rawType }
  }