/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */
import { BigNumberish, Overrides } from "ethers";
import { HandlerOptions } from "@sentio/sdk";
import {
  addContractByABI,
  getContractByABI,
  addProcessor,
  getProcessor,
  getProvider,
  transformEtherError,
  BindOptions,
  BaseProcessor,
  BaseProcessorTemplate,
  BoundContractView,
  ContractContext,
  ContractView,
  DummyProvider,
  EthChainId,
  TypedCallTrace,
  EthContext,
  EthFetchConfig,
  PreprocessResult,
  encodeCallData,
} from "@sentio/sdk/eth";
import { EthCallParam, EthCallContext, PreparedData } from "@sentio/protos";

import { EACAggregatorProxy__factory } from "./index.js";
import {
  EACAggregatorProxy,
  AnswerUpdatedEvent,
  AnswerUpdatedEventFilter,
  NewRoundEvent,
  NewRoundEventFilter,
  OwnershipTransferRequestedEvent,
  OwnershipTransferRequestedEventFilter,
  OwnershipTransferredEvent,
  OwnershipTransferredEventFilter,
} from "./EACAggregatorProxy.js";

export interface AcceptOwnershipCallObject {}

export type AcceptOwnershipCallTrace = TypedCallTrace<
  [],
  AcceptOwnershipCallObject
>;

export interface AccessControllerCallObject {}

export type AccessControllerCallTrace = TypedCallTrace<
  [],
  AccessControllerCallObject
>;

export interface AggregatorCallObject {}

export type AggregatorCallTrace = TypedCallTrace<[], AggregatorCallObject>;

export interface ConfirmAggregatorCallObject {
  _aggregator: string;
}

export type ConfirmAggregatorCallTrace = TypedCallTrace<
  [string],
  ConfirmAggregatorCallObject
>;

export interface DecimalsCallObject {}

export type DecimalsCallTrace = TypedCallTrace<[], DecimalsCallObject>;

export interface DescriptionCallObject {}

export type DescriptionCallTrace = TypedCallTrace<[], DescriptionCallObject>;

export interface GetAnswerCallObject {
  _roundId: bigint;
}

export type GetAnswerCallTrace = TypedCallTrace<[bigint], GetAnswerCallObject>;

export interface GetRoundDataCallObject {
  _roundId: bigint;
}

export type GetRoundDataCallTrace = TypedCallTrace<
  [bigint],
  GetRoundDataCallObject
>;

export interface GetTimestampCallObject {
  _roundId: bigint;
}

export type GetTimestampCallTrace = TypedCallTrace<
  [bigint],
  GetTimestampCallObject
>;

export interface LatestAnswerCallObject {}

export type LatestAnswerCallTrace = TypedCallTrace<[], LatestAnswerCallObject>;

export interface LatestRoundCallObject {}

export type LatestRoundCallTrace = TypedCallTrace<[], LatestRoundCallObject>;

export interface LatestRoundDataCallObject {}

export type LatestRoundDataCallTrace = TypedCallTrace<
  [],
  LatestRoundDataCallObject
>;

export interface LatestTimestampCallObject {}

export type LatestTimestampCallTrace = TypedCallTrace<
  [],
  LatestTimestampCallObject
>;

export interface OwnerCallObject {}

export type OwnerCallTrace = TypedCallTrace<[], OwnerCallObject>;

export interface PhaseAggregatorsCallObject {}

export type PhaseAggregatorsCallTrace = TypedCallTrace<
  [bigint],
  PhaseAggregatorsCallObject
>;

export interface PhaseIdCallObject {}

export type PhaseIdCallTrace = TypedCallTrace<[], PhaseIdCallObject>;

export interface ProposeAggregatorCallObject {
  _aggregator: string;
}

export type ProposeAggregatorCallTrace = TypedCallTrace<
  [string],
  ProposeAggregatorCallObject
>;

export interface ProposedAggregatorCallObject {}

export type ProposedAggregatorCallTrace = TypedCallTrace<
  [],
  ProposedAggregatorCallObject
>;

export interface ProposedGetRoundDataCallObject {
  _roundId: bigint;
}

export type ProposedGetRoundDataCallTrace = TypedCallTrace<
  [bigint],
  ProposedGetRoundDataCallObject
>;

export interface ProposedLatestRoundDataCallObject {}

export type ProposedLatestRoundDataCallTrace = TypedCallTrace<
  [],
  ProposedLatestRoundDataCallObject
>;

export interface SetControllerCallObject {
  _accessController: string;
}

export type SetControllerCallTrace = TypedCallTrace<
  [string],
  SetControllerCallObject
>;

export interface TransferOwnershipCallObject {
  _to: string;
}

export type TransferOwnershipCallTrace = TypedCallTrace<
  [string],
  TransferOwnershipCallObject
>;

export interface VersionCallObject {}

export type VersionCallTrace = TypedCallTrace<[], VersionCallObject>;

const templateContract = EACAggregatorProxy__factory.connect(
  "0x0",
  DummyProvider,
);

export class EACAggregatorProxyContractView extends ContractView<EACAggregatorProxy> {
  constructor(contract: EACAggregatorProxy) {
    super(contract);
    this.callStatic.contract = contract;
  }

  async accessController(
    overrides?: Overrides,
    preparedData?: PreparedData,
    ethCallContext?: EthCallContext,
  ): Promise<string> {
    try {
      return await this.contract.getFunction("accessController()")(
        overrides || {},
      );
    } catch (e) {
      const stack = new Error().stack;
      throw transformEtherError(e, undefined, stack);
    }
  }

  async aggregator(
    overrides?: Overrides,
    preparedData?: PreparedData,
    ethCallContext?: EthCallContext,
  ): Promise<string> {
    try {
      return await this.contract.getFunction("aggregator()")(overrides || {});
    } catch (e) {
      const stack = new Error().stack;
      throw transformEtherError(e, undefined, stack);
    }
  }

  async decimals(
    overrides?: Overrides,
    preparedData?: PreparedData,
    ethCallContext?: EthCallContext,
  ): Promise<bigint> {
    try {
      return await this.contract.getFunction("decimals()")(overrides || {});
    } catch (e) {
      const stack = new Error().stack;
      throw transformEtherError(e, undefined, stack);
    }
  }

  async description(
    overrides?: Overrides,
    preparedData?: PreparedData,
    ethCallContext?: EthCallContext,
  ): Promise<string> {
    try {
      return await this.contract.getFunction("description()")(overrides || {});
    } catch (e) {
      const stack = new Error().stack;
      throw transformEtherError(e, undefined, stack);
    }
  }

