@sentio/sdk 1.40.5-rc.6 → 1.41.0-rc.1

package/src/builtin/internal/eacaggregatorproxy_processor.ts

@@ -1,8 +1,8 @@
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
-import { BigNumber, BigNumberish, CallOverrides } from "ethers";
-import { Networkish } from "@ethersproject/providers";
+import { BigNumberish, Overrides } from "ethers";
+import { Networkish } from "ethers/providers";
 import {
   addContractByABI,
   getContractByABI,
@@ -10,6 +10,7 @@ import {
   getProcessor,
   getProvider,
   transformEtherError,
+  Trace,
   BindOptions,
   BaseProcessor,
   BaseProcessorTemplate,
@@ -21,7 +22,7 @@ import {
   toBlockTag,
 } from "@sentio/sdk";
 import { EthFetchConfig } from "@sentio/protos";
-import { PromiseOrValue } from "./common";
+
 import { EACAggregatorProxy, EACAggregatorProxy__factory } from "./index";
 import {
   AnswerUpdatedEvent,
@@ -39,18 +40,21 @@ export interface AcceptOwnershipCallObject {}
 export type AcceptOwnershipCallTrace = TypedCallTrace<
   [],
   AcceptOwnershipCallObject
->;
+> &
+  Trace;
 
 export interface AccessControllerCallObject {}
 
 export type AccessControllerCallTrace = TypedCallTrace<
   [],
   AccessControllerCallObject
->;
+> &
+  Trace;
 
 export interface AggregatorCallObject {}
 
-export type AggregatorCallTrace = TypedCallTrace<[], AggregatorCallObject>;
+export type AggregatorCallTrace = TypedCallTrace<[], AggregatorCallObject> &
+  Trace;
 
 export interface ConfirmAggregatorCallObject {
   _aggregator: string;
@@ -59,79 +63,86 @@ export interface ConfirmAggregatorCallObject {
 export type ConfirmAggregatorCallTrace = TypedCallTrace<
   [string],
   ConfirmAggregatorCallObject
->;
+> &
+  Trace;
 
 export interface DecimalsCallObject {}
 
-export type DecimalsCallTrace = TypedCallTrace<[], DecimalsCallObject>;
+export type DecimalsCallTrace = TypedCallTrace<[], DecimalsCallObject> & Trace;
 
 export interface DescriptionCallObject {}
 
-export type DescriptionCallTrace = TypedCallTrace<[], DescriptionCallObject>;
+export type DescriptionCallTrace = TypedCallTrace<[], DescriptionCallObject> &
+  Trace;
 
 export interface GetAnswerCallObject {
-  _roundId: BigNumber;
+  _roundId: bigint;
 }
 
-export type GetAnswerCallTrace = TypedCallTrace<
-  [BigNumber],
-  GetAnswerCallObject
->;
+export type GetAnswerCallTrace = TypedCallTrace<[bigint], GetAnswerCallObject> &
+  Trace;
 
 export interface GetRoundDataCallObject {
-  _roundId: BigNumber;
+  _roundId: bigint;
 }
 
 export type GetRoundDataCallTrace = TypedCallTrace<
-  [BigNumber],
+  [bigint],
   GetRoundDataCallObject
->;
+> &
+  Trace;
 
 export interface GetTimestampCallObject {
-  _roundId: BigNumber;
+  _roundId: bigint;
 }
 
 export type GetTimestampCallTrace = TypedCallTrace<
-  [BigNumber],
+  [bigint],
   GetTimestampCallObject
->;
+> &
+  Trace;
 
 export interface LatestAnswerCallObject {}
 
-export type LatestAnswerCallTrace = TypedCallTrace<[], LatestAnswerCallObject>;
+export type LatestAnswerCallTrace = TypedCallTrace<[], LatestAnswerCallObject> &
+  Trace;
 
 export interface LatestRoundCallObject {}
 
-export type LatestRoundCallTrace = TypedCallTrace<[], LatestRoundCallObject>;
+export type LatestRoundCallTrace = TypedCallTrace<[], LatestRoundCallObject> &
+  Trace;
 
 export interface LatestRoundDataCallObject {}
 
 export type LatestRoundDataCallTrace = TypedCallTrace<
   [],
   LatestRoundDataCallObject
->;
+> &
+  Trace;
 
 export interface LatestTimestampCallObject {}
 
 export type LatestTimestampCallTrace = TypedCallTrace<
   [],
   LatestTimestampCallObject
->;
+> &
+  Trace;
 
 export interface OwnerCallObject {}
 
-export type OwnerCallTrace = TypedCallTrace<[], OwnerCallObject>;
+export type OwnerCallTrace = TypedCallTrace<[], OwnerCallObject> & Trace;
 
 export interface PhaseAggregatorsCallObject {}
 
 export type PhaseAggregatorsCallTrace = TypedCallTrace<
-  [number],
+  [bigint],
   PhaseAggregatorsCallObject
->;
+> &
+  Trace;
 
 export interface PhaseIdCallObject {}
 
-export type PhaseIdCallTrace = TypedCallTrace<[], PhaseIdCallObject>;
+export type PhaseIdCallTrace = TypedCallTrace<[], PhaseIdCallObject> & Trace;
 
 export interface ProposeAggregatorCallObject {
   _aggregator: string;
@@ -140,30 +151,34 @@ export interface ProposeAggregatorCallObject {
 export type ProposeAggregatorCallTrace = TypedCallTrace<
   [string],
   ProposeAggregatorCallObject
->;
+> &
+  Trace;
 
 export interface ProposedAggregatorCallObject {}
 
 export type ProposedAggregatorCallTrace = TypedCallTrace<
   [],
   ProposedAggregatorCallObject
->;
+> &
+  Trace;
 
 export interface ProposedGetRoundDataCallObject {
-  _roundId: BigNumber;
+  _roundId: bigint;
 }
 
 export type ProposedGetRoundDataCallTrace = TypedCallTrace<
-  [BigNumber],
+  [bigint],
   ProposedGetRoundDataCallObject
->;
+> &
+  Trace;
 
 export interface ProposedLatestRoundDataCallObject {}
 
 export type ProposedLatestRoundDataCallTrace = TypedCallTrace<
   [],
   ProposedLatestRoundDataCallObject
->;
+> &
+  Trace;
 
 export interface SetControllerCallObject {
   _accessController: string;
@@ -172,7 +187,8 @@ export interface SetControllerCallObject {
 export type SetControllerCallTrace = TypedCallTrace<
   [string],
   SetControllerCallObject
->;
+> &
+  Trace;
 
 export interface TransferOwnershipCallObject {
   _to: string;
@@ -181,281 +197,238 @@ export interface TransferOwnershipCallObject {
 export type TransferOwnershipCallTrace = TypedCallTrace<
   [string],
   TransferOwnershipCallObject
->;
+> &
+  Trace;
 
 export interface VersionCallObject {}
 
-export type VersionCallTrace = TypedCallTrace<[], VersionCallObject>;
+export type VersionCallTrace = TypedCallTrace<[], VersionCallObject> & Trace;
 
-const templateContract = EACAggregatorProxy__factory.connect("", DummyProvider);
+const templateContract = EACAggregatorProxy__factory.connect(
+  "0x0",
+  DummyProvider
+);
 
 export class EACAggregatorProxyContractView extends ContractView<EACAggregatorProxy> {
   constructor(contract: EACAggregatorProxy) {
     super(contract);
   }
 
-  async accessController(overrides?: CallOverrides): Promise<string> {
+  async accessController(overrides?: Overrides): Promise<string> {
     try {
-      if (overrides) {
-        return await this.contract.accessController(overrides);
-      } else {
-        return await this.contract.accessController();
-      }
+      return await this.contract.getFunction("accessController()")(
+        overrides || {}
+      );
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
-  async aggregator(overrides?: CallOverrides): Promise<string> {
+  async aggregator(overrides?: Overrides): Promise<string> {
     try {
-      if (overrides) {
-        return await this.contract.aggregator(overrides);
-      } else {
-        return await this.contract.aggregator();
-      }
+      return await this.contract.getFunction("aggregator()")(overrides || {});
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
-  async decimals(overrides?: CallOverrides): Promise<number> {
+  async decimals(overrides?: Overrides): Promise<bigint> {
     try {
-      if (overrides) {
-        return await this.contract.decimals(overrides);
-      } else {
-        return await this.contract.decimals();
-      }
+      return await this.contract.getFunction("decimals()")(overrides || {});
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
-  async description(overrides?: CallOverrides): Promise<string> {
+  async description(overrides?: Overrides): Promise<string> {
     try {
-      if (overrides) {
-        return await this.contract.description(overrides);
-      } else {
-        return await this.contract.description();
-      }
+      return await this.contract.getFunction("description()")(overrides || {});
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
   async getAnswer(
-    _roundId: PromiseOrValue<BigNumberish>,
-    overrides?: CallOverrides
-  ): Promise<BigNumber> {
+    _roundId: BigNumberish,
+    overrides?: Overrides
+  ): Promise<bigint> {
     try {
-      if (overrides) {
-        return await this.contract.getAnswer(_roundId, overrides);
-      } else {
-        return await this.contract.getAnswer(_roundId);
-      }
+      return await this.contract.getFunction("getAnswer(uint256)")(
+        _roundId,
+        overrides || {}
+      );
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
   async getRoundData(
-    _roundId: PromiseOrValue<BigNumberish>,
-    overrides?: CallOverrides
+    _roundId: BigNumberish,
+    overrides?: Overrides
   ): Promise<
-    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
-      roundId: BigNumber;
-      answer: BigNumber;
-      startedAt: BigNumber;
-      updatedAt: BigNumber;
-      answeredInRound: BigNumber;
+    [bigint, bigint, bigint, bigint, bigint] & {
+      roundId: bigint;
+      answer: bigint;
+      startedAt: bigint;
+      updatedAt: bigint;
+      answeredInRound: bigint;
     }
   > {
     try {
-      if (overrides) {
-        return await this.contract.getRoundData(_roundId, overrides);
-      } else {
-        return await this.contract.getRoundData(_roundId);
-      }
+      return await this.contract.getFunction("getRoundData(uint80)")(
+        _roundId,
+        overrides || {}
+      );
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
   async getTimestamp(
-    _roundId: PromiseOrValue<BigNumberish>,
-    overrides?: CallOverrides
-  ): Promise<BigNumber> {
+    _roundId: BigNumberish,
+    overrides?: Overrides
+  ): Promise<bigint> {
     try {
-      if (overrides) {
-        return await this.contract.getTimestamp(_roundId, overrides);
-      } else {
-        return await this.contract.getTimestamp(_roundId);
-      }
+      return await this.contract.getFunction("getTimestamp(uint256)")(
+        _roundId,
+        overrides || {}
+      );
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
-  async latestAnswer(overrides?: CallOverrides): Promise<BigNumber> {
+  async latestAnswer(overrides?: Overrides): Promise<bigint> {
     try {
-      if (overrides) {
-        return await this.contract.latestAnswer(overrides);
-      } else {
-        return await this.contract.latestAnswer();
-      }
+      return await this.contract.getFunction("latestAnswer()")(overrides || {});
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
-  async latestRound(overrides?: CallOverrides): Promise<BigNumber> {
+  async latestRound(overrides?: Overrides): Promise<bigint> {
     try {
-      if (overrides) {
-        return await this.contract.latestRound(overrides);
-      } else {
-        return await this.contract.latestRound();
-      }
+      return await this.contract.getFunction("latestRound()")(overrides || {});
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
   async latestRoundData(
-    overrides?: CallOverrides
+    overrides?: Overrides
   ): Promise<
-    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
-      roundId: BigNumber;
-      answer: BigNumber;
-      startedAt: BigNumber;
-      updatedAt: BigNumber;
-      answeredInRound: BigNumber;
+    [bigint, bigint, bigint, bigint, bigint] & {
+      roundId: bigint;
+      answer: bigint;
+      startedAt: bigint;
+      updatedAt: bigint;
+      answeredInRound: bigint;
     }
   > {
     try {
-      if (overrides) {
-        return await this.contract.latestRoundData(overrides);
-      } else {
-        return await this.contract.latestRoundData();
-      }
+      return await this.contract.getFunction("latestRoundData()")(
+        overrides || {}
+      );
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
-  async latestTimestamp(overrides?: CallOverrides): Promise<BigNumber> {
+  async latestTimestamp(overrides?: Overrides): Promise<bigint> {
     try {
-      if (overrides) {
-        return await this.contract.latestTimestamp(overrides);
-      } else {
-        return await this.contract.latestTimestamp();
-      }
+      return await this.contract.getFunction("latestTimestamp()")(
+        overrides || {}
+      );
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
-  async owner(overrides?: CallOverrides): Promise<string> {
+  async owner(overrides?: Overrides): Promise<string> {
     try {
-      if (overrides) {
-        return await this.contract.owner(overrides);
-      } else {
-        return await this.contract.owner();
-      }
+      return await this.contract.getFunction("owner()")(overrides || {});
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
   async phaseAggregators(
-    arg0: PromiseOrValue<BigNumberish>,
-    overrides?: CallOverrides
+    arg0: BigNumberish,
+    overrides?: Overrides
   ): Promise<string> {
     try {
-      if (overrides) {
-        return await this.contract.phaseAggregators(arg0, overrides);
-      } else {
-        return await this.contract.phaseAggregators(arg0);
-      }
+      return await this.contract.getFunction("phaseAggregators(uint16)")(
+        arg0,
+        overrides || {}
+      );
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
-  async phaseId(overrides?: CallOverrides): Promise<number> {
+  async phaseId(overrides?: Overrides): Promise<bigint> {
     try {
-      if (overrides) {
-        return await this.contract.phaseId(overrides);
-      } else {
-        return await this.contract.phaseId();
-      }
+      return await this.contract.getFunction("phaseId()")(overrides || {});
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
-  async proposedAggregator(overrides?: CallOverrides): Promise<string> {
+  async proposedAggregator(overrides?: Overrides): Promise<string> {
     try {
-      if (overrides) {
-        return await this.contract.proposedAggregator(overrides);
-      } else {
-        return await this.contract.proposedAggregator();
-      }
+      return await this.contract.getFunction("proposedAggregator()")(
+        overrides || {}
+      );
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
   async proposedGetRoundData(
-    _roundId: PromiseOrValue<BigNumberish>,
-    overrides?: CallOverrides
+    _roundId: BigNumberish,
+    overrides?: Overrides
   ): Promise<
-    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
-      roundId: BigNumber;
-      answer: BigNumber;
-      startedAt: BigNumber;
-      updatedAt: BigNumber;
-      answeredInRound: BigNumber;
+    [bigint, bigint, bigint, bigint, bigint] & {
+      roundId: bigint;
+      answer: bigint;
+      startedAt: bigint;
+      updatedAt: bigint;
+      answeredInRound: bigint;
     }
   > {
     try {
-      if (overrides) {
-        return await this.contract.proposedGetRoundData(_roundId, overrides);
-      } else {
-        return await this.contract.proposedGetRoundData(_roundId);
-      }
+      return await this.contract.getFunction("proposedGetRoundData(uint80)")(
+        _roundId,
+        overrides || {}
+      );
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
   async proposedLatestRoundData(
-    overrides?: CallOverrides
+    overrides?: Overrides
   ): Promise<
-    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
-      roundId: BigNumber;
-      answer: BigNumber;
-      startedAt: BigNumber;
-      updatedAt: BigNumber;
-      answeredInRound: BigNumber;
+    [bigint, bigint, bigint, bigint, bigint] & {
+      roundId: bigint;
+      answer: bigint;
+      startedAt: bigint;
+      updatedAt: bigint;
+      answeredInRound: bigint;
     }
   > {
     try {
-      if (overrides) {
-        return await this.contract.proposedLatestRoundData(overrides);
-      } else {
-        return await this.contract.proposedLatestRoundData();
-      }
+      return await this.contract.getFunction("proposedLatestRoundData()")(
+        overrides || {}
+      );
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
-  async version(overrides?: CallOverrides): Promise<BigNumber> {
+  async version(overrides?: Overrides): Promise<bigint> {
     try {
-      if (overrides) {
-        return await this.contract.version(overrides);
-      } else {
-        return await this.contract.version();
-      }
+      return await this.contract.getFunction("version()")(overrides || {});
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
@@ -466,108 +439,84 @@ export class EACAggregatorProxyBoundContractView extends BoundContractView<
   EACAggregatorProxy,
   EACAggregatorProxyContractView
 > {
-  // constructor (contract: EACAggregatorProxy) {
-  //   super(contract);
-  // }
-
-  async accessController(overrides?: CallOverrides): Promise<string> {
+  async accessController(overrides?: Overrides): Promise<string> {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.accessController(overrides);
-      } else {
-        return await this.view.accessController();
-      }
+      return await this.view.accessController(overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
-  async aggregator(overrides?: CallOverrides): Promise<string> {
+  async aggregator(overrides?: Overrides): Promise<string> {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.aggregator(overrides);
-      } else {
-        return await this.view.aggregator();
-      }
+      return await this.view.aggregator(overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
-  async decimals(overrides?: CallOverrides): Promise<number> {
+  async decimals(overrides?: Overrides): Promise<bigint> {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.decimals(overrides);
-      } else {
-        return await this.view.decimals();
-      }
+      return await this.view.decimals(overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
-  async description(overrides?: CallOverrides): Promise<string> {
+  async description(overrides?: Overrides): Promise<string> {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.description(overrides);
-      } else {
-        return await this.view.description();
-      }
+      return await this.view.description(overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
   async getAnswer(
-    _roundId: PromiseOrValue<BigNumberish>,
-    overrides?: CallOverrides
-  ): Promise<BigNumber> {
+    _roundId: BigNumberish,
+    overrides?: Overrides
+  ): Promise<bigint> {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.getAnswer(_roundId, overrides);
-      } else {
-        return await this.view.getAnswer(_roundId);
-      }
+      return await this.view.getAnswer(_roundId, overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
   async getRoundData(
-    _roundId: PromiseOrValue<BigNumberish>,
-    overrides?: CallOverrides
+    _roundId: BigNumberish,
+    overrides?: Overrides
   ): Promise<
-    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
-      roundId: BigNumber;
-      answer: BigNumber;
-      startedAt: BigNumber;
-      updatedAt: BigNumber;
-      answeredInRound: BigNumber;
+    [bigint, bigint, bigint, bigint, bigint] & {
+      roundId: bigint;
+      answer: bigint;
+      startedAt: bigint;
+      updatedAt: bigint;
+      answeredInRound: bigint;
     }
   > {
     try {
@@ -576,79 +525,63 @@ export class EACAggregatorProxyBoundContractView extends BoundContractView<
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.getRoundData(_roundId, overrides);
-      } else {
-        return await this.view.getRoundData(_roundId);
-      }
+      return await this.view.getRoundData(_roundId, overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
   async getTimestamp(
-    _roundId: PromiseOrValue<BigNumberish>,
-    overrides?: CallOverrides
-  ): Promise<BigNumber> {
+    _roundId: BigNumberish,
+    overrides?: Overrides
+  ): Promise<bigint> {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.getTimestamp(_roundId, overrides);
-      } else {
-        return await this.view.getTimestamp(_roundId);
-      }
+      return await this.view.getTimestamp(_roundId, overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
-  async latestAnswer(overrides?: CallOverrides): Promise<BigNumber> {
+  async latestAnswer(overrides?: Overrides): Promise<bigint> {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.latestAnswer(overrides);
-      } else {
-        return await this.view.latestAnswer();
-      }
+      return await this.view.latestAnswer(overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
-  async latestRound(overrides?: CallOverrides): Promise<BigNumber> {
+  async latestRound(overrides?: Overrides): Promise<bigint> {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.latestRound(overrides);
-      } else {
-        return await this.view.latestRound();
-      }
+      return await this.view.latestRound(overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
   async latestRoundData(
-    overrides?: CallOverrides
+    overrides?: Overrides
   ): Promise<
-    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
-      roundId: BigNumber;
-      answer: BigNumber;
-      startedAt: BigNumber;
-      updatedAt: BigNumber;
-      answeredInRound: BigNumber;
+    [bigint, bigint, bigint, bigint, bigint] & {
+      roundId: bigint;
+      answer: bigint;
+      startedAt: bigint;
+      updatedAt: bigint;
+      answeredInRound: bigint;
     }
   > {
     try {
@@ -657,53 +590,41 @@ export class EACAggregatorProxyBoundContractView extends BoundContractView<
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.latestRoundData(overrides);
-      } else {
-        return await this.view.latestRoundData();
-      }
+      return await this.view.latestRoundData(overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
-  async latestTimestamp(overrides?: CallOverrides): Promise<BigNumber> {
+  async latestTimestamp(overrides?: Overrides): Promise<bigint> {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.latestTimestamp(overrides);
-      } else {
-        return await this.view.latestTimestamp();
-      }
+      return await this.view.latestTimestamp(overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
-  async owner(overrides?: CallOverrides): Promise<string> {
+  async owner(overrides?: Overrides): Promise<string> {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.owner(overrides);
-      } else {
-        return await this.view.owner();
-      }
+      return await this.view.owner(overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
   async phaseAggregators(
-    arg0: PromiseOrValue<BigNumberish>,
-    overrides?: CallOverrides
+    arg0: BigNumberish,
+    overrides?: Overrides
   ): Promise<string> {
     try {
       if (!overrides && this.context) {
@@ -711,60 +632,48 @@ export class EACAggregatorProxyBoundContractView extends BoundContractView<
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.phaseAggregators(arg0, overrides);
-      } else {
-        return await this.view.phaseAggregators(arg0);
-      }
+      return await this.view.phaseAggregators(arg0, overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
-  async phaseId(overrides?: CallOverrides): Promise<number> {
+  async phaseId(overrides?: Overrides): Promise<bigint> {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.phaseId(overrides);
-      } else {
-        return await this.view.phaseId();
-      }
+      return await this.view.phaseId(overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
-  async proposedAggregator(overrides?: CallOverrides): Promise<string> {
+  async proposedAggregator(overrides?: Overrides): Promise<string> {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.proposedAggregator(overrides);
-      } else {
-        return await this.view.proposedAggregator();
-      }
+      return await this.view.proposedAggregator(overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
   async proposedGetRoundData(
-    _roundId: PromiseOrValue<BigNumberish>,
-    overrides?: CallOverrides
+    _roundId: BigNumberish,
+    overrides?: Overrides
   ): Promise<
-    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
-      roundId: BigNumber;
-      answer: BigNumber;
-      startedAt: BigNumber;
-      updatedAt: BigNumber;
-      answeredInRound: BigNumber;
+    [bigint, bigint, bigint, bigint, bigint] & {
+      roundId: bigint;
+      answer: bigint;
+      startedAt: bigint;
+      updatedAt: bigint;
+      answeredInRound: bigint;
     }
   > {
     try {
@@ -773,25 +682,21 @@ export class EACAggregatorProxyBoundContractView extends BoundContractView<
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.proposedGetRoundData(_roundId, overrides);
-      } else {
-        return await this.view.proposedGetRoundData(_roundId);
-      }
+      return await this.view.proposedGetRoundData(_roundId, overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
   async proposedLatestRoundData(
-    overrides?: CallOverrides
+    overrides?: Overrides
   ): Promise<
-    [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & {
-      roundId: BigNumber;
-      answer: BigNumber;
-      startedAt: BigNumber;
-      updatedAt: BigNumber;
-      answeredInRound: BigNumber;
+    [bigint, bigint, bigint, bigint, bigint] & {
+      roundId: bigint;
+      answer: bigint;
+      startedAt: bigint;
+      updatedAt: bigint;
+      answeredInRound: bigint;
     }
   > {
     try {
@@ -800,28 +705,20 @@ export class EACAggregatorProxyBoundContractView extends BoundContractView<
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.proposedLatestRoundData(overrides);
-      } else {
-        return await this.view.proposedLatestRoundData();
-      }
+      return await this.view.proposedLatestRoundData(overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
-  async version(overrides?: CallOverrides): Promise<BigNumber> {
+  async version(overrides?: Overrides): Promise<bigint> {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.version(overrides);
-      } else {
-        return await this.view.version();
-      }
+      return await this.view.version(overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
@@ -833,96 +730,6 @@ export type EACAggregatorProxyContext = ContractContext<
   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[],
-    fetchConfig?: EthFetchConfig
-  ) {
-    if (!filter) {
-      // @ts-ignore
-      filter = EACAggregatorProxyProcessor.filters[
-        // @ts-ignore
-        "AnswerUpdated(int256,uint256,uint256)"
-      ](null, null, null);
-    }
-    return super.onEvent(handler, filter!, fetchConfig);
-  }
-
-  onEventNewRound(
-    handler: (event: NewRoundEvent, ctx: EACAggregatorProxyContext) => void,
-    filter?: NewRoundEventFilter | NewRoundEventFilter[],
-    fetchConfig?: EthFetchConfig
-  ) {
-    if (!filter) {
-      // @ts-ignore
-      filter = EACAggregatorProxyProcessor.filters[
-        // @ts-ignore
-        "NewRound(uint256,address,uint256)"
-      ](null, null, null);
-    }
-    return super.onEvent(handler, filter!, fetchConfig);
-  }
-
-  onEventOwnershipTransferRequested(
-    handler: (
-      event: OwnershipTransferRequestedEvent,
-      ctx: EACAggregatorProxyContext
-    ) => void,
-    filter?:
-      | OwnershipTransferRequestedEventFilter
-      | OwnershipTransferRequestedEventFilter[],
-    fetchConfig?: EthFetchConfig
-  ) {
-    if (!filter) {
-      // @ts-ignore
-      filter = EACAggregatorProxyProcessor.filters[
-        // @ts-ignore
-        "OwnershipTransferRequested(address,address)"
-      ](null, null);
-    }
-    return super.onEvent(handler, filter!, fetchConfig);
-  }
-
-  onEventOwnershipTransferred(
-    handler: (
-      event: OwnershipTransferredEvent,
-      ctx: EACAggregatorProxyContext
-    ) => void,
-    filter?:
-      | OwnershipTransferredEventFilter
-      | OwnershipTransferredEventFilter[],
-    fetchConfig?: EthFetchConfig
-  ) {
-    if (!filter) {
-      // @ts-ignore
-      filter = EACAggregatorProxyProcessor.filters[
-        // @ts-ignore
-        "OwnershipTransferred(address,address)"
-      ](null, null);
-    }
-    return super.onEvent(handler, filter!, fetchConfig);
-  }
-}
-
 export class EACAggregatorProxyProcessor extends BaseProcessor<
   EACAggregatorProxy,
   EACAggregatorProxyBoundContractView
@@ -936,9 +743,7 @@ export class EACAggregatorProxyProcessor extends BaseProcessor<
     fetchConfig?: EthFetchConfig
   ) {
     if (!filter) {
-      // @ts-ignore
-      filter = EACAggregatorProxyProcessor.filters[
-        // @ts-ignore
+      filter = templateContract.filters[
         "AnswerUpdated(int256,uint256,uint256)"
       ](null, null, null);
     }
@@ -951,11 +756,11 @@ export class EACAggregatorProxyProcessor extends BaseProcessor<
     fetchConfig?: EthFetchConfig
   ) {
     if (!filter) {
-      // @ts-ignore
-      filter = EACAggregatorProxyProcessor.filters[
-        // @ts-ignore
-        "NewRound(uint256,address,uint256)"
-      ](null, null, null);
+      filter = templateContract.filters["NewRound(uint256,address,uint256)"](
+        null,
+        null,
+        null
+      );
     }
     return super.onEvent(handler, filter!, fetchConfig);
   }
@@ -971,9 +776,7 @@ export class EACAggregatorProxyProcessor extends BaseProcessor<
     fetchConfig?: EthFetchConfig
   ) {
     if (!filter) {
-      // @ts-ignore
-      filter = EACAggregatorProxyProcessor.filters[
-        // @ts-ignore
+      filter = templateContract.filters[
         "OwnershipTransferRequested(address,address)"
       ](null, null);
     }
@@ -991,9 +794,7 @@ export class EACAggregatorProxyProcessor extends BaseProcessor<
     fetchConfig?: EthFetchConfig
   ) {
     if (!filter) {
-      // @ts-ignore
-      filter = EACAggregatorProxyProcessor.filters[
-        // @ts-ignore
+      filter = templateContract.filters[
         "OwnershipTransferred(address,address)"
       ](null, null);
     }
@@ -1215,7 +1016,41 @@ export class EACAggregatorProxyProcessor extends BaseProcessor<
     return super.onTrace("0x54fd4d50", handler, fetchConfig);
   }
 
-  public static filters = templateContract.filters;
+  public static filters = {
+    AnswerUpdated(
+      current?: BigNumberish | null,
+      roundId?: BigNumberish | null,
+      updatedAt?: null
+    ) {
+      return templateContract.filters["AnswerUpdated(int256,uint256,uint256)"](
+        current,
+        roundId,
+        updatedAt
+      );
+    },
+    NewRound(
+      roundId?: BigNumberish | null,
+      startedBy?: string | null,
+      startedAt?: null
+    ) {
+      return templateContract.filters["NewRound(uint256,address,uint256)"](
+        roundId,
+        startedBy,
+        startedAt
+      );
+    },
+    OwnershipTransferRequested(from?: string | null, to?: string | null) {
+      return templateContract.filters[
+        "OwnershipTransferRequested(address,address)"
+      ](from, to);
+    },
+    OwnershipTransferred(from?: string | null, to?: string | null) {
+      return templateContract.filters["OwnershipTransferred(address,address)"](
+        from,
+        to
+      );
+    },
+  };
 
   protected CreateBoundContractView(): EACAggregatorProxyBoundContractView {
     const view = getEACAggregatorProxyContract(
@@ -1238,6 +1073,90 @@ export class EACAggregatorProxyProcessor extends BaseProcessor<
   }
 }
 
+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[],
+    fetchConfig?: EthFetchConfig
+  ) {
+    if (!filter) {
+      filter = templateContract.filters[
+        "AnswerUpdated(int256,uint256,uint256)"
+      ](null, null, null);
+    }
+    return super.onEvent(handler, filter!, fetchConfig);
+  }
+
+  onEventNewRound(
+    handler: (event: NewRoundEvent, ctx: EACAggregatorProxyContext) => void,
+    filter?: NewRoundEventFilter | NewRoundEventFilter[],
+    fetchConfig?: EthFetchConfig
+  ) {
+    if (!filter) {
+      filter = templateContract.filters["NewRound(uint256,address,uint256)"](
+        null,
+        null,
+        null
+      );
+    }
+    return super.onEvent(handler, filter!, fetchConfig);
+  }
+
+  onEventOwnershipTransferRequested(
+    handler: (
+      event: OwnershipTransferRequestedEvent,
+      ctx: EACAggregatorProxyContext
+    ) => void,
+    filter?:
+      | OwnershipTransferRequestedEventFilter
+      | OwnershipTransferRequestedEventFilter[],
+    fetchConfig?: EthFetchConfig
+  ) {
+    if (!filter) {
+      filter = templateContract.filters[
+        "OwnershipTransferRequested(address,address)"
+      ](null, null);
+    }
+    return super.onEvent(handler, filter!, fetchConfig);
+  }
+
+  onEventOwnershipTransferred(
+    handler: (
+      event: OwnershipTransferredEvent,
+      ctx: EACAggregatorProxyContext
+    ) => void,
+    filter?:
+      | OwnershipTransferredEventFilter
+      | OwnershipTransferredEventFilter[],
+    fetchConfig?: EthFetchConfig
+  ) {
+    if (!filter) {
+      filter = templateContract.filters[
+        "OwnershipTransferred(address,address)"
+      ](null, null);
+    }
+    return super.onEvent(handler, filter!, fetchConfig);
+  }
+}
+
 export function getEACAggregatorProxyContract(
   address: string,
   network: Networkish = 1