ERC20Processor

new ERC20Processor(config: BindOptions): ERC20Processor;

getChainId(): EthChainId;

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

onCallAllowance(
   handler: (call: AllowanceCallTrace, ctx: ERC20Context) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, AllowanceCallTrace>, 
   preprocessHandler?: (call: AllowanceCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>
): this;

onCallApprove(
   handler: (call: ApproveCallTrace, ctx: ERC20Context) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, ApproveCallTrace>, 
   preprocessHandler?: (call: ApproveCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>
): this;

onCallBalanceOf(
   handler: (call: BalanceOfCallTrace, ctx: ERC20Context) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, BalanceOfCallTrace>, 
   preprocessHandler?: (call: BalanceOfCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>
): this;

onCallBurn(
   handler: (call: BurnCallTrace, ctx: ERC20Context) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, BurnCallTrace>, 
   preprocessHandler?: (call: BurnCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>
): this;

onCallBurnFrom(
   handler: (call: BurnFromCallTrace, ctx: ERC20Context) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, BurnFromCallTrace>, 
   preprocessHandler?: (call: BurnFromCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>
): this;

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

onCallDecreaseAllowance(
   handler: (call: DecreaseAllowanceCallTrace, ctx: ERC20Context) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, DecreaseAllowanceCallTrace>, 
   preprocessHandler?: (call: DecreaseAllowanceCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>
): this;

onCallIncreaseAllowance(
   handler: (call: IncreaseAllowanceCallTrace, ctx: ERC20Context) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, IncreaseAllowanceCallTrace>, 
   preprocessHandler?: (call: IncreaseAllowanceCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>
): this;

onCallLocker(
   handler: (call: LockerCallTrace, ctx: ERC20Context) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, LockerCallTrace>, 
   preprocessHandler?: (call: LockerCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>
): this;

onCallName(
   handler: (call: NameCallTrace, ctx: ERC20Context) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, NameCallTrace>, 
   preprocessHandler?: (call: NameCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>
): this;

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

onCallRenounceOwnership(
   handler: (call: RenounceOwnershipCallTrace, ctx: ERC20Context) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, RenounceOwnershipCallTrace>, 
   preprocessHandler?: (call: RenounceOwnershipCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>
): this;

onCallSetLocker(
   handler: (call: SetLockerCallTrace, ctx: ERC20Context) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, SetLockerCallTrace>, 
   preprocessHandler?: (call: SetLockerCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>
): this;

onCallSymbol(
   handler: (call: SymbolCallTrace, ctx: ERC20Context) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, SymbolCallTrace>, 
   preprocessHandler?: (call: SymbolCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>
): this;

onCallTotalSupply(
   handler: (call: TotalSupplyCallTrace, ctx: ERC20Context) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, TotalSupplyCallTrace>, 
   preprocessHandler?: (call: TotalSupplyCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>
): this;

onCallTransfer(
   handler: (call: TransferCallTrace, ctx: ERC20Context) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, TransferCallTrace>, 
   preprocessHandler?: (call: TransferCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>
): this;

onCallTransferFrom(
   handler: (call: TransferFromCallTrace, ctx: ERC20Context) => void, 
   handlerOptions?: HandlerOptions<EthFetchConfig, TransferFromCallTrace>, 
   preprocessHandler?: (call: TransferFromCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>
): this;

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

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

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

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

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

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

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

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

static bind(options: BindOptions): ERC20Processor;