  async getAnswer(
    _roundId: BigNumberish,
    overrides?: Overrides,
    preparedData?: PreparedData,
    ethCallContext?: EthCallContext,
  ): Promise<bigint> {
    try {
      return await this.contract.getFunction("getAnswer(uint256)")(
        _roundId,
        overrides || {},
      );
    } catch (e) {
      const stack = new Error().stack;
      throw transformEtherError(e, undefined, stack);
    }
  }

  async getRoundData(
    _roundId: BigNumberish,
    overrides?: Overrides,
    preparedData?: PreparedData,
    ethCallContext?: EthCallContext,
  ): Promise<
    [bigint, bigint, bigint, bigint, bigint] & {
      roundId: bigint;
      answer: bigint;
      startedAt: bigint;
      updatedAt: bigint;
      answeredInRound: bigint;
    }
  > {
    try {
      return await this.contract.getFunction("getRoundData(uint80)")(
        _roundId,
        overrides || {},
      );
    } catch (e) {
      const stack = new Error().stack;
      throw transformEtherError(e, undefined, stack);
    }
  }

  async getTimestamp(
    _roundId: BigNumberish,
    overrides?: Overrides,
    preparedData?: PreparedData,
    ethCallContext?: EthCallContext,
  ): Promise<bigint> {
    try {
      return await this.contract.getFunction("getTimestamp(uint256)")(
        _roundId,
        overrides || {},
      );
    } catch (e) {
      const stack = new Error().stack;
      throw transformEtherError(e, undefined, stack);
    }
  }

  async latestAnswer(
    overrides?: Overrides,
    preparedData?: PreparedData,
    ethCallContext?: EthCallContext,
  ): Promise<bigint> {
    try {
      return await this.contract.getFunction("latestAnswer()")(overrides || {});
    } catch (e) {
      const stack = new Error().stack;
      throw transformEtherError(e, undefined, stack);
    }
  }

  async latestRound(
    overrides?: Overrides,
    preparedData?: PreparedData,
    ethCallContext?: EthCallContext,
  ): Promise<bigint> {
    try {
      return await this.contract.getFunction("latestRound()")(overrides || {});
    } catch (e) {
      const stack = new Error().stack;
      throw transformEtherError(e, undefined, stack);
    }
  }

  async latestRoundData(
    overrides?: Overrides,
    preparedData?: PreparedData,
    ethCallContext?: EthCallContext,
  ): Promise<
    [bigint, bigint, bigint, bigint, bigint] & {
      roundId: bigint;
      answer: bigint;
      startedAt: bigint;
      updatedAt: bigint;
      answeredInRound: bigint;
    }
  > {
    try {
      return await this.contract.getFunction("latestRoundData()")(
        overrides || {},
      );
    } catch (e) {
      const stack = new Error().stack;
      throw transformEtherError(e, undefined, stack);
    }
  }

  async latestTimestamp(
    overrides?: Overrides,
    preparedData?: PreparedData,
    ethCallContext?: EthCallContext,
  ): Promise<bigint> {
    try {
      return await this.contract.getFunction("latestTimestamp()")(
        overrides || {},
      );
    } catch (e) {
      const stack = new Error().stack;
      throw transformEtherError(e, undefined, stack);
    }
  }

  async owner(
    overrides?: Overrides,
    preparedData?: PreparedData,
    ethCallContext?: EthCallContext,
  ): Promise<string> {
    try {
      return await this.contract.getFunction("owner()")(overrides || {});
    } catch (e) {
      const stack = new Error().stack;
      throw transformEtherError(e, undefined, stack);
    }
  }

  async phaseAggregators(
    arg0: BigNumberish,
    overrides?: Overrides,
    preparedData?: PreparedData,
    ethCallContext?: EthCallContext,
  ): Promise<string> {
    try {
      return await this.contract.getFunction("phaseAggregators(uint16)")(
        arg0,
        overrides || {},
      );
    } catch (e) {
      const stack = new Error().stack;
      throw transformEtherError(e, undefined, stack);
    }
  }

  async phaseId(
    overrides?: Overrides,
    preparedData?: PreparedData,
    ethCallContext?: EthCallContext,
  ): Promise<bigint> {
    try {
      return await this.contract.getFunction("phaseId()")(overrides || {});
    } catch (e) {
      const stack = new Error().stack;
      throw transformEtherError(e, undefined, stack);
    }
  }

  async proposedAggregator(
    overrides?: Overrides,
    preparedData?: PreparedData,
    ethCallContext?: EthCallContext,
  ): Promise<string> {
    try {
      return await this.contract.getFunction("proposedAggregator()")(
        overrides || {},
      );
    } catch (e) {
      const stack = new Error().stack;
      throw transformEtherError(e, undefined, stack);
    }
  }

  async proposedGetRoundData(
    _roundId: BigNumberish,
    overrides?: Overrides,
    preparedData?: PreparedData,
    ethCallContext?: EthCallContext,
  ): Promise<
    [bigint, bigint, bigint, bigint, bigint] & {
      roundId: bigint;
      answer: bigint;
      startedAt: bigint;
      updatedAt: bigint;
      answeredInRound: bigint;
    }
  > {
    try {
      return await this.contract.getFunction("proposedGetRoundData(uint80)")(
        _roundId,
        overrides || {},
      );
    } catch (e) {
      const stack = new Error().stack;
      throw transformEtherError(e, undefined, stack);
    }
  }

  async proposedLatestRoundData(
    overrides?: Overrides,
    preparedData?: PreparedData,
    ethCallContext?: EthCallContext,
  ): Promise<
    [bigint, bigint, bigint, bigint, bigint] & {
      roundId: bigint;
      answer: bigint;
      startedAt: bigint;
      updatedAt: bigint;
      answeredInRound: bigint;
    }
  > {
    try {
      return await this.contract.getFunction("proposedLatestRoundData()")(
        overrides || {},
      );
    } catch (e) {
      const stack = new Error().stack;
      throw transformEtherError(e, undefined, stack);
    }
  }

  async version(
    overrides?: Overrides,
    preparedData?: PreparedData,
    ethCallContext?: EthCallContext,
  ): Promise<bigint> {
    try {
      return await this.contract.getFunction("version()")(overrides || {});
    } catch (e) {
      const stack = new Error().stack;
      throw transformEtherError(e, undefined, stack);
    }
  }

