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

package/src/builtin/solana/wormhole-processor.ts

@@ -0,0 +1,178 @@
+import { SolanaBaseProcessor, SolanaContext, SolanaBindOptions } from '@sentio/sdk'
+import { Instruction } from '@project-serum/anchor'
+import * as borsh from "@coral-xyz/borsh";
+import bs58 from 'bs58'
+
+// https://github.com/certusone/wormhole/blob/8818d4b8f0471095dd48fa6f5da9c315cbfc9b52/solana/modules/token_bridge/program/src/lib.rs#L100
+enum TokenBridgeInstruction {
+  Initialize = 0,
+  AttestToken,
+  CompleteNative, // no args
+  CompleteWrapped, // no args
+  TransferWrapped,
+  TransferNative,
+  RegisterChain, // no args
+  CreateWrapped, // no args
+  UpgradeContract, // no args
+  CompleteNativeWithPayload, // no args
+  CompleteWrappedWithPayload, // no args
+  TransferWrappedWithPayload,
+  TransferNativeWithPayload,
+}
+
+export class TokenBridgeProcessor extends SolanaBaseProcessor {
+
+  private readonly transferDataValues = [
+    borsh.u32('nonce'),
+    borsh.u64('amount'),
+    borsh.u64('fee'),
+    borsh.array(borsh.u8(undefined), 32, 'target_address'),
+    borsh.u16('target_chain')
+  ]
+  // https://github.com/certusone/wormhole/blob/8818d4b8f0471095dd48fa6f5da9c315cbfc9b52/solana/modules/token_bridge/program/src/api/transfer_payload.rs#L170
+  private readonly transferDataWithPayloadValues = [
+    borsh.u32('nonce'),
+    borsh.u64('amount'),
+    borsh.array(borsh.u8(undefined), 32, 'target_address'),
+    borsh.u16('target_chain'),
+    borsh.vecU8('payload'),
+    borsh.option(borsh.publicKey(undefined), 'cpi_program_id')
+  ]
+  private readonly attestTokenValues = [
+    borsh.u32('nonce')
+  ]
+  private readonly initializeDataValues = [
+    borsh.publicKey('bridge')
+  ]
+
+  static bind(options: SolanaBindOptions): TokenBridgeProcessor {
+    if (options && !options.name) {
+      options.name = 'WormholeTokenBridge'
+    }
+    return new TokenBridgeProcessor(options)
+  }
+
+  decodeInstruction: (rawInstruction: string) => Instruction | null = (ins) => {
+    const u8Arr = bs58.decode(ins)
+    if (u8Arr.length === 0) {
+      return null
+    }
+
+    let data: any
+    // wormhole pass intruction's enum value as its first instrcution data
+    switch (u8Arr[0]) {
+      case TokenBridgeInstruction.Initialize:
+        return {
+          data: '',
+          name: TokenBridgeInstruction[TokenBridgeInstruction.Initialize]
+        }
+      case TokenBridgeInstruction.TransferNative:
+        // struct is defined at: https://github.com/certusone/wormhole/blob/8818d4b8f0471095dd48fa6f5da9c315cbfc9b52/solana/modules/token_bridge/program/src/api/transfer.rs#L295
+        data = borsh.struct(this.transferDataValues, 'TransferNativeData').decode(Buffer.from(u8Arr.slice(1)))
+        return {
+          data,
+          name: TokenBridgeInstruction[TokenBridgeInstruction.TransferNative]
+        }
+      case TokenBridgeInstruction.TransferWrapped:
+        // stuct is defined at: https://github.com/certusone/wormhole/blob/8818d4b8f0471095dd48fa6f5da9c315cbfc9b52/solana/modules/token_bridge/program/src/api/transfer.rs#L295
+        data = borsh.struct(this.transferDataValues, 'TransferWrappedData').decode(Buffer.from(u8Arr.slice(1)))
+        return {
+          data,
+          name: TokenBridgeInstruction[TokenBridgeInstruction.TransferWrapped]
+        }
+      case TokenBridgeInstruction.TransferNativeWithPayload:
+        data = borsh.struct(this.transferDataWithPayloadValues, 'TransferNativeWithPayloadData').decode(Buffer.from(u8Arr.slice(1)))
+        return {
+          data,
+          name: TokenBridgeInstruction[TokenBridgeInstruction.TransferNativeWithPayload]
+        }
+      case TokenBridgeInstruction.TransferWrappedWithPayload:
+        data = borsh.struct(this.transferDataWithPayloadValues, 'TransferWrappedWithPayloadData').decode(Buffer.from(u8Arr.slice(1)))
+        return {
+          data,
+          name: TokenBridgeInstruction[TokenBridgeInstruction.TransferWrappedWithPayload]
+        }
+      case TokenBridgeInstruction.Initialize:
+        data = borsh.struct(this.initializeDataValues, 'InitializeData').decode(Buffer.from(u8Arr.slice(1)))
+        return {
+          data,
+          name: TokenBridgeInstruction[TokenBridgeInstruction.Initialize]
+        }
+      case TokenBridgeInstruction.AttestToken:
+        data = borsh.struct(this.attestTokenValues, 'AttestTokenData').decode(Buffer.from(u8Arr.slice(1)))
+        return {
+          data,
+          name: TokenBridgeInstruction[TokenBridgeInstruction.AttestToken]
+        }
+      case TokenBridgeInstruction.CompleteNative:
+      case TokenBridgeInstruction.CompleteNativeWithPayload:
+      case TokenBridgeInstruction.CompleteWrapped:
+      case TokenBridgeInstruction.CompleteWrappedWithPayload:
+      case TokenBridgeInstruction.CreateWrapped:
+      case TokenBridgeInstruction.UpgradeContract:
+      case TokenBridgeInstruction.RegisterChain:
+        return {
+          data: '',
+          name: TokenBridgeInstruction[u8Arr[0]]
+        }
+
+      default:
+        return null
+    }
+  }
+
+  onInitialize(handler: (args: any, accounts: string[], ctx: SolanaContext) => void): TokenBridgeProcessor {
+    this.onInstruction('Initialize', (ins: Instruction, ctx, accounts: string[]) => {
+      if (ins) {
+        handler(ins.data, accounts, ctx)
+      }
+    })
+    return this
+  }
+
+  onAttestToken(handler: (args: any, accounts: string[], ctx: SolanaContext) => void): TokenBridgeProcessor {
+    this.onInstruction('AttestToken', (ins: Instruction, ctx, accounts: string[]) => {
+      if (ins) {
+        handler(ins.data, accounts, ctx)
+      }
+    })
+    return this
+  }
+
+
+  onTransferWrapped(handler: (args: any, accounts: string[], ctx: SolanaContext) => void): TokenBridgeProcessor {
+    this.onInstruction('TransferWrapped', (ins: Instruction, ctx, accounts: string[]) => {
+      if (ins) {
+        handler(ins.data, accounts, ctx)
+      }
+    })
+    return this
+  }
+
+  onTransferNativeWithPayload(handler: (args: any, accounts: string[], ctx: SolanaContext) => void): TokenBridgeProcessor {
+    this.onInstruction('TransferNativeWithPayload', (ins: Instruction, ctx, accounts: string[]) => {
+      if (ins) {
+        handler(ins.data,  accounts, ctx)
+      }
+    })
+    return this
+  }
+
+  onTransferWrappedWithPaylod(handler: (args: any, accounts: string[], ctx: SolanaContext) => void): TokenBridgeProcessor {
+    this.onInstruction('TransferWrappedWithPaylod', (ins: Instruction, ctx, accounts: string[]) => {
+      if (ins) {
+        handler(ins.data, accounts, ctx)
+      }
+    })
+    return this
+  }
+
+  onTransferNative(handler: (args: any, accounts: string[], ctx: SolanaContext) => void): TokenBridgeProcessor {
+    this.onInstruction('TransferNative', (ins: Instruction, ctx, accounts: string[]) => {
+      if (ins) {
+        handler(ins.data, accounts, ctx)
+      }
+    })
+    return this
+  }
+}

