@sentio/sdk 1.0.0-development → 1.0.0-rc.2

package/src/builtin/internal/eacaggregatorproxy_processor.ts

@@ -0,0 +1,1219 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import { BigNumber, BigNumberish, CallOverrides } from "ethers";
+import { Networkish } from "@ethersproject/providers";
+import {
+  addContractByABI,
+  getContractByABI,
+  addProcessor,
+  getProcessor,
+  getProvider,
+  transformEtherError,
+  BindOptions,
+  BaseProcessor,
+  BaseProcessorTemplate,
+  BoundContractView,
+  ContractContext,
+  ContractView,
+  DummyProvider,
+  TypedCallTrace,
+} from "@sentio/sdk";
+import { PromiseOrValue } from "./common";
+import { EACAggregatorProxy, EACAggregatorProxy__factory } from "./index";
+import {
+  AnswerUpdatedEvent,
+  AnswerUpdatedEventFilter,
+  NewRoundEvent,
+  NewRoundEventFilter,
+  OwnershipTransferRequestedEvent,
+  OwnershipTransferRequestedEventFilter,
+  OwnershipTransferredEvent,
+  OwnershipTransferredEventFilter,
+} from "./EACAggregatorProxy";
+
+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: BigNumber;
+}
+
+export type GetAnswerCallTrace = TypedCallTrace<
+  [BigNumber],
+  GetAnswerCallObject
+>;
+
+export interface GetRoundDataCallObject {
+  _roundId: BigNumber;
+}
+
+export type GetRoundDataCallTrace = TypedCallTrace<
+  [BigNumber],
+  GetRoundDataCallObject
+>;
+
+export interface GetTimestampCallObject {
+  _roundId: BigNumber;
+}
+
+export type GetTimestampCallTrace = TypedCallTrace<
+  [BigNumber],
+  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<
+  [number],
+  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: BigNumber;
+}
+
+export type ProposedGetRoundDataCallTrace = TypedCallTrace<
+  [BigNumber],
+  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("", DummyProvider);
+
+export class EACAggregatorProxyContractView extends ContractView<EACAggregatorProxy> {
+  constructor(contract: EACAggregatorProxy) {
+    super(contract);
+  }
+
+  async accessController(overrides?: CallOverrides): Promise<string> {
+    try {
+      if (overrides) {
+        return await this.contract.accessController(overrides);
+      } else {
+        return await this.contract.accessController();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async aggregator(overrides?: CallOverrides): Promise<string> {
+    try {
+      if (overrides) {
+        return await this.contract.aggregator(overrides);
+      } else {
+        return await this.contract.aggregator();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async decimals(overrides?: CallOverrides): Promise<number> {
+    try {
+      if (overrides) {
+        return await this.contract.decimals(overrides);
+      } else {
+        return await this.contract.decimals();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async description(overrides?: CallOverrides): Promise<string> {
+    try {
+      if (overrides) {
+        return await this.contract.description(overrides);
+      } else {
+        return await this.contract.description();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async getAnswer(
+    _roundId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber> {
+    try {
+      if (overrides) {
+        return await this.contract.getAnswer(_roundId, overrides);
+      } else {
+        return await this.contract.getAnswer(_roundId);
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async getRoundData(
+    _roundId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+      roundId: BigNumber;
+      answer: BigNumber;
+      startedAt: BigNumber;
+      updatedAt: BigNumber;
+      answeredInRound: BigNumber;
+    }
+  > {
+    try {
+      if (overrides) {
+        return await this.contract.getRoundData(_roundId, overrides);
+      } else {
+        return await this.contract.getRoundData(_roundId);
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async getTimestamp(
+    _roundId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber> {
+    try {
+      if (overrides) {
+        return await this.contract.getTimestamp(_roundId, overrides);
+      } else {
+        return await this.contract.getTimestamp(_roundId);
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async latestAnswer(overrides?: CallOverrides): Promise<BigNumber> {
+    try {
+      if (overrides) {
+        return await this.contract.latestAnswer(overrides);
+      } else {
+        return await this.contract.latestAnswer();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async latestRound(overrides?: CallOverrides): Promise<BigNumber> {
+    try {
+      if (overrides) {
+        return await this.contract.latestRound(overrides);
+      } else {
+        return await this.contract.latestRound();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async latestRoundData(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+      roundId: BigNumber;
+      answer: BigNumber;
+      startedAt: BigNumber;
+      updatedAt: BigNumber;
+      answeredInRound: BigNumber;
+    }
+  > {
+    try {
+      if (overrides) {
+        return await this.contract.latestRoundData(overrides);
+      } else {
+        return await this.contract.latestRoundData();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async latestTimestamp(overrides?: CallOverrides): Promise<BigNumber> {
+    try {
+      if (overrides) {
+        return await this.contract.latestTimestamp(overrides);
+      } else {
+        return await this.contract.latestTimestamp();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async owner(overrides?: CallOverrides): Promise<string> {
+    try {
+      if (overrides) {
+        return await this.contract.owner(overrides);
+      } else {
+        return await this.contract.owner();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async phaseAggregators(
+    arg0: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string> {
+    try {
+      if (overrides) {
+        return await this.contract.phaseAggregators(arg0, overrides);
+      } else {
+        return await this.contract.phaseAggregators(arg0);
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async phaseId(overrides?: CallOverrides): Promise<number> {
+    try {
+      if (overrides) {
+        return await this.contract.phaseId(overrides);
+      } else {
+        return await this.contract.phaseId();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async proposedAggregator(overrides?: CallOverrides): Promise<string> {
+    try {
+      if (overrides) {
+        return await this.contract.proposedAggregator(overrides);
+      } else {
+        return await this.contract.proposedAggregator();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async proposedGetRoundData(
+    _roundId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+      roundId: BigNumber;
+      answer: BigNumber;
+      startedAt: BigNumber;
+      updatedAt: BigNumber;
+      answeredInRound: BigNumber;
+    }
+  > {
+    try {
+      if (overrides) {
+        return await this.contract.proposedGetRoundData(_roundId, overrides);
+      } else {
+        return await this.contract.proposedGetRoundData(_roundId);
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async proposedLatestRoundData(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+      roundId: BigNumber;
+      answer: BigNumber;
+      startedAt: BigNumber;
+      updatedAt: BigNumber;
+      answeredInRound: BigNumber;
+    }
+  > {
+    try {
+      if (overrides) {
+        return await this.contract.proposedLatestRoundData(overrides);
+      } else {
+        return await this.contract.proposedLatestRoundData();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async version(overrides?: CallOverrides): Promise<BigNumber> {
+    try {
+      if (overrides) {
+        return await this.contract.version(overrides);
+      } else {
+        return await this.contract.version();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+}
+
+export class EACAggregatorProxyBoundContractView extends BoundContractView<
+  EACAggregatorProxy,
+  EACAggregatorProxyContractView
+> {
+  // constructor (contract: EACAggregatorProxy) {
+  //   super(contract);
+  // }
+
+  async accessController(overrides?: CallOverrides): Promise<string> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.accessController(overrides);
+      } else {
+        return await this.view.accessController();
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async aggregator(overrides?: CallOverrides): Promise<string> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.aggregator(overrides);
+      } else {
+        return await this.view.aggregator();
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async decimals(overrides?: CallOverrides): Promise<number> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.decimals(overrides);
+      } else {
+        return await this.view.decimals();
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async description(overrides?: CallOverrides): Promise<string> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.description(overrides);
+      } else {
+        return await this.view.description();
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async getAnswer(
+    _roundId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.getAnswer(_roundId, overrides);
+      } else {
+        return await this.view.getAnswer(_roundId);
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async getRoundData(
+    _roundId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+      roundId: BigNumber;
+      answer: BigNumber;
+      startedAt: BigNumber;
+      updatedAt: BigNumber;
+      answeredInRound: BigNumber;
+    }
+  > {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.getRoundData(_roundId, overrides);
+      } else {
+        return await this.view.getRoundData(_roundId);
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async getTimestamp(
+    _roundId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.getTimestamp(_roundId, overrides);
+      } else {
+        return await this.view.getTimestamp(_roundId);
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async latestAnswer(overrides?: CallOverrides): Promise<BigNumber> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.latestAnswer(overrides);
+      } else {
+        return await this.view.latestAnswer();
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async latestRound(overrides?: CallOverrides): Promise<BigNumber> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.latestRound(overrides);
+      } else {
+        return await this.view.latestRound();
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async latestRoundData(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+      roundId: BigNumber;
+      answer: BigNumber;
+      startedAt: BigNumber;
+      updatedAt: BigNumber;
+      answeredInRound: BigNumber;
+    }
+  > {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.latestRoundData(overrides);
+      } else {
+        return await this.view.latestRoundData();
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async latestTimestamp(overrides?: CallOverrides): Promise<BigNumber> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.latestTimestamp(overrides);
+      } else {
+        return await this.view.latestTimestamp();
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async owner(overrides?: CallOverrides): Promise<string> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.owner(overrides);
+      } else {
+        return await this.view.owner();
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async phaseAggregators(
+    arg0: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.phaseAggregators(arg0, overrides);
+      } else {
+        return await this.view.phaseAggregators(arg0);
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async phaseId(overrides?: CallOverrides): Promise<number> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.phaseId(overrides);
+      } else {
+        return await this.view.phaseId();
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async proposedAggregator(overrides?: CallOverrides): Promise<string> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.proposedAggregator(overrides);
+      } else {
+        return await this.view.proposedAggregator();
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async proposedGetRoundData(
+    _roundId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+      roundId: BigNumber;
+      answer: BigNumber;
+      startedAt: BigNumber;
+      updatedAt: BigNumber;
+      answeredInRound: BigNumber;
+    }
+  > {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.proposedGetRoundData(_roundId, overrides);
+      } else {
+        return await this.view.proposedGetRoundData(_roundId);
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async proposedLatestRoundData(
+    overrides?: CallOverrides
+  ): Promise<
+    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
+      roundId: BigNumber;
+      answer: BigNumber;
+      startedAt: BigNumber;
+      updatedAt: BigNumber;
+      answeredInRound: BigNumber;
+    }
+  > {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.proposedLatestRoundData(overrides);
+      } else {
+        return await this.view.proposedLatestRoundData();
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async version(overrides?: CallOverrides): Promise<BigNumber> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.version(overrides);
+      } else {
+        return await this.view.version();
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+}
+
+export type EACAggregatorProxyContext = ContractContext<
+  EACAggregatorProxy,
+  EACAggregatorProxyBoundContractView
+>;
+
+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[]
+  ) {
+    if (!filter) {
+      // @ts-ignore
+      filter = EACAggregatorProxyProcessor.filters[
+        // @ts-ignore
+        "AnswerUpdated(int256,uint256,uint256)"
+      ](null, null, null);
+    }
+    return super.onEvent(handler, filter!);
+  }
+
+  onEventNewRound(
+    handler: (event: NewRoundEvent, ctx: EACAggregatorProxyContext) => void,
+    filter?: NewRoundEventFilter | NewRoundEventFilter[]
+  ) {
+    if (!filter) {
+      // @ts-ignore
+      filter = EACAggregatorProxyProcessor.filters[
+        // @ts-ignore
+        "NewRound(uint256,address,uint256)"
+      ](null, null, null);
+    }
+    return super.onEvent(handler, filter!);
+  }
+
+  onEventOwnershipTransferRequested(
+    handler: (
+      event: OwnershipTransferRequestedEvent,
+      ctx: EACAggregatorProxyContext
+    ) => void,
+    filter?:
+      | OwnershipTransferRequestedEventFilter
+      | OwnershipTransferRequestedEventFilter[]
+  ) {
+    if (!filter) {
+      // @ts-ignore
+      filter = EACAggregatorProxyProcessor.filters[
+        // @ts-ignore
+        "OwnershipTransferRequested(address,address)"
+      ](null, null);
+    }
+    return super.onEvent(handler, filter!);
+  }
+
+  onEventOwnershipTransferred(
+    handler: (
+      event: OwnershipTransferredEvent,
+      ctx: EACAggregatorProxyContext
+    ) => void,
+    filter?: OwnershipTransferredEventFilter | OwnershipTransferredEventFilter[]
+  ) {
+    if (!filter) {
+      // @ts-ignore
+      filter = EACAggregatorProxyProcessor.filters[
+        // @ts-ignore
+        "OwnershipTransferred(address,address)"
+      ](null, null);
+    }
+    return super.onEvent(handler, filter!);
+  }
+}
+
+export class EACAggregatorProxyProcessor extends BaseProcessor<
+  EACAggregatorProxy,
+  EACAggregatorProxyBoundContractView
+> {
+  onEventAnswerUpdated(
+    handler: (
+      event: AnswerUpdatedEvent,
+      ctx: EACAggregatorProxyContext
+    ) => void,
+    filter?: AnswerUpdatedEventFilter | AnswerUpdatedEventFilter[]
+  ) {
+    if (!filter) {
+      // @ts-ignore
+      filter = EACAggregatorProxyProcessor.filters[
+        // @ts-ignore
+        "AnswerUpdated(int256,uint256,uint256)"
+      ](null, null, null);
+    }
+    return super.onEvent(handler, filter!);
+  }
+
+  onEventNewRound(
+    handler: (event: NewRoundEvent, ctx: EACAggregatorProxyContext) => void,
+    filter?: NewRoundEventFilter | NewRoundEventFilter[]
+  ) {
+    if (!filter) {
+      // @ts-ignore
+      filter = EACAggregatorProxyProcessor.filters[
+        // @ts-ignore
+        "NewRound(uint256,address,uint256)"
+      ](null, null, null);
+    }
+    return super.onEvent(handler, filter!);
+  }
+
+  onEventOwnershipTransferRequested(
+    handler: (
+      event: OwnershipTransferRequestedEvent,
+      ctx: EACAggregatorProxyContext
+    ) => void,
+    filter?:
+      | OwnershipTransferRequestedEventFilter
+      | OwnershipTransferRequestedEventFilter[]
+  ) {
+    if (!filter) {
+      // @ts-ignore
+      filter = EACAggregatorProxyProcessor.filters[
+        // @ts-ignore
+        "OwnershipTransferRequested(address,address)"
+      ](null, null);
+    }
+    return super.onEvent(handler, filter!);
+  }
+
+  onEventOwnershipTransferred(
+    handler: (
+      event: OwnershipTransferredEvent,
+      ctx: EACAggregatorProxyContext
+    ) => void,
+    filter?: OwnershipTransferredEventFilter | OwnershipTransferredEventFilter[]
+  ) {
+    if (!filter) {
+      // @ts-ignore
+      filter = EACAggregatorProxyProcessor.filters[
+        // @ts-ignore
+        "OwnershipTransferred(address,address)"
+      ](null, null);
+    }
+    return super.onEvent(handler, filter!);
+  }
+
+  onCallAcceptOwnership(
+    handler: (
+      call: AcceptOwnershipCallTrace,
+      ctx: EACAggregatorProxyContext
+    ) => void
+  ) {
+    return super.onTrace("0x79ba5097", handler);
+  }
+
+  onCallAccessController(
+    handler: (
+      call: AccessControllerCallTrace,
+      ctx: EACAggregatorProxyContext
+    ) => void
+  ) {
+    return super.onTrace("0xbc43cbaf", handler);
+  }
+
+  onCallAggregator(
+    handler: (call: AggregatorCallTrace, ctx: EACAggregatorProxyContext) => void
+  ) {
+    return super.onTrace("0x245a7bfc", handler);
+  }
+
+  onCallConfirmAggregator(
+    handler: (
+      call: ConfirmAggregatorCallTrace,
+      ctx: EACAggregatorProxyContext
+    ) => void
+  ) {
+    return super.onTrace("0xa928c096", handler);
+  }
+
+  onCallDecimals(
+    handler: (call: DecimalsCallTrace, ctx: EACAggregatorProxyContext) => void
+  ) {
+    return super.onTrace("0x313ce567", handler);
+  }
+
+  onCallDescription(
+    handler: (
+      call: DescriptionCallTrace,
+      ctx: EACAggregatorProxyContext
+    ) => void
+  ) {
+    return super.onTrace("0x7284e416", handler);
+  }
+
+  onCallGetAnswer(
+    handler: (call: GetAnswerCallTrace, ctx: EACAggregatorProxyContext) => void
+  ) {
+    return super.onTrace("0xb5ab58dc", handler);
+  }
+
+  onCallGetRoundData(
+    handler: (
+      call: GetRoundDataCallTrace,
+      ctx: EACAggregatorProxyContext
+    ) => void
+  ) {
+    return super.onTrace("0x9a6fc8f5", handler);
+  }
+
+  onCallGetTimestamp(
+    handler: (
+      call: GetTimestampCallTrace,
+      ctx: EACAggregatorProxyContext
+    ) => void
+  ) {
+    return super.onTrace("0xb633620c", handler);
+  }
+
+  onCallLatestAnswer(
+    handler: (
+      call: LatestAnswerCallTrace,
+      ctx: EACAggregatorProxyContext
+    ) => void
+  ) {
+    return super.onTrace("0x50d25bcd", handler);
+  }
+
+  onCallLatestRound(
+    handler: (
+      call: LatestRoundCallTrace,
+      ctx: EACAggregatorProxyContext
+    ) => void
+  ) {
+    return super.onTrace("0x668a0f02", handler);
+  }
+
+  onCallLatestRoundData(
+    handler: (
+      call: LatestRoundDataCallTrace,
+      ctx: EACAggregatorProxyContext
+    ) => void
+  ) {
+    return super.onTrace("0xfeaf968c", handler);
+  }
+
+  onCallLatestTimestamp(
+    handler: (
+      call: LatestTimestampCallTrace,
+      ctx: EACAggregatorProxyContext
+    ) => void
+  ) {
+    return super.onTrace("0x8205bf6a", handler);
+  }
+
+  onCallOwner(
+    handler: (call: OwnerCallTrace, ctx: EACAggregatorProxyContext) => void
+  ) {
+    return super.onTrace("0x8da5cb5b", handler);
+  }
+
+  onCallPhaseAggregators(
+    handler: (
+      call: PhaseAggregatorsCallTrace,
+      ctx: EACAggregatorProxyContext
+    ) => void
+  ) {
+    return super.onTrace("0xc1597304", handler);
+  }
+
+  onCallPhaseId(
+    handler: (call: PhaseIdCallTrace, ctx: EACAggregatorProxyContext) => void
+  ) {
+    return super.onTrace("0x58303b10", handler);
+  }
+
+  onCallProposeAggregator(
+    handler: (
+      call: ProposeAggregatorCallTrace,
+      ctx: EACAggregatorProxyContext
+    ) => void
+  ) {
+    return super.onTrace("0xf8a2abd3", handler);
+  }
+
+  onCallProposedAggregator(
+    handler: (
+      call: ProposedAggregatorCallTrace,
+      ctx: EACAggregatorProxyContext
+    ) => void
+  ) {
+    return super.onTrace("0xe8c4be30", handler);
+  }
+
+  onCallProposedGetRoundData(
+    handler: (
+      call: ProposedGetRoundDataCallTrace,
+      ctx: EACAggregatorProxyContext
+    ) => void
+  ) {
+    return super.onTrace("0x6001ac53", handler);
+  }
+
+  onCallProposedLatestRoundData(
+    handler: (
+      call: ProposedLatestRoundDataCallTrace,
+      ctx: EACAggregatorProxyContext
+    ) => void
+  ) {
+    return super.onTrace("0x8f6b4d91", handler);
+  }
+
+  onCallSetController(
+    handler: (
+      call: SetControllerCallTrace,
+      ctx: EACAggregatorProxyContext
+    ) => void
+  ) {
+    return super.onTrace("0x92eefe9b", handler);
+  }
+
+  onCallTransferOwnership(
+    handler: (
+      call: TransferOwnershipCallTrace,
+      ctx: EACAggregatorProxyContext
+    ) => void
+  ) {
+    return super.onTrace("0xf2fde38b", handler);
+  }
+
+  onCallVersion(
+    handler: (call: VersionCallTrace, ctx: EACAggregatorProxyContext) => void
+  ) {
+    return super.onTrace("0x54fd4d50", handler);
+  }
+
+  public static filters = templateContract.filters;
+
+  protected CreateBoundContractView(): EACAggregatorProxyBoundContractView {
+    const view = getEACAggregatorProxyContract(
+      this.config.address,
+      this.config.network
+    );
+    return new EACAggregatorProxyBoundContractView(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 function getEACAggregatorProxyContract(
+  address: string,
+  network: Networkish = 1
+): EACAggregatorProxyContractView {
+  let contract = getContractByABI(
+    "EACAggregatorProxy",
+    address,
+    network
+  ) as EACAggregatorProxyContractView;
+  if (!contract) {
+    const rawContract = EACAggregatorProxy__factory.connect(
+      address,
+      getProvider(network)
+    );
+    contract = new EACAggregatorProxyContractView(rawContract);
+    addContractByABI("EACAggregatorProxy", address, network, contract);
+  }
+  return contract;
+}