  callStatic = {
    contract: this.contract,

    async acceptOwnership(
      overrides?: Overrides,
      preparedData?: PreparedData,
      ethCallContext?: EthCallContext,
    ): Promise<void> {
      try {
        return await this.contract
          .getFunction("acceptOwnership()")
          .staticCall(overrides || {});
      } catch (e) {
        const stack = new Error().stack;
        throw transformEtherError(e, undefined, stack);
      }
    },
    async confirmAggregator(
      _aggregator: string,
      overrides?: Overrides,
      preparedData?: PreparedData,
      ethCallContext?: EthCallContext,
    ): Promise<void> {
      try {
        return await this.contract
          .getFunction("confirmAggregator(address)")
          .staticCall(_aggregator, overrides || {});
      } catch (e) {
        const stack = new Error().stack;
        throw transformEtherError(e, undefined, stack);
      }
    },
    async proposeAggregator(
      _aggregator: string,
      overrides?: Overrides,
      preparedData?: PreparedData,
      ethCallContext?: EthCallContext,
    ): Promise<void> {
      try {
        return await this.contract
          .getFunction("proposeAggregator(address)")
          .staticCall(_aggregator, overrides || {});
      } catch (e) {
        const stack = new Error().stack;
        throw transformEtherError(e, undefined, stack);
      }
    },
    async setController(
      _accessController: string,
      overrides?: Overrides,
      preparedData?: PreparedData,
      ethCallContext?: EthCallContext,
    ): Promise<void> {
      try {
        return await this.contract
          .getFunction("setController(address)")
          .staticCall(_accessController, overrides || {});
      } catch (e) {
        const stack = new Error().stack;
        throw transformEtherError(e, undefined, stack);
      }
    },
    async transferOwnership(
      _to: string,
      overrides?: Overrides,
      preparedData?: PreparedData,
      ethCallContext?: EthCallContext,
    ): Promise<void> {
      try {
        return await this.contract
          .getFunction("transferOwnership(address)")
          .staticCall(_to, overrides || {});
      } catch (e) {
        const stack = new Error().stack;
        throw transformEtherError(e, undefined, stack);
      }
    },
  };

  encodeCall = {
    acceptOwnership(callContext: EthCallContext): EthCallParam {
      return encodeCallData(
        callContext,
        "acceptOwnership",
        "function acceptOwnership()",
        [],
      );
    },
    accessController(callContext: EthCallContext): EthCallParam {
      return encodeCallData(
        callContext,
        "accessController",
        "function accessController()",
        [],
      );
    },
    aggregator(callContext: EthCallContext): EthCallParam {
      return encodeCallData(
        callContext,
        "aggregator",
        "function aggregator()",
        [],
      );
    },
    confirmAggregator(
      _aggregator: string,
      callContext: EthCallContext,
    ): EthCallParam {
      return encodeCallData(
        callContext,
        "confirmAggregator",
        "function confirmAggregator(address)",
        [_aggregator],
      );
    },
    decimals(callContext: EthCallContext): EthCallParam {
      return encodeCallData(callContext, "decimals", "function decimals()", []);
    },
    description(callContext: EthCallContext): EthCallParam {
      return encodeCallData(
        callContext,
        "description",
        "function description()",
        [],
      );
    },
    getAnswer(
      _roundId: BigNumberish,
      callContext: EthCallContext,
    ): EthCallParam {
      return encodeCallData(
        callContext,
        "getAnswer",
        "function getAnswer(uint256)",
        [_roundId],
      );
    },
    getRoundData(
      _roundId: BigNumberish,
      callContext: EthCallContext,
    ): EthCallParam {
      return encodeCallData(
        callContext,
        "getRoundData",
        "function getRoundData(uint80)",
        [_roundId],
      );
    },
    getTimestamp(
      _roundId: BigNumberish,
      callContext: EthCallContext,
    ): EthCallParam {
      return encodeCallData(
        callContext,
        "getTimestamp",
        "function getTimestamp(uint256)",
        [_roundId],
      );
    },
    latestAnswer(callContext: EthCallContext): EthCallParam {
      return encodeCallData(
        callContext,
        "latestAnswer",
        "function latestAnswer()",
        [],
      );
    },
    latestRound(callContext: EthCallContext): EthCallParam {
      return encodeCallData(
        callContext,
        "latestRound",
        "function latestRound()",
        [],
      );
    },
    latestRoundData(callContext: EthCallContext): EthCallParam {
      return encodeCallData(
        callContext,
        "latestRoundData",
        "function latestRoundData()",
        [],
      );
    },
    latestTimestamp(callContext: EthCallContext): EthCallParam {
      return encodeCallData(
        callContext,
        "latestTimestamp",
        "function latestTimestamp()",
        [],
      );
    },
    owner(callContext: EthCallContext): EthCallParam {
      return encodeCallData(callContext, "owner", "function owner()", []);
    },
    phaseAggregators(
      arg0: BigNumberish,
      callContext: EthCallContext,
    ): EthCallParam {
      return encodeCallData(
        callContext,
        "phaseAggregators",
        "function phaseAggregators(uint16)",
        [arg0],
      );
    },
    phaseId(callContext: EthCallContext): EthCallParam {
      return encodeCallData(callContext, "phaseId", "function phaseId()", []);
    },
    proposeAggregator(
      _aggregator: string,
      callContext: EthCallContext,
    ): EthCallParam {
      return encodeCallData(
        callContext,
        "proposeAggregator",
        "function proposeAggregator(address)",
        [_aggregator],
      );
    },
    proposedAggregator(callContext: EthCallContext): EthCallParam {
      return encodeCallData(
        callContext,
        "proposedAggregator",
        "function proposedAggregator()",
        [],
      );
    },
    proposedGetRoundData(
      _roundId: BigNumberish,
      callContext: EthCallContext,
    ): EthCallParam {
      return encodeCallData(
        callContext,
        "proposedGetRoundData",
        "function proposedGetRoundData(uint80)",
        [_roundId],
      );
    },
    proposedLatestRoundData(callContext: EthCallContext): EthCallParam {
      return encodeCallData(
        callContext,
        "proposedLatestRoundData",
        "function proposedLatestRoundData()",
        [],
      );
    },
    setController(
      _accessController: string,
      callContext: EthCallContext,
    ): EthCallParam {
      return encodeCallData(
        callContext,
        "setController",
        "function setController(address)",
        [_accessController],
      );
    },
    transferOwnership(_to: string, callContext: EthCallContext): EthCallParam {
      return encodeCallData(
        callContext,
        "transferOwnership",
        "function transferOwnership(address)",
        [_to],
      );
    },
    version(callContext: EthCallContext): EthCallParam {
      return encodeCallData(callContext, "version", "function version()", []);
    },
  };
}

export class EACAggregatorProxyBoundContractView extends BoundContractView<
  EACAggregatorProxy,
  EACAggregatorProxyContractView