package/src/builtin/weth9/index.ts

@@ -0,0 +1,6 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+export * from "../internal/weth9_processor";
+export * from "../internal/WETH9";

package/src/builtin/weth9/test-utils.ts

@@ -0,0 +1,89 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import { Log } from "@ethersproject/providers";
+import {
+  getWETH9Contract,
+  ApprovalEventObject,
+  TransferEventObject,
+  DepositEventObject,
+  WithdrawalEventObject,
+} from ".";
+const mockField = {
+  blockHash:
+    "0x0000000000000000000000000000000000000000000000000000000000000000",
+  blockNumber: 0,
+  logIndex: 0,
+  removed: false,
+  transactionHash:
+    "0x0000000000000000000000000000000000000000000000000000000000000000",
+  transactionIndex: 0,
+};
+
+export function mockApprovalLog(
+  contractAddress: string,
+  event: ApprovalEventObject
+): Log {
+  const contract = getWETH9Contract(contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    contract.rawContract.interface.getEvent("Approval"),
+    [event.src, event.guy, event.wad]
+  );
+  return {
+    ...mockField,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics,
+  };
+}
+
+export function mockTransferLog(
+  contractAddress: string,
+  event: TransferEventObject
+): Log {
+  const contract = getWETH9Contract(contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    contract.rawContract.interface.getEvent("Transfer"),
+    [event.src, event.dst, event.wad]
+  );
+  return {
+    ...mockField,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics,
+  };
+}
+
+export function mockDepositLog(
+  contractAddress: string,
+  event: DepositEventObject
+): Log {
+  const contract = getWETH9Contract(contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    contract.rawContract.interface.getEvent("Deposit"),
+    [event.dst, event.wad]
+  );
+  return {
+    ...mockField,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics,
+  };
+}
+
+export function mockWithdrawalLog(
+  contractAddress: string,
+  event: WithdrawalEventObject
+): Log {
+  const contract = getWETH9Contract(contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    contract.rawContract.interface.getEvent("Withdrawal"),
+    [event.src, event.wad]
+  );
+  return {
+    ...mockField,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics,
+  };
+}

