Class ParserWrapper

src/parser/index.ts:25–197

}

export class ParserWrapper {
  enums: Record<string, AbiEnum> = {}
  structs: Record<string, AbiStruct> = {};
  functions: Record<string, AbiFunction> = {}
  errors: Record<string, AbiError> = {}
  events: Record<string, AbiEvent> = {}

  constructor(parsed: DefinedType[]) {
    let i = 0;
    let n = 0;
    while (n < parsed.length && i < 50) for (let p of parsed) if (this.handleType(p)) (i++ && n++);
  }

  get allStructs(): AbiType<false, false>[] {
    return [
      ...Object.values(this.structs),
      ...Object.values(this.enums)
    ]
  }

  get allErrors(): AbiError[] {
    return Object.values(this.errors)
  }

  get allEvents(): AbiEvent[] {
    return Object.values(this.events)
  }

  get allFunctions(): AbiFunction[] {
    return Object.values(this.functions)
  }
  
  handleFields(fields: StructField[]) {
    const outFields: AbiStructField[] = [];
    let size = 0;
    for (let field of fields) {
      let { name, typeName, coderType, accessors } = field;
      const abiType = this.convertFieldType(typeName);
      if (!abiType) return null;
      const outField: AbiStructField = { name, type: abiType, coderType, accessors }
      if ((field as any).isIndexed) {
        (outField as any).isIndexed = (field as any).isIndexed
      }
      outFields.push(outField);
      if (abiType.size == null) size = null;
      else if (size != null) size += abiType.size;
    }
    return {
      fields: outFields,
      dynamic: size == null,
      size
    }
  }

  buildGroup(struct: AbiStruct, group: GroupType): StructGroup {
    const members: AbiStructField[] = []
    for (const member of group.members) {
      const field = struct.fields.find((field) => field.name === member.name);