> {
  async accessController(overrides?: Overrides): Promise<string> {
    return await this.view.accessController(
      {
        blockTag: this.context.blockNumber,
        ...overrides,
      },
      this.context.preparedData,
      this.context.getEthCallContext(),
    );
  }

  async aggregator(overrides?: Overrides): Promise<string> {
    return await this.view.aggregator(
      {
        blockTag: this.context.blockNumber,
        ...overrides,
      },
      this.context.preparedData,
      this.context.getEthCallContext(),
    );
  }

  async decimals(overrides?: Overrides): Promise<bigint> {
    return await this.view.decimals(
      {
        blockTag: this.context.blockNumber,
        ...overrides,
      },
      this.context.preparedData,
      this.context.getEthCallContext(),
    );
  }

  async description(overrides?: Overrides): Promise<string> {
    return await this.view.description(
      {
        blockTag: this.context.blockNumber,
        ...overrides,
      },
      this.context.preparedData,
      this.context.getEthCallContext(),
    );
  }

  async getAnswer(
    _roundId: BigNumberish,
    overrides?: Overrides,
  ): Promise<bigint> {
    return await this.view.getAnswer(
      _roundId,
      {
        blockTag: this.context.blockNumber,
        ...overrides,
      },
      this.context.preparedData,
      this.context.getEthCallContext(),
    );
  }

  async getRoundData(
    _roundId: BigNumberish,
    overrides?: Overrides,
  ): Promise<
    [bigint, bigint, bigint, bigint, bigint] & {
      roundId: bigint;
      answer: bigint;
      startedAt: bigint;
      updatedAt: bigint;
      answeredInRound: bigint;
    }
  > {
    return await this.view.getRoundData(
      _roundId,
      {
        blockTag: this.context.blockNumber,
        ...overrides,
      },
      this.context.preparedData,
      this.context.getEthCallContext(),
    );
  }

  async getTimestamp(
    _roundId: BigNumberish,
    overrides?: Overrides,
  ): Promise<bigint> {
    return await this.view.getTimestamp(
      _roundId,
      {
        blockTag: this.context.blockNumber,
        ...overrides,
      },
      this.context.preparedData,
      this.context.getEthCallContext(),
    );
  }

  async latestAnswer(overrides?: Overrides): Promise<bigint> {
    return await this.view.latestAnswer(
      {
        blockTag: this.context.blockNumber,
        ...overrides,
      },
      this.context.preparedData,
      this.context.getEthCallContext(),
    );
  }

  async latestRound(overrides?: Overrides): Promise<bigint> {
    return await this.view.latestRound(
      {
        blockTag: this.context.blockNumber,
        ...overrides,
      },
      this.context.preparedData,
      this.context.getEthCallContext(),
    );
  }

  async latestRoundData(
    overrides?: Overrides,
  ): Promise<
    [bigint, bigint, bigint, bigint, bigint] & {
      roundId: bigint;
      answer: bigint;
      startedAt: bigint;
      updatedAt: bigint;
      answeredInRound: bigint;
    }
  > {
    return await this.view.latestRoundData(
      {
        blockTag: this.context.blockNumber,
        ...overrides,
      },
      this.context.preparedData,
      this.context.getEthCallContext(),
    );
  }

  async latestTimestamp(overrides?: Overrides): Promise<bigint> {
    return await this.view.latestTimestamp(
      {
        blockTag: this.context.blockNumber,
        ...overrides,
      },
      this.context.preparedData,
      this.context.getEthCallContext(),
    );
  }

  async owner(overrides?: Overrides): Promise<string> {
    return await this.view.owner(
      {
        blockTag: this.context.blockNumber,
        ...overrides,
      },
      this.context.preparedData,
      this.context.getEthCallContext(),
    );
  }

  async phaseAggregators(
    arg0: BigNumberish,
    overrides?: Overrides,
  ): Promise<string> {
    return await this.view.phaseAggregators(
      arg0,
      {
        blockTag: this.context.blockNumber,
        ...overrides,
      },
      this.context.preparedData,
      this.context.getEthCallContext(),
    );
  }

  async phaseId(overrides?: Overrides): Promise<bigint> {
    return await this.view.phaseId(
      {
        blockTag: this.context.blockNumber,
        ...overrides,
      },
      this.context.preparedData,
      this.context.getEthCallContext(),
    );
  }

  async proposedAggregator(overrides?: Overrides): Promise<string> {
    return await this.view.proposedAggregator(
      {
        blockTag: this.context.blockNumber,
        ...overrides,
      },
      this.context.preparedData,
      this.context.getEthCallContext(),
    );
  }

  async proposedGetRoundData(
    _roundId: BigNumberish,
    overrides?: Overrides,
  ): Promise<
    [bigint, bigint, bigint, bigint, bigint] & {
      roundId: bigint;
      answer: bigint;
      startedAt: bigint;
      updatedAt: bigint;
      answeredInRound: bigint;
    }
  > {
    return await this.view.proposedGetRoundData(
      _roundId,
      {
        blockTag: this.context.blockNumber,
        ...overrides,
      },
      this.context.preparedData,
      this.context.getEthCallContext(),
    );
  }

  async proposedLatestRoundData(
    overrides?: Overrides,
  ): Promise<
    [bigint, bigint, bigint, bigint, bigint] & {
      roundId: bigint;
      answer: bigint;
      startedAt: bigint;
      updatedAt: bigint;
      answeredInRound: bigint;
    }
  > {
    return await this.view.proposedLatestRoundData(
      {
        blockTag: this.context.blockNumber,
        ...overrides,
      },
      this.context.preparedData,
      this.context.getEthCallContext(),
    );
  }

  async version(overrides?: Overrides): Promise<bigint> {
    return await this.view.version(
      {
        blockTag: this.context.blockNumber,
        ...overrides,
      },
      this.context.preparedData,
      this.context.getEthCallContext(),
    );
  }

  callStatic = {
    view: this.view,
    context: this.context,

    async acceptOwnership(overrides?: Overrides): Promise<void> {
      return await this.view.callStatic.acceptOwnership(
        {
          blockTag: this.context.blockNumber,
          ...overrides,
        },
        this.context.preparedData,
        this.context.getEthCallContext(),
      );
    },
    async confirmAggregator(
      _aggregator: string,
      overrides?: Overrides,
    ): Promise<void> {
      return await this.view.callStatic.confirmAggregator(
        _aggregator,
        {
          blockTag: this.context.blockNumber,
          ...overrides,
        },
        this.context.preparedData,
        this.context.getEthCallContext(),
      );
    },
    async proposeAggregator(
      _aggregator: string,
      overrides?: Overrides,
    ): Promise<void> {
      return await this.view.callStatic.proposeAggregator(
        _aggregator,
        {
          blockTag: this.context.blockNumber,
          ...overrides,
        },
        this.context.preparedData,
        this.context.getEthCallContext(),
      );
    },
    async setController(
      _accessController: string,
      overrides?: Overrides,
    ): Promise<void> {
      return await this.view.callStatic.setController(
        _accessController,
        {
          blockTag: this.context.blockNumber,
          ...overrides,
        },
        this.context.preparedData,
        this.context.getEthCallContext(),
      );
    },
    async transferOwnership(_to: string, overrides?: Overrides): Promise<void> {
      return await this.view.callStatic.transferOwnership(
        _to,
        {
          blockTag: this.context.blockNumber,
          ...overrides,
        },
        this.context.preparedData,
        this.context.getEthCallContext(),
      );
    },
  };

  encodeCall = {
    view: this.view,
    context: this.context,

    acceptOwnership(overrides?: Overrides): EthCallParam {
      return this.view.encodeCall.acceptOwnership({
        chainId: this.context.chainId.toString(),
        address: this.context.address,
        blockTag: this.context.getBlockTag(overrides),
      });
    },
    accessController(overrides?: Overrides): EthCallParam {
      return this.view.encodeCall.accessController({
        chainId: this.context.chainId.toString(),
        address: this.context.address,
        blockTag: this.context.getBlockTag(overrides),
      });
    },
    aggregator(overrides?: Overrides): EthCallParam {
      return this.view.encodeCall.aggregator({
        chainId: this.context.chainId.toString(),
        address: this.context.address,
        blockTag: this.context.getBlockTag(overrides),
      });
    },
    confirmAggregator(
      _aggregator: string,
      overrides?: Overrides,
    ): EthCallParam {
      return this.view.encodeCall.confirmAggregator(_aggregator, {
        chainId: this.context.chainId.toString(),
        address: this.context.address,
        blockTag: this.context.getBlockTag(overrides),
      });
    },
    decimals(overrides?: Overrides): EthCallParam {
      return this.view.encodeCall.decimals({
        chainId: this.context.chainId.toString(),
        address: this.context.address,
        blockTag: this.context.getBlockTag(overrides),
      });
    },
    description(overrides?: Overrides): EthCallParam {
      return this.view.encodeCall.description({
        chainId: this.context.chainId.toString(),
        address: this.context.address,
        blockTag: this.context.getBlockTag(overrides),
      });
    },
    getAnswer(_roundId: BigNumberish, overrides?: Overrides): EthCallParam {
      return this.view.encodeCall.getAnswer(_roundId, {
        chainId: this.context.chainId.toString(),
        address: this.context.address,
        blockTag: this.context.getBlockTag(overrides),
      });
    },
    getRoundData(_roundId: BigNumberish, overrides?: Overrides): EthCallParam {
      return this.view.encodeCall.getRoundData(_roundId, {
        chainId: this.context.chainId.toString(),
        address: this.context.address,
        blockTag: this.context.getBlockTag(overrides),
      });
    },
    getTimestamp(_roundId: BigNumberish, overrides?: Overrides): EthCallParam {
      return this.view.encodeCall.getTimestamp(_roundId, {
        chainId: this.context.chainId.toString(),
        address: this.context.address,
        blockTag: this.context.getBlockTag(overrides),
      });
    },
    latestAnswer(overrides?: Overrides): EthCallParam {
      return this.view.encodeCall.latestAnswer({
        chainId: this.context.chainId.toString(),
        address: this.context.address,
        blockTag: this.context.getBlockTag(overrides),
      });
    },
    latestRound(overrides?: Overrides): EthCallParam {
      return this.view.encodeCall.latestRound({
        chainId: this.context.chainId.toString(),
        address: this.context.address,
        blockTag: this.context.getBlockTag(overrides),
      });
    },
    latestRoundData(overrides?: Overrides): EthCallParam {
      return this.view.encodeCall.latestRoundData({
        chainId: this.context.chainId.toString(),
        address: this.context.address,
        blockTag: this.context.getBlockTag(overrides),
      });
    },
    latestTimestamp(overrides?: Overrides): EthCallParam {
      return this.view.encodeCall.latestTimestamp({
        chainId: this.context.chainId.toString(),
        address: this.context.address,
        blockTag: this.context.getBlockTag(overrides),
      });
    },
    owner(overrides?: Overrides): EthCallParam {
      return this.view.encodeCall.owner({
        chainId: this.context.chainId.toString(),
        address: this.context.address,
        blockTag: this.context.getBlockTag(overrides),
      });
    },
    phaseAggregators(arg0: BigNumberish, overrides?: Overrides): EthCallParam {
      return this.view.encodeCall.phaseAggregators(arg0, {
        chainId: this.context.chainId.toString(),
        address: this.context.address,
        blockTag: this.context.getBlockTag(overrides),
      });
    },
    phaseId(overrides?: Overrides): EthCallParam {
      return this.view.encodeCall.phaseId({
        chainId: this.context.chainId.toString(),
        address: this.context.address,
        blockTag: this.context.getBlockTag(overrides),
      });
    },
    proposeAggregator(
      _aggregator: string,
      overrides?: Overrides,
    ): EthCallParam {
      return this.view.encodeCall.proposeAggregator(_aggregator, {
        chainId: this.context.chainId.toString(),
        address: this.context.address,
        blockTag: this.context.getBlockTag(overrides),
      });
    },
    proposedAggregator(overrides?: Overrides): EthCallParam {
      return this.view.encodeCall.proposedAggregator({
        chainId: this.context.chainId.toString(),
        address: this.context.address,
        blockTag: this.context.getBlockTag(overrides),
      });
    },
    proposedGetRoundData(
      _roundId: BigNumberish,
      overrides?: Overrides,
    ): EthCallParam {
      return this.view.encodeCall.proposedGetRoundData(_roundId, {
        chainId: this.context.chainId.toString(),
        address: this.context.address,
        blockTag: this.context.getBlockTag(overrides),
      });
    },
    proposedLatestRoundData(overrides?: Overrides): EthCallParam {
      return this.view.encodeCall.proposedLatestRoundData({
        chainId: this.context.chainId.toString(),
        address: this.context.address,
        blockTag: this.context.getBlockTag(overrides),
      });
    },
    setController(
      _accessController: string,
      overrides?: Overrides,
    ): EthCallParam {
      return this.view.encodeCall.setController(_accessController, {
        chainId: this.context.chainId.toString(),
        address: this.context.address,
        blockTag: this.context.getBlockTag(overrides),
      });
    },
    transferOwnership(_to: string, overrides?: Overrides): EthCallParam {
      return this.view.encodeCall.transferOwnership(_to, {
        chainId: this.context.chainId.toString(),
        address: this.context.address,
        blockTag: this.context.getBlockTag(overrides),
      });
    },
    version(overrides?: Overrides): EthCallParam {
      return this.view.encodeCall.version({
        chainId: this.context.chainId.toString(),
        address: this.context.address,
        blockTag: this.context.getBlockTag(overrides),
      });
    },
  };
}