package/src/chain-config.ts

@@ -0,0 +1,6 @@
+export interface ChainConfig {
+  ChainID: string
+  Https: string[]
+  WebSockets?: string[]
+  ChainServer?: string
+}

package/src/core/account-processor.ts

@@ -0,0 +1,217 @@
+import { ListStateStorage } from '../state/state-storage'
+import { ERC20__factory, ERC721__factory } from '../builtin/internal'
+import { AddressType, DummyProvider, ProcessResult } from '@sentio/sdk'
+import { AccountBindOptions } from './bind-options'
+import { getNetwork } from '@ethersproject/providers'
+import { TransferEvent as ERC20TransferEvent } from '../builtin/internal/ERC20'
+import { TransferEvent as ERC721TransferEvent } from '../builtin/internal/ERC721'
+import { AccountContext } from './context'
+import { PromiseOrVoid } from '../promise-or-void'
+import { Event } from '@ethersproject/contracts'
+import { BytesLike } from '@ethersproject/bytes'
+import { AddressOrTypeEventFilter, EventsHandler } from './base-processor'
+
+export class AccountProcessorState extends ListStateStorage<AccountProcessor> {
+  static INSTANCE = new AccountProcessorState()
+}
+
+const ERC20_CONTRACT = ERC20__factory.connect('', DummyProvider)
+const ERC721_CONTRACT = ERC721__factory.connect('', DummyProvider)
+
+export class AccountProcessor {
+  config: AccountBindOptions
+  eventHandlers: EventsHandler[] = []
+
+  static bind(config: AccountBindOptions): AccountProcessor {
+    const processor = new AccountProcessor(config)
+    AccountProcessorState.INSTANCE.addValue(processor)
+    return processor
+  }
+
+  protected constructor(config: AccountBindOptions) {
+    this.config = config
+  }
+
+  public getChainId(): number {
+    return getNetwork(this.config.network || 1).chainId
+  }
+
+  /**
+   * Register custom handler function to process erc20 transfer event to this account
+   * @param handler custom handler function
+   * @param tokensAddresses all the erc20 token address to watch
+   */
+  onERC20TransferIn(
+    handler: (event: ERC20TransferEvent, ctx: AccountContext) => PromiseOrVoid,
+    tokensAddresses: string[] = []
+  ) {
+    return this.onERC20(handler, tokensAddresses, (address: string) =>
+      ERC20_CONTRACT.filters.Transfer(null, this.config.address)
+    )
+  }
+
+  /**
+   * Register custom handler function to process erc20 transfer event from this account
+   * @param handler custom handler function
+   * @param tokensAddresses all the erc20 token address to watch
+   */
+  onERC20TransferOut(
+    handler: (event: ERC20TransferEvent, ctx: AccountContext) => PromiseOrVoid,
+    tokensAddresses: string[] = []
+  ) {
+    return this.onERC20(handler, tokensAddresses, (address: string) =>
+      ERC20_CONTRACT.filters.Transfer(this.config.address)
+    )
+  }
+
+  /**
+   * Register custom handler function to process erc20 mint for this account
+   * @param handler custom handler function
+   * @param tokensAddresses all the erc20 token address to watch
+   */
+  onERC20Minted(
+    handler: (event: ERC20TransferEvent, ctx: AccountContext) => PromiseOrVoid,
+    tokensAddresses: string[] = []
+  ) {
+    return this.onERC20(handler, tokensAddresses, (address: string) =>
+      ERC20_CONTRACT.filters.Transfer('0x0000000000000000000000000000000000000000', this.config.address)
+    )
+  }
+
+  private onERC20(
+    handler: (event: ERC20TransferEvent, ctx: AccountContext) => PromiseOrVoid,
+    tokensAddresses: string[] = [],
+    defaultFilter: (address: string) => AddressOrTypeEventFilter
+  ) {
+    return this.onERC(handler, tokensAddresses, defaultFilter, AddressType.ERC20)
+  }
+
+  /**
+   * Register custom handler function to process ERC721 transfer event to this account
+   * @param handler custom handler function
+   * @param collections all the ERC721 token address to watch, if not provided then watch all ERC721
+   */
+  onERC721TransferIn(
+    handler: (event: ERC721TransferEvent, ctx: AccountContext) => PromiseOrVoid,
+    collections: string[]
+  ) {
+    return this.onERC721(handler, collections, (address: string) =>
+      ERC721_CONTRACT.filters.Transfer(null, this.config.address)
+    )
+  }
+
+  /**
+   * Register custom handler function to process ERC721 transfer event from this account
+   * @param handler custom handler function
+   * @param collections all the ERC721 token address to watch, if not provided then watch all ERC721
+   */
+  onERC721TransferOut(
+    handler: (event: ERC721TransferEvent, ctx: AccountContext) => PromiseOrVoid,
+    collections: string[]
+  ) {
+    return this.onERC721(handler, collections, (address: string) =>
+      ERC721_CONTRACT.filters.Transfer(this.config.address)
+    )
+  }
+
+  /**
+   * Register custom handler function to process ERC721 mint for this account
+   * @param handler custom handler function
+   * @param collections all the ERC721 token address to watch, if not provided then watch all ERC721
+   */
+  onERC721Minted(
+    handler: (event: ERC721TransferEvent, ctx: AccountContext) => PromiseOrVoid,
+    collections: string[] = []
+  ) {
+    return this.onERC721(handler, collections, (address: string) =>
+      ERC721_CONTRACT.filters.Transfer('0x0000000000000000000000000000000000000000', this.config.address)
+    )
+  }
+
+  private onERC721(
+    handler: (event: ERC721TransferEvent, ctx: AccountContext) => PromiseOrVoid,
+    collections: string[],
+    defaultFilter: (address: string) => AddressOrTypeEventFilter
+  ) {
+    return this.onERC(handler, collections, defaultFilter, AddressType.ERC721)
+  }
+
+  private onERC(
+    handler: (event: any, ctx: AccountContext) => PromiseOrVoid,
+    contractAddresses: string[],
+    defaultFilter: (address: string) => AddressOrTypeEventFilter,
+    addressType: AddressType
+  ) {
+    const filters = []
+    for (const token of contractAddresses) {
+      const filter = defaultFilter(this.config.address)
+      filter.address = token
+      filters.push(filter)
+    }
+    if (!filters.length) {
+      const filter = defaultFilter(this.config.address)
+      filter.address = undefined
+      filter.addressType = addressType
+      filters.push(filter)
+    }
+    return this.onEvent(handler, filters)
+  }
+
+  protected onEvent(
+    handler: (event: Event, ctx: AccountContext) => PromiseOrVoid,
+    filter: AddressOrTypeEventFilter | AddressOrTypeEventFilter[]
+  ) {
+    const chainId = this.getChainId()
+
+    let _filters: AddressOrTypeEventFilter[] = []
+
+    if (Array.isArray(filter)) {
+      _filters = filter
+    } else {
+      _filters.push(filter)
+    }
+
+    let hasVaildConfig = false
+    for (const filter of _filters) {
+      if (filter.address) {
+        hasVaildConfig = true
+        break
+      }
+      if (filter.topics && filter.topics.length) {
+        hasVaildConfig = true
+        break
+      }
+    }
+
+    if (!hasVaildConfig) {
+      throw Error('no valid config has been found for this account')
+    }
+
+    const config = this.config
+
+    this.eventHandlers.push({
+      filters: _filters,
+      handler: async function (log) {
+        const ctx = new AccountContext(chainId, config.address, undefined, log)
+        // let event: Event = <Event>deepCopy(log);
+        const event: Event = <Event>log
+        const parsed = ERC20_CONTRACT.interface.parseLog(log)
+        if (parsed) {
+          event.args = parsed.args
+          event.decode = (data: BytesLike, topics?: Array<any>) => {
+            return ERC20_CONTRACT.interface.decodeEventLog(parsed.eventFragment, data, topics)
+          }
+          event.event = parsed.name
+          event.eventSignature = parsed.signature
+
+          // TODO fix this bug
+          await handler(event, ctx)
+          return ctx.getProcessResult()
+        }
+        return ProcessResult.fromPartial({})
+      },
+    })
+
+    return this
+  }
+}

