Method handleType

src/parser/index.ts:96–167

(input: DefinedType)

  }

  handleType(input: DefinedType): AbiType<true, true> | AbiFunction {
    if (input.type == 'EnumDefinition') {
      const { type, name, fields, namePath } = <EnumType> input;
      const out: AbiType = {
        meta: 'enum',
        name,
        fields,
        dynamic: false,
        size: bitsRequired(fields.length)
      };
      return this.putEnum(namePath, out);
    }
    if (input.type == 'StructDefinition') {
      // console.log(input)
      const { name, fields: _fields, namePath, coderType, accessors, groups } = <StructType> input;
      const { fields, size, dynamic } = this.handleFields(_fields);

      const struct: AbiType = {
        meta: 'struct',
        size,
        dynamic,
        name,
        fields,
        coderType,
        accessors,
        groups
      }
      // struct.groups = groups.map(group => this.buildGroup(struct, group));

      return this.putStruct(namePath, struct);
    }
    if (input.type == 'CustomErrorDefinition') {
      const { name, fields: _fields, namePath } = <ErrorType> input;
      const { fields, size, dynamic } = this.handleFields(_fields);

      const error: AbiError = {
        meta: 'error',
        size,
        dynamic,
        name,
        fields
      }
      return this.putError(namePath, error as AbiError);
    }
    if (input.type == 'FunctionDefinition') {
      const { stateMutability, visibility, name, namePath } = <FunctionType> input;
      const inputs = this.handleFields(input.input)
      const outputs = this.handleFields(input.output)
      const fn: AbiFunction = {
        meta: "function",
        name,
        stateMutability,
        visibility,
        input: inputs,
        output: outputs
      }
      return this.putFunction(namePath, fn);
    }