EACAggregatorProxyProcessor

new EACAggregatorProxyProcessor(config: BindOptions): EACAggregatorProxyProcessor;

getChainId(): EthChainId;

onBlockInterval(
   handler: (block: RichBlock, ctx: ContractContext<EACAggregatorProxy, EACAggregatorProxyBoundContractView>) => PromiseOrVoid, 
   blockInterval?: number, 
   backfillBlockInterval?: number, 
   handlerOptions?: HandlerOptions<EthFetchConfig, RichBlock>, 
   preprocessHandler?: (block: RichBlock, ctx: ContractContext<EACAggregatorProxy, EACAggregatorProxyBoundContractView>, preprocessStore: object) => Promise<PreprocessResult>
): this;

onCallAcceptOwnership(
   handler: (call: AcceptOwnershipCallTrace, ctx: EACAggregatorProxyContext) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, AcceptOwnershipCallTrace>, 
   preprocessHandler?: (call: AcceptOwnershipCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>
): this;

onCallAccessController(
   handler: (call: AccessControllerCallTrace, ctx: EACAggregatorProxyContext) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, AccessControllerCallTrace>, 
   preprocessHandler?: (call: AccessControllerCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>
): this;

onCallAggregator(
   handler: (call: AggregatorCallTrace, ctx: EACAggregatorProxyContext) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, AggregatorCallTrace>, 
   preprocessHandler?: (call: AggregatorCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>
): this;

onCallConfirmAggregator(
   handler: (call: ConfirmAggregatorCallTrace, ctx: EACAggregatorProxyContext) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, ConfirmAggregatorCallTrace>, 
   preprocessHandler?: (call: ConfirmAggregatorCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>
): this;

onCallDecimals(
   handler: (call: DecimalsCallTrace, ctx: EACAggregatorProxyContext) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, DecimalsCallTrace>, 
   preprocessHandler?: (call: DecimalsCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>
): this;

onCallDescription(
   handler: (call: DescriptionCallTrace, ctx: EACAggregatorProxyContext) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, DescriptionCallTrace>, 
   preprocessHandler?: (call: DescriptionCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>
): this;

onCallGetAnswer(
   handler: (call: GetAnswerCallTrace, ctx: EACAggregatorProxyContext) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, GetAnswerCallTrace>, 
   preprocessHandler?: (call: GetAnswerCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>
): this;

onCallGetRoundData(
   handler: (call: GetRoundDataCallTrace, ctx: EACAggregatorProxyContext) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, GetRoundDataCallTrace>, 
   preprocessHandler?: (call: GetRoundDataCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>
): this;

onCallGetTimestamp(
   handler: (call: GetTimestampCallTrace, ctx: EACAggregatorProxyContext) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, GetTimestampCallTrace>, 
   preprocessHandler?: (call: GetTimestampCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>
): this;

onCallLatestAnswer(
   handler: (call: LatestAnswerCallTrace, ctx: EACAggregatorProxyContext) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, LatestAnswerCallTrace>, 
   preprocessHandler?: (call: LatestAnswerCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>
): this;

onCallLatestRound(
   handler: (call: LatestRoundCallTrace, ctx: EACAggregatorProxyContext) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, LatestRoundCallTrace>, 
   preprocessHandler?: (call: LatestRoundCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>
): this;

onCallLatestRoundData(
   handler: (call: LatestRoundDataCallTrace, ctx: EACAggregatorProxyContext) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, LatestRoundDataCallTrace>, 
   preprocessHandler?: (call: LatestRoundDataCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>
): this;

onCallLatestTimestamp(
   handler: (call: LatestTimestampCallTrace, ctx: EACAggregatorProxyContext) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, LatestTimestampCallTrace>, 
   preprocessHandler?: (call: LatestTimestampCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>
): this;

onCallOwner(
   handler: (call: OwnerCallTrace, ctx: EACAggregatorProxyContext) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, OwnerCallTrace>, 
   preprocessHandler?: (call: OwnerCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>
): this;

onCallPhaseAggregators(
   handler: (call: PhaseAggregatorsCallTrace, ctx: EACAggregatorProxyContext) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, PhaseAggregatorsCallTrace>, 
   preprocessHandler?: (call: PhaseAggregatorsCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>
): this;

onCallPhaseId(
   handler: (call: PhaseIdCallTrace, ctx: EACAggregatorProxyContext) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, PhaseIdCallTrace>, 
   preprocessHandler?: (call: PhaseIdCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>
): this;

onCallProposeAggregator(
   handler: (call: ProposeAggregatorCallTrace, ctx: EACAggregatorProxyContext) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, ProposeAggregatorCallTrace>, 
   preprocessHandler?: (call: ProposeAggregatorCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>
): this;

onCallProposedAggregator(
   handler: (call: ProposedAggregatorCallTrace, ctx: EACAggregatorProxyContext) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, ProposedAggregatorCallTrace>, 
   preprocessHandler?: (call: ProposedAggregatorCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>
): this;

onCallProposedGetRoundData(
   handler: (call: ProposedGetRoundDataCallTrace, ctx: EACAggregatorProxyContext) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, ProposedGetRoundDataCallTrace>, 
   preprocessHandler?: (call: ProposedGetRoundDataCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>
): this;

onCallProposedLatestRoundData(
   handler: (call: ProposedLatestRoundDataCallTrace, ctx: EACAggregatorProxyContext) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, ProposedLatestRoundDataCallTrace>, 
   preprocessHandler?: (call: ProposedLatestRoundDataCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>
): this;

onCallSetController(
   handler: (call: SetControllerCallTrace, ctx: EACAggregatorProxyContext) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, SetControllerCallTrace>, 
   preprocessHandler?: (call: SetControllerCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>
): this;

onCallTransferOwnership(
   handler: (call: TransferOwnershipCallTrace, ctx: EACAggregatorProxyContext) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, TransferOwnershipCallTrace>, 
   preprocessHandler?: (call: TransferOwnershipCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>
): this;

onCallVersion(
   handler: (call: VersionCallTrace, ctx: EACAggregatorProxyContext) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, VersionCallTrace>, 
   preprocessHandler?: (call: VersionCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>
): this;

onEvent<T extends TypedEvent<any, any> = TypedEvent<any, any>>(
   handler: (event: T, ctx: ContractContext<EACAggregatorProxy, EACAggregatorProxyBoundContractView>) => PromiseOrVoid, 
   handlerOptions?: HandlerOptions<EthFetchConfig, T>, 
   preprocessHandler?: (event: T, ctx: ContractContext<EACAggregatorProxy, EACAggregatorProxyBoundContractView>, preprocessStore: object) => Promise<PreprocessResult>
): this;

onEventAnswerUpdated(
   handler: (event: AnswerUpdatedEvent, ctx: EACAggregatorProxyContext) => void, 
   filter?: DeferredTopicFilter | DeferredTopicFilter[], 
   handlerOptions?: HandlerOptions<EthFetchConfig, AnswerUpdatedEvent>, 
   preprocessHandler?: (event: AnswerUpdatedEvent, ctx: EACAggregatorProxyContext, preprocessStore: object) => Promise<PreprocessResult>
): this;

onEventNewRound(
   handler: (event: NewRoundEvent, ctx: EACAggregatorProxyContext) => void, 
   filter?: DeferredTopicFilter | DeferredTopicFilter[], 
   handlerOptions?: HandlerOptions<EthFetchConfig, NewRoundEvent>, 
   preprocessHandler?: (event: NewRoundEvent, ctx: EACAggregatorProxyContext, preprocessStore: object) => Promise<PreprocessResult>
): this;

onEventOwnershipTransferred(
   handler: (event: OwnershipTransferredEvent, ctx: EACAggregatorProxyContext) => void, 
   filter?: DeferredTopicFilter | DeferredTopicFilter[], 
   handlerOptions?: HandlerOptions<EthFetchConfig, OwnershipTransferredEvent>, 
   preprocessHandler?: (event: OwnershipTransferredEvent, ctx: EACAggregatorProxyContext, preprocessStore: object) => Promise<PreprocessResult>
): this;

onEventOwnershipTransferRequested(
   handler: (event: OwnershipTransferRequestedEvent, ctx: EACAggregatorProxyContext) => void, 
   filter?: DeferredTopicFilter | DeferredTopicFilter[], 
   handlerOptions?: HandlerOptions<EthFetchConfig, OwnershipTransferRequestedEvent>, 
   preprocessHandler?: (event: OwnershipTransferRequestedEvent, ctx: EACAggregatorProxyContext, preprocessStore: object) => Promise<PreprocessResult>
): this;

onInterval(
   handler: (block: RichBlock, ctx: ContractContext<EACAggregatorProxy, EACAggregatorProxyBoundContractView>) => PromiseOrVoid, 
   timeInterval: 
  | HandleInterval
  | undefined, 
   blockInterval: 
  | HandleInterval
  | undefined, 
   handlerOptions?: HandlerOptions<EthFetchConfig, RichBlock>, 
   preprocessHandler?: (block: RichBlock, ctx: ContractContext<EACAggregatorProxy, EACAggregatorProxyBoundContractView>, preprocessStore: object) => Promise<PreprocessResult>, 
   handlerName?: string
): this;

onTimeInterval(
   handler: (block: RichBlock, ctx: ContractContext<EACAggregatorProxy, EACAggregatorProxyBoundContractView>) => PromiseOrVoid, 
   timeIntervalInMinutes?: number, 
   backfillTimeIntervalInMinutes?: number, 
   handlerOptions?: HandlerOptions<EthFetchConfig, RichBlock>, 
   preprocessHandler?: (block: RichBlock, ctx: ContractContext<EACAggregatorProxy, EACAggregatorProxyBoundContractView>, preprocessStore: object) => Promise<PreprocessResult>
): this;

onTrace(
   handler: (event: TypedCallTrace, ctx: ContractContext<EACAggregatorProxy, EACAggregatorProxyBoundContractView>) => PromiseOrVoid, 
   handlerOptions?: HandlerOptions<EthFetchConfig, TypedCallTrace<any, any>>, 
   preprocessHandler?: (trace: TypedCallTrace, ctx: ContractContext<EACAggregatorProxy, EACAggregatorProxyBoundContractView>, preprocessStore: object) => Promise<PreprocessResult>
): this;

static bind(options: BindOptions): EACAggregatorProxyProcessor;