package/src/core/base-context.ts

@@ -0,0 +1,28 @@
+import { ProcessResult, RecordMetaData } from '../gen'
+import { Logger } from './logger'
+import { Labels } from './metadata'
+import { Meter } from './meter'
+
+export abstract class BaseContext {
+  meter: Meter
+  logger: Logger
+
+  res: ProcessResult = {
+    counters: [],
+    events: [],
+    exports: [],
+    gauges: [],
+    logs: [],
+  }
+
+  protected constructor() {
+    this.meter = new Meter(this)
+    this.logger = new Logger(this)
+  }
+
+  getProcessResult(): ProcessResult {
+    return this.res
+  }
+
+  abstract getMetaData(name: string, labels: Labels): RecordMetaData
+}

package/src/core/base-processor-template.ts

@@ -0,0 +1,150 @@
+import { BoundContractView, ContractContext, ContractView } from './context'
+import { Block } from '@ethersproject/abstract-provider'
+import { BaseContract, EventFilter } from 'ethers'
+import { Event } from '@ethersproject/contracts'
+import { BaseProcessor } from './base-processor'
+import { BindOptions, getOptionsSignature } from './bind-options'
+import { HandleInterval, TemplateInstance } from '../gen'
+import Long from 'long'
+import { getNetwork } from '@ethersproject/providers'
+import { PromiseOrVoid } from '../promise-or-void'
+import { Trace } from './trace'
+import { ListStateStorage } from '../state/state-storage'
+
+export class ProcessorTemplateProcessorState extends ListStateStorage<
+  BaseProcessorTemplate<BaseContract, BoundContractView<BaseContract, any>>
+> {
+  static INSTANCE = new ProcessorTemplateProcessorState()
+}
+
+export class TemplateInstanceState extends ListStateStorage<TemplateInstance> {
+  static INSTANCE = new TemplateInstanceState()
+}
+
+export abstract class BaseProcessorTemplate<
+  TContract extends BaseContract,
+  TBoundContractView extends BoundContractView<TContract, ContractView<TContract>>
+> {
+  id: number
+  binds = new Set<string>()
+  blockHandlers: {
+    handler: (block: Block, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid
+    blockInterval?: HandleInterval
+    timeIntervalInMinutes?: HandleInterval
+  }[] = []
+  traceHandlers: {
+    signature: string
+    handler: (trace: Trace, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid
+  }[] = []
+  eventHandlers: {
+    handler: (event: Event, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid
+    filter: EventFilter | EventFilter[]
+  }[] = []
+
+  constructor() {
+    this.id = ProcessorTemplateProcessorState.INSTANCE.getValues().length
+    ProcessorTemplateProcessorState.INSTANCE.addValue(this)
+  }
+
+  public bind(options: BindOptions) {
+    const sig = getOptionsSignature(options)
+    if (this.binds.has(sig)) {
+      return
+    }
+    this.binds.add(sig)
+
+    const processor = this.bindInternal(options)
+
+    for (const eh of this.eventHandlers) {
+      processor.onEvent(eh.handler, eh.filter)
+    }
+    for (const bh of this.blockHandlers) {
+      processor.onInterval(bh.handler, bh.timeIntervalInMinutes, bh.blockInterval)
+    }
+
+    const instance: TemplateInstance = {
+      templateId: this.id,
+      contract: {
+        address: options.address,
+        name: options.name || '',
+        chainId: options.network ? getNetwork(options.network).chainId.toString() : '1',
+        abi: '',
+      },
+      startBlock: Long.ZERO,
+      endBlock: Long.ZERO,
+    }
+    if (options.startBlock) {
+      if (typeof options.startBlock === 'number') {
+        instance.startBlock = Long.fromNumber(options.startBlock)
+      } else {
+        instance.startBlock = options.startBlock
+      }
+    }
+    if (options.endBlock) {
+      if (typeof options.endBlock === 'number') {
+        instance.endBlock = Long.fromNumber(options.endBlock)
+      } else {
+        instance.endBlock = options.endBlock
+      }
+    }
+    TemplateInstanceState.INSTANCE.addValue(instance)
+    return processor
+  }
+
+  public onEvent(
+    handler: (event: Event, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
+    filter: EventFilter | EventFilter[]
+  ) {
+    this.eventHandlers.push({
+      handler: handler,
+      filter: filter,
+    })
+    return this
+  }
+
+  public onBlock(handler: (block: Block, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid) {
+    return this.onBlockInterval(handler)
+  }
+
+  public onBlockInterval(
+    handler: (block: Block, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
+    blockInterval = 1000,
+    backfillBlockInterval = 4000
+  ) {
+    return this.onInterval(handler, undefined, {
+      recentInterval: blockInterval,
+      backfillInterval: backfillBlockInterval,
+    })
+  }
+
+  public onTimeInterval(
+    handler: (block: Block, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
+    timeIntervalInMinutes = 60,
+    backfillBlockInterval = 240
+  ) {
+    return this.onInterval(
+      handler,
+      { recentInterval: timeIntervalInMinutes, backfillInterval: backfillBlockInterval },
+      undefined
+    )
+  }
+
+  public onInterval(
+    handler: (block: Block, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
+    timeInterval: HandleInterval | undefined,
+    blockInterval: HandleInterval | undefined
+  ) {
+    this.blockHandlers.push({ handler, timeIntervalInMinutes: timeInterval, blockInterval: blockInterval })
+    return this
+  }
+
+  public onTrace(
+    signature: string,
+    handler: (trace: Trace, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid
+  ) {
+    this.traceHandlers.push({ signature, handler })
+    return this
+  }
+
+  protected abstract bindInternal(options: BindOptions): BaseProcessor<TContract, TBoundContractView>
+}