export type EACAggregatorProxyContext = ContractContext<
  EACAggregatorProxy,
  EACAggregatorProxyBoundContractView
>;

export class EACAggregatorProxyProcessor extends BaseProcessor<
  EACAggregatorProxy,
  EACAggregatorProxyBoundContractView
> {
  onEventAnswerUpdated(
    handler: (
      event: AnswerUpdatedEvent,
      ctx: EACAggregatorProxyContext,
    ) => void,
    filter?: AnswerUpdatedEventFilter | AnswerUpdatedEventFilter[],
    handlerOptions?: HandlerOptions<EthFetchConfig, AnswerUpdatedEvent>,
    preprocessHandler?: (
      event: AnswerUpdatedEvent,
      ctx: EACAggregatorProxyContext,
      preprocessStore: { [k: string]: any },
    ) => Promise<PreprocessResult>,
  ): this {
    if (!filter) {
      filter = templateContract.filters[
        "AnswerUpdated(int256,uint256,uint256)"
      ](null, null, null);
    }
    return super.onEthEvent(
      handler,
      filter!,
      handlerOptions,
      preprocessHandler,
    );
  }

  onEventNewRound(
    handler: (event: NewRoundEvent, ctx: EACAggregatorProxyContext) => void,
    filter?: NewRoundEventFilter | NewRoundEventFilter[],
    handlerOptions?: HandlerOptions<EthFetchConfig, NewRoundEvent>,
    preprocessHandler?: (
      event: NewRoundEvent,
      ctx: EACAggregatorProxyContext,
      preprocessStore: { [k: string]: any },
    ) => Promise<PreprocessResult>,
  ): this {
    if (!filter) {
      filter = templateContract.filters["NewRound(uint256,address,uint256)"](
        null,
        null,
        null,
      );
    }
    return super.onEthEvent(
      handler,
      filter!,
      handlerOptions,
      preprocessHandler,
    );
  }

  onEventOwnershipTransferRequested(
    handler: (
      event: OwnershipTransferRequestedEvent,
      ctx: EACAggregatorProxyContext,
    ) => void,
    filter?:
      | OwnershipTransferRequestedEventFilter
      | OwnershipTransferRequestedEventFilter[],
    handlerOptions?: HandlerOptions<
      EthFetchConfig,
      OwnershipTransferRequestedEvent
    >,
    preprocessHandler?: (
      event: OwnershipTransferRequestedEvent,
      ctx: EACAggregatorProxyContext,
      preprocessStore: { [k: string]: any },
    ) => Promise<PreprocessResult>,
  ): this {
    if (!filter) {
      filter = templateContract.filters[
        "OwnershipTransferRequested(address,address)"
      ](null, null);
    }
    return super.onEthEvent(
      handler,
      filter!,
      handlerOptions,
      preprocessHandler,
    );
  }

  onEventOwnershipTransferred(
    handler: (
      event: OwnershipTransferredEvent,
      ctx: EACAggregatorProxyContext,
    ) => void,
    filter?:
      | OwnershipTransferredEventFilter
      | OwnershipTransferredEventFilter[],
    handlerOptions?: HandlerOptions<EthFetchConfig, OwnershipTransferredEvent>,
    preprocessHandler?: (
      event: OwnershipTransferredEvent,
      ctx: EACAggregatorProxyContext,
      preprocessStore: { [k: string]: any },
    ) => Promise<PreprocessResult>,
  ): this {
    if (!filter) {
      filter = templateContract.filters[
        "OwnershipTransferred(address,address)"
      ](null, null);
    }
    return super.onEthEvent(
      handler,
      filter!,
      handlerOptions,
      preprocessHandler,
    );
  }

  onCallAcceptOwnership(
    handler: (
      call: AcceptOwnershipCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => void,
    handlerOptions?: HandlerOptions<EthFetchConfig, AcceptOwnershipCallTrace>,
    preprocessHandler?: (
      call: AcceptOwnershipCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => Promise<PreprocessResult>,
  ): this {
    return super.onEthTrace(
      "0x79ba5097",
      handler as any,
      handlerOptions,
      preprocessHandler,
    );
  }

  onCallAccessController(
    handler: (
      call: AccessControllerCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => void,
    handlerOptions?: HandlerOptions<EthFetchConfig, AccessControllerCallTrace>,
    preprocessHandler?: (
      call: AccessControllerCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => Promise<PreprocessResult>,
  ): this {
    return super.onEthTrace(
      "0xbc43cbaf",
      handler as any,
      handlerOptions,
      preprocessHandler,
    );
  }

  onCallAggregator(
    handler: (
      call: AggregatorCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => void,
    handlerOptions?: HandlerOptions<EthFetchConfig, AggregatorCallTrace>,
    preprocessHandler?: (
      call: AggregatorCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => Promise<PreprocessResult>,
  ): this {
    return super.onEthTrace(
      "0x245a7bfc",
      handler as any,
      handlerOptions,
      preprocessHandler,
    );
  }

  onCallConfirmAggregator(
    handler: (
      call: ConfirmAggregatorCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => void,
    handlerOptions?: HandlerOptions<EthFetchConfig, ConfirmAggregatorCallTrace>,
    preprocessHandler?: (
      call: ConfirmAggregatorCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => Promise<PreprocessResult>,
  ): this {
    return super.onEthTrace(
      "0xa928c096",
      handler as any,
      handlerOptions,
      preprocessHandler,
    );
  }

  onCallDecimals(
    handler: (call: DecimalsCallTrace, ctx: EACAggregatorProxyContext) => void,
    handlerOptions?: HandlerOptions<EthFetchConfig, DecimalsCallTrace>,
    preprocessHandler?: (
      call: DecimalsCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => Promise<PreprocessResult>,
  ): this {
    return super.onEthTrace(
      "0x313ce567",
      handler as any,
      handlerOptions,
      preprocessHandler,
    );
  }

  onCallDescription(
    handler: (
      call: DescriptionCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => void,
    handlerOptions?: HandlerOptions<EthFetchConfig, DescriptionCallTrace>,
    preprocessHandler?: (
      call: DescriptionCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => Promise<PreprocessResult>,
  ): this {
    return super.onEthTrace(
      "0x7284e416",
      handler as any,
      handlerOptions,
      preprocessHandler,
    );
  }

  onCallGetAnswer(
    handler: (call: GetAnswerCallTrace, ctx: EACAggregatorProxyContext) => void,
    handlerOptions?: HandlerOptions<EthFetchConfig, GetAnswerCallTrace>,
    preprocessHandler?: (
      call: GetAnswerCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => Promise<PreprocessResult>,
  ): this {
    return super.onEthTrace(
      "0xb5ab58dc",
      handler as any,
      handlerOptions,
      preprocessHandler,
    );
  }

  onCallGetRoundData(
    handler: (
      call: GetRoundDataCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => void,
    handlerOptions?: HandlerOptions<EthFetchConfig, GetRoundDataCallTrace>,
    preprocessHandler?: (
      call: GetRoundDataCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => Promise<PreprocessResult>,
  ): this {
    return super.onEthTrace(
      "0x9a6fc8f5",
      handler as any,
      handlerOptions,
      preprocessHandler,
    );
  }

  onCallGetTimestamp(
    handler: (
      call: GetTimestampCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => void,
    handlerOptions?: HandlerOptions<EthFetchConfig, GetTimestampCallTrace>,
    preprocessHandler?: (
      call: GetTimestampCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => Promise<PreprocessResult>,
  ): this {
    return super.onEthTrace(
      "0xb633620c",
      handler as any,
      handlerOptions,
      preprocessHandler,
    );
  }

  onCallLatestAnswer(
    handler: (
      call: LatestAnswerCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => void,
    handlerOptions?: HandlerOptions<EthFetchConfig, LatestAnswerCallTrace>,
    preprocessHandler?: (
      call: LatestAnswerCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => Promise<PreprocessResult>,
  ): this {
    return super.onEthTrace(
      "0x50d25bcd",
      handler as any,
      handlerOptions,
      preprocessHandler,
    );
  }

  onCallLatestRound(
    handler: (
      call: LatestRoundCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => void,
    handlerOptions?: HandlerOptions<EthFetchConfig, LatestRoundCallTrace>,
    preprocessHandler?: (
      call: LatestRoundCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => Promise<PreprocessResult>,
  ): this {
    return super.onEthTrace(
      "0x668a0f02",
      handler as any,
      handlerOptions,
      preprocessHandler,
    );
  }

  onCallLatestRoundData(
    handler: (
      call: LatestRoundDataCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => void,
    handlerOptions?: HandlerOptions<EthFetchConfig, LatestRoundDataCallTrace>,
    preprocessHandler?: (
      call: LatestRoundDataCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => Promise<PreprocessResult>,
  ): this {
    return super.onEthTrace(
      "0xfeaf968c",
      handler as any,
      handlerOptions,
      preprocessHandler,
    );
  }

  onCallLatestTimestamp(
    handler: (
      call: LatestTimestampCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => void,
    handlerOptions?: HandlerOptions<EthFetchConfig, LatestTimestampCallTrace>,
    preprocessHandler?: (
      call: LatestTimestampCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => Promise<PreprocessResult>,
  ): this {
    return super.onEthTrace(
      "0x8205bf6a",
      handler as any,
      handlerOptions,
      preprocessHandler,
    );
  }

  onCallOwner(
    handler: (call: OwnerCallTrace, ctx: EACAggregatorProxyContext) => void,
    handlerOptions?: HandlerOptions<EthFetchConfig, OwnerCallTrace>,
    preprocessHandler?: (
      call: OwnerCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => Promise<PreprocessResult>,
  ): this {
    return super.onEthTrace(
      "0x8da5cb5b",
      handler as any,
      handlerOptions,
      preprocessHandler,
    );
  }

  onCallPhaseAggregators(
    handler: (
      call: PhaseAggregatorsCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => void,
    handlerOptions?: HandlerOptions<EthFetchConfig, PhaseAggregatorsCallTrace>,
    preprocessHandler?: (
      call: PhaseAggregatorsCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => Promise<PreprocessResult>,
  ): this {
    return super.onEthTrace(
      "0xc1597304",
      handler as any,
      handlerOptions,
      preprocessHandler,
    );
  }

  onCallPhaseId(
    handler: (call: PhaseIdCallTrace, ctx: EACAggregatorProxyContext) => void,
    handlerOptions?: HandlerOptions<EthFetchConfig, PhaseIdCallTrace>,
    preprocessHandler?: (
      call: PhaseIdCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => Promise<PreprocessResult>,
  ): this {
    return super.onEthTrace(
      "0x58303b10",
      handler as any,
      handlerOptions,
      preprocessHandler,
    );
  }

  onCallProposeAggregator(
    handler: (
      call: ProposeAggregatorCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => void,
    handlerOptions?: HandlerOptions<EthFetchConfig, ProposeAggregatorCallTrace>,
    preprocessHandler?: (
      call: ProposeAggregatorCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => Promise<PreprocessResult>,
  ): this {
    return super.onEthTrace(
      "0xf8a2abd3",
      handler as any,
      handlerOptions,
      preprocessHandler,
    );
  }

  onCallProposedAggregator(
    handler: (
      call: ProposedAggregatorCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      EthFetchConfig,
      ProposedAggregatorCallTrace
    >,
    preprocessHandler?: (
      call: ProposedAggregatorCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => Promise<PreprocessResult>,
  ): this {
    return super.onEthTrace(
      "0xe8c4be30",
      handler as any,
      handlerOptions,
      preprocessHandler,
    );
  }

  onCallProposedGetRoundData(
    handler: (
      call: ProposedGetRoundDataCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      EthFetchConfig,
      ProposedGetRoundDataCallTrace
    >,
    preprocessHandler?: (
      call: ProposedGetRoundDataCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => Promise<PreprocessResult>,
  ): this {
    return super.onEthTrace(
      "0x6001ac53",
      handler as any,
      handlerOptions,
      preprocessHandler,
    );
  }

  onCallProposedLatestRoundData(
    handler: (
      call: ProposedLatestRoundDataCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      EthFetchConfig,
      ProposedLatestRoundDataCallTrace
    >,
    preprocessHandler?: (
      call: ProposedLatestRoundDataCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => Promise<PreprocessResult>,
  ): this {
    return super.onEthTrace(
      "0x8f6b4d91",
      handler as any,
      handlerOptions,
      preprocessHandler,
    );
  }

  onCallSetController(
    handler: (
      call: SetControllerCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => void,
    handlerOptions?: HandlerOptions<EthFetchConfig, SetControllerCallTrace>,
    preprocessHandler?: (
      call: SetControllerCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => Promise<PreprocessResult>,
  ): this {
    return super.onEthTrace(
      "0x92eefe9b",
      handler as any,
      handlerOptions,
      preprocessHandler,
    );
  }

  onCallTransferOwnership(
    handler: (
      call: TransferOwnershipCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => void,
    handlerOptions?: HandlerOptions<EthFetchConfig, TransferOwnershipCallTrace>,
    preprocessHandler?: (
      call: TransferOwnershipCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => Promise<PreprocessResult>,
  ): this {
    return super.onEthTrace(
      "0xf2fde38b",
      handler as any,
      handlerOptions,
      preprocessHandler,
    );
  }

  onCallVersion(
    handler: (call: VersionCallTrace, ctx: EACAggregatorProxyContext) => void,
    handlerOptions?: HandlerOptions<EthFetchConfig, VersionCallTrace>,
    preprocessHandler?: (
      call: VersionCallTrace,
      ctx: EACAggregatorProxyContext,
    ) => Promise<PreprocessResult>,
  ): this {
    return super.onEthTrace(
      "0x54fd4d50",
      handler as any,
      handlerOptions,
      preprocessHandler,
    );
  }

  public static filters = {
    AnswerUpdated(
      current?: BigNumberish | null,
      roundId?: BigNumberish | null,
      updatedAt?: null,
    ): AnswerUpdatedEventFilter {
      return templateContract.filters["AnswerUpdated(int256,uint256,uint256)"](
        current,
        roundId,
        updatedAt,
      );
    },
    NewRound(
      roundId?: BigNumberish | null,
      startedBy?: string | null,
      startedAt?: null,
    ): NewRoundEventFilter {
      return templateContract.filters["NewRound(uint256,address,uint256)"](
        roundId,
        startedBy,
        startedAt,
      );
    },
    OwnershipTransferRequested(
      from?: string | null,
      to?: string | null,
    ): OwnershipTransferRequestedEventFilter {
      return templateContract.filters[
        "OwnershipTransferRequested(address,address)"
      ](from, to);
    },
    OwnershipTransferred(
      from?: string | null,
      to?: string | null,
    ): OwnershipTransferredEventFilter {
      return templateContract.filters["OwnershipTransferred(address,address)"](
        from,
        to,
      );
    },
  };

  protected CreateBoundContractView(): EACAggregatorProxyBoundContractView {
    const view = getEACAggregatorProxyContract(
      this.config.network,
      this.config.address,
    );
    return new EACAggregatorProxyBoundContractView(this.config.address, view);
  }

  public static bind(options: BindOptions): EACAggregatorProxyProcessor {
    if (!options.name) {
      options.name = "EACAggregatorProxy";
    }
    let processor = getProcessor(options) as EACAggregatorProxyProcessor;
    if (!processor) {
      processor = new EACAggregatorProxyProcessor(options);
      addProcessor(options, processor);
    }
    return processor;
  }
}

export class EACAggregatorProxyProcessorTemplate extends BaseProcessorTemplate<
  EACAggregatorProxy,
  EACAggregatorProxyBoundContractView
> {
  bindInternal(options: BindOptions) {
    if (!options.name) {
      options.name = "EACAggregatorProxy";
    }
    let processor = getProcessor(options) as EACAggregatorProxyProcessor;
    if (!processor) {
      processor = new EACAggregatorProxyProcessor(options);
      addProcessor(options, processor);
    }
    return processor;
  }

  onEventAnswerUpdated(
    handler: (
      event: AnswerUpdatedEvent,
      ctx: EACAggregatorProxyContext,
    ) => void,
    filter?: AnswerUpdatedEventFilter | AnswerUpdatedEventFilter[],
    handlerOptions?: HandlerOptions<EthFetchConfig, AnswerUpdatedEvent>,
    preprocessHandler?: (
      event: AnswerUpdatedEvent,
      ctx: EACAggregatorProxyContext,
      preprocessStore: { [k: string]: any },
    ) => Promise<PreprocessResult>,
  ): this {
    if (!filter) {
      filter = templateContract.filters[
        "AnswerUpdated(int256,uint256,uint256)"
      ](null, null, null);
    }
    return super.onEthEvent(
      handler,
      filter!,
      handlerOptions,
      preprocessHandler,
    );
  }

  onEventNewRound(
    handler: (event: NewRoundEvent, ctx: EACAggregatorProxyContext) => void,
    filter?: NewRoundEventFilter | NewRoundEventFilter[],
    handlerOptions?: HandlerOptions<EthFetchConfig, NewRoundEvent>,
    preprocessHandler?: (
      event: NewRoundEvent,
      ctx: EACAggregatorProxyContext,
      preprocessStore: { [k: string]: any },
    ) => Promise<PreprocessResult>,
  ): this {
    if (!filter) {
      filter = templateContract.filters["NewRound(uint256,address,uint256)"](
        null,
        null,
        null,
      );
    }
    return super.onEthEvent(
      handler,
      filter!,
      handlerOptions,
      preprocessHandler,
    );
  }

  onEventOwnershipTransferRequested(
    handler: (
      event: OwnershipTransferRequestedEvent,
      ctx: EACAggregatorProxyContext,
    ) => void,
    filter?:
      | OwnershipTransferRequestedEventFilter
      | OwnershipTransferRequestedEventFilter[],
    handlerOptions?: HandlerOptions<
      EthFetchConfig,
      OwnershipTransferRequestedEvent
    >,
    preprocessHandler?: (
      event: OwnershipTransferRequestedEvent,
      ctx: EACAggregatorProxyContext,
      preprocessStore: { [k: string]: any },
    ) => Promise<PreprocessResult>,
  ): this {
    if (!filter) {
      filter = templateContract.filters[
        "OwnershipTransferRequested(address,address)"
      ](null, null);
    }
    return super.onEthEvent(
      handler,
      filter!,
      handlerOptions,
      preprocessHandler,
    );
  }

  onEventOwnershipTransferred(
    handler: (
      event: OwnershipTransferredEvent,
      ctx: EACAggregatorProxyContext,
    ) => void,
    filter?:
      | OwnershipTransferredEventFilter
      | OwnershipTransferredEventFilter[],
    handlerOptions?: HandlerOptions<EthFetchConfig, OwnershipTransferredEvent>,
    preprocessHandler?: (
      event: OwnershipTransferredEvent,
      ctx: EACAggregatorProxyContext,
      preprocessStore: { [k: string]: any },
    ) => Promise<PreprocessResult>,
  ): this {
    if (!filter) {
      filter = templateContract.filters[
        "OwnershipTransferred(address,address)"
      ](null, null);
    }
    return super.onEthEvent(
      handler,
      filter!,
      handlerOptions,
      preprocessHandler,
    );
  }
}

export function getEACAggregatorProxyContract(
  chainId: EthChainId,
  address: string,
): EACAggregatorProxyContractView {
  let contract = getContractByABI(
    "EACAggregatorProxy",
    address,
    chainId,
  ) as EACAggregatorProxyContractView;
  if (!contract) {
    const rawContract = EACAggregatorProxy__factory.connect(
      address,
      getProvider(chainId),
    );
    contract = new EACAggregatorProxyContractView(rawContract);
    addContractByABI("EACAggregatorProxy", address, chainId, contract);
  }
  return contract;
}

export function getEACAggregatorProxyContractOnContext(
  context: EthContext,
  address: string,
): EACAggregatorProxyBoundContractView {
  const view = getEACAggregatorProxyContract(context.getChainId(), address);
  const boundView = new EACAggregatorProxyBoundContractView(address, view);
  boundView.context = context;
  if (boundView.callStatic) {
    boundView.callStatic.context = context;
  }
  return boundView;
}