Function parse

packages/typechain/src/parser/abiParser.ts:148–211

(abi: RawAbiDefinition[], path: string, documentation?: DocumentationResult)

}

export function parse(abi: RawAbiDefinition[], path: string, documentation?: DocumentationResult): Contract {
  const constructors: FunctionWithoutOutputDeclaration[] = []
  let fallback: FunctionWithoutInputDeclaration | undefined
  const functions: FunctionDeclaration[] = []
  const events: EventDeclaration[] = []

  const structs: StructType[] = []
  function registerStruct(newStruct: StructType) {
    // ignore registration if structName not present
    if (newStruct.structName === undefined) return
    // if struct array (recursive) then keep going deep until we reach the struct tuple
    while (newStruct.type === 'array') {
      newStruct = newStruct.itemType as StructType
    }
    // only register if not already registered
    const newStructName = newStruct.structName?.toString()
    if (!structs.find((s) => s.structName?.toString() === newStructName)) {
      structs.push(newStruct)
    }
  }

  abi.forEach((abiPiece) => {
    if (abiPiece.type === 'fallback') {
      if (fallback) {
        throw new Error(
          `Fallback function can't be defined more than once! ${JSON.stringify(
            abiPiece,
          )} Previously defined: ${JSON.stringify(fallback)}`,
        )
      }
      fallback = parseFallback(abiPiece, registerStruct)
      return
    }

    if (abiPiece.type === 'constructor') {
      constructors.push(parseConstructor(abiPiece, registerStruct))
      return
    }

    if (abiPiece.type === 'function') {
      functions.push(parseFunctionDeclaration(abiPiece, registerStruct, documentation))
      return
    }

    if (abiPiece.type === 'event') {
      const eventAbi = abiPiece as any as RawEventAbiDefinition

      events.push(parseEvent(eventAbi, registerStruct))
      return
    }

    debug(`Unrecognized abi element: ${abiPiece.type}`)
  })

  return {
    ...parseContractPath(path),
    fallback,
    constructor: constructors,