@sentio/runtime 0.0.0-rc.a

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@sentio/runtime",
+  "version": "0.0.0-rc.a",
+  "license": "Apache-2.0",
+  "type": "module",
+  "exports": {
+    ".": "./lib/index.js",
+    "./service-worker": "./lib/service-worker.js"
+  },
+  "bin": {
+    "processor-runner": "./lib/processor-runner.js"
+  },
+  "files": [
+    "{lib,src}",
+    "!**/*.test.{js,ts}",
+    "!{lib,src}/tests"
+  ],
+  "dependencies": {
+    "@grpc/grpc-js": "^1.9.14",
+    "@opentelemetry/exporter-metrics-otlp-grpc": "^0.57.0",
+    "@opentelemetry/exporter-prometheus": "^0.57.0",
+    "@opentelemetry/sdk-node": "^0.57.0",
+    "command-line-args": "^6.0.0",
+    "command-line-usage": "^7.0.1",
+    "ethers": "npm:@sentio/ethers@6.13.1-patch.5",
+    "fs-extra": "^11.2.0",
+    "google-protobuf": "^3.21.2",
+    "ix": "^7.0.0",
+    "long": "^5.2.3",
+    "nice-grpc": "^2.1.10",
+    "nice-grpc-client-middleware-retry": "^3.1.6",
+    "nice-grpc-common": "^2.0.2",
+    "nice-grpc-error-details": "^0.2.4",
+    "nice-grpc-opentelemetry": "^0.1.15",
+    "nice-grpc-prometheus": "^0.2.2",
+    "protobufjs": "^7.2.6",
+    "rxjs": "^7.8.1",
+    "utility-types": "^3.11.0",
+    "winston": "^3.11.0",
+    "@sentio/protos": "0.0.0-rc.a"
+  },
+  "devDependencies": {
+    "@types/command-line-args": "^5.2.3",
+    "@types/command-line-usage": "^5.0.4",
+    "@types/fs-extra": "^11.0.4",
+    "@types/google-protobuf": "^3.15.12",
+    "piscina": "5.0.0-alpha.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "pnpm tsc --noEmit && pnpm bundle",
+    "build:all": "pnpm --filter=$(node -p \"require('./package.json').name\")... build",
+    "bundle": "tsup --config src/tsup.config.ts",
+    "compile": "tsc",
+    "run": "tsx src/processor-runner.ts --log-format=json",
+    "run-benchmark": "tsx src/decode-benchmark.ts",
+    "start_js": "tsx ./lib/processor-runner.js $PWD/../../debug/dist/lib.js",
+    "start_ts": "tsx ./lib/processor-runner.js --log-format=json $PWD/../../debug/src/processor.ts",
+    "test": "glob -c 'tsx --test' '**/*.test.ts'"
+  }
+}

package/src/action-server.ts

@@ -0,0 +1,18 @@
+import { PluginManager } from './plugin.js'
+import { ProcessConfigResponse } from '@sentio/protos'
+
+export class ActionServer {
+  constructor(readonly loader: () => Promise<void>) {}
+
+  async listen(port: number) {
+    const pluginManager = PluginManager.INSTANCE
+    await this.loader()
+    await pluginManager.configure(ProcessConfigResponse.create())
+    console.log('Starting Action Server at:', port)
+    await pluginManager.startServer(port)
+  }
+
+  forceShutdown() {
+    PluginManager.INSTANCE.shutdown()
+  }
+}

package/src/chain-config.ts

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

package/src/db-context.ts

@@ -0,0 +1,227 @@
+import { Subject } from 'rxjs'
+import {
+  DBRequest,
+  DBRequest_DBUpsert,
+  DBResponse,
+  DeepPartial,
+  ProcessResult,
+  ProcessStreamResponse
+} from '@sentio/protos'
+import * as process from 'node:process'
+import { dbMetrics } from './metrics.js'
+const {
+  request_errors,
+  unsolved_requests,
+  request_times,
+  batched_request_count,
+  batched_total_count,
+  send_counts,
+  recv_counts
+} = dbMetrics
+const STORE_BATCH_IDLE = process.env['STORE_BATCH_MAX_IDLE'] ? parseInt(process.env['STORE_BATCH_MAX_IDLE']) : 1
+const STORE_BATCH_SIZE = process.env['STORE_BATCH_SIZE'] ? parseInt(process.env['STORE_BATCH_SIZE']) : 10
+const STORE_UPSERT_NO_WAIT = process.env['STORE_UPSERT_NO_WAIT'] === 'true'
+
+type Request = Omit<DBRequest, 'opId'>
+type RequestType = keyof Request
+
+export const timeoutError = new Error('timeout')
+
+export class StoreContext {
+  private static opCounter = 0n
+  private defers = new Map<
+    bigint,
+    { resolve: (value: any) => void; reject: (reason?: any) => void; requestType?: RequestType }
+  >()
+  private statsInterval: NodeJS.Timeout | undefined
+  private pendings: Promise<unknown>[] = []
+
+  constructor(
+    readonly subject: Subject<DeepPartial<ProcessStreamResponse>>,
+    readonly processId: number
+  ) {}
+
+  newPromise<T>(opId: bigint, requestType?: RequestType) {
+    return new Promise<T>((resolve, reject) => {
+      this.defers.set(opId, { resolve, reject, requestType })
+      unsolved_requests.record(this.defers.size, { processId: this.processId })
+    })
+  }
+
+  sendRequest(request: DeepPartial<Request>, timeoutSecs?: number): Promise<DBResponse> {
+    if (STORE_BATCH_IDLE > 0 && STORE_BATCH_SIZE > 1 && request.upsert) {
+      // batch upsert if possible
+      return this.sendUpsertInBatch(request.upsert as DBRequest_DBUpsert)
+    }
+
+    const requestType = Object.keys(request)[0] as RequestType
+    const opId = StoreContext.opCounter++
+    const promise = this.newPromise(opId, requestType)
+
+    const start = Date.now()
+    const promises = [promise]
+    // console.debug('sending db request ', opId, request)
+    let timer: NodeJS.Timeout | undefined
+    if (timeoutSecs) {
+      const timeoutPromise = new Promise((_r, rej) => (timer = setTimeout(rej, timeoutSecs * 1000, timeoutError)))
+      promises.push(timeoutPromise)
+    }
+
+    this.subject.next({
+      dbRequest: {
+        ...request,
+        opId
+      },
+      processId: this.processId
+    })
+
+    send_counts[requestType]?.add(1)
+
+    if (requestType === 'upsert' && STORE_UPSERT_NO_WAIT) {
+      this.pendings.push(promise)
+      return Promise.resolve({
+        opId,
+      } as DBResponse)
+    }
+
+    return Promise.race(promises)
+      .then((result: DBResponse) => {
+        if (timeoutSecs) {
+          console.debug('db request', requestType, 'op', opId, ' took', Date.now() - start, 'ms')
+        }
+        request_times[requestType]?.add(Date.now() - start)
+        return result
+      })
+      .catch((e) => {
+        if (e === timeoutError) {
+          console.error('db request', requestType, 'op:', opId, ' timeout')
+        }
+        request_errors[requestType]?.add(1)
+        throw e
+      })
+      .finally(() => {
+        if (timer) {
+          clearTimeout(timer)
+        }
+      })
+  }
+
+  result(dbResult: DBResponse) {
+    const opId = dbResult.opId
+    const defer = this.defers.get(opId)
+    // console.debug('received db result ', opId, dbResult)
+    if (defer) {
+      if (defer.requestType) {
+        recv_counts[defer.requestType]?.add(1)
+      }
+      if (dbResult.error) {
+        defer.reject(new Error(dbResult.error))
+      } else {
+        defer.resolve(dbResult)
+      }
+      this.defers.delete(opId)
+    }
+    unsolved_requests.record(this.defers.size, { processId: this.processId })
+  }
+
+  error(processId: number, e: any) {
+    console.error('process error', processId, e)
+    const errorResult = ProcessResult.create({
+      states: {
+        error: e?.toString()
+      }
+    })
+    this.subject.next({
+      result: errorResult,
+      processId
+    })
+  }
+
+  close() {
+    for (const [opId, defer] of this.defers) {
+      // console.warn('context closed before db response', opId)
+      defer.reject(new Error('context closed before db response, processId: ' + this.processId + ' opId: ' + opId))
+    }
+    this.defers.clear()
+    if (this.statsInterval) {
+      clearInterval(this.statsInterval)
+    }
+  }
+
+  upsertBatch:
+    | {
+        opId: bigint
+        request: DBRequest_DBUpsert
+        promise: Promise<DBResponse>
+        timer: NodeJS.Timeout
+      }
+    | undefined = undefined
+
+  private async sendUpsertInBatch(req: DBRequest_DBUpsert): Promise<DBResponse> {
+    if (this.upsertBatch) {
+      // merge the upserts
+      const { request, promise } = this.upsertBatch
+      request.entity = this.upsertBatch.request.entity.concat(req.entity)
+      request.entityData = this.upsertBatch.request.entityData.concat(req.entityData)
+      request.id = this.upsertBatch.request.id.concat(req.id)
+      if (request.entity.length >= STORE_BATCH_SIZE) {
+        this.sendBatch()
+      }
+      if (STORE_UPSERT_NO_WAIT) {
+        return {
+          opId: this.upsertBatch.opId
+        }
+      }
+
+      return promise
+    } else {
+      const opId = StoreContext.opCounter++
+      const timeout = setTimeout(() => {
+        this.sendBatch()
+      }, STORE_BATCH_IDLE)
+      const start = Date.now()
+      const promise = this.newPromise<DBResponse>(opId, 'upsert').finally(() => {
+        request_times['upsert'].add(Date.now() - start)
+      })
+
+      this.upsertBatch = {
+        opId,
+        request: req,
+        promise,
+        timer: timeout,
+      }
+
+      if (STORE_UPSERT_NO_WAIT) {
+        this.pendings.push(promise)
+        return {
+          opId: this.upsertBatch.opId
+        }
+      } else {
+        return promise
+      }
+    }
+  }
+
+  private sendBatch() {
+    if (this.upsertBatch) {
+      const { request, opId, timer } = this.upsertBatch
+      // console.debug('sending batch upsert', opId, 'batch size', request?.entity.length)
+      clearTimeout(timer)
+      this.upsertBatch = undefined
+      this.subject.next({
+        dbRequest: {
+          upsert: request,
+          opId
+        },
+        processId: this.processId
+      })
+      send_counts['upsert']?.add(1)
+      batched_request_count.add(1)
+      batched_total_count.add(request.entity.length)
+    }
+  }
+
+  async awaitPendings() {
+    await Promise.all(this.pendings)
+  }
+}

package/src/decode-benchmark.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+import fs from 'fs'
+
+const fileContent = fs.readFileSync('../../../chain/aptos/testdata/block-0-9999.json', { encoding: 'utf-8' })
+// console.log(fileContent)
+
+const contents: object[] = JSON.parse(fileContent)
+
+console.log(contents.length)
+
+const raws: Uint8Array[] = []
+for (const content of contents) {
+  raws.push(new TextEncoder().encode(JSON.stringify(content)))
+}
+
+console.log('test begin')
+
+const start = Date.now()
+
+for (let i = 0; i < 10; i++) {
+  for (const raw of raws) {
+    const x = JSON.parse(new TextDecoder().decode(raw))
+  }
+}
+
+const end = Date.now()
+console.log((end - start) / 1000.0, 'seconds')

package/src/endpoints.ts

@@ -0,0 +1,11 @@
+export class Endpoints {
+  static INSTANCE: Endpoints = new Endpoints()
+
+  concurrency = 8
+  chainQueryAPI = ''
+  priceFeedAPI = ''
+
+  chainServer = new Map<string, string>()
+
+  batchCount = 1
+}

package/src/full-service.ts

@@ -0,0 +1,339 @@
+import { CallContext } from 'nice-grpc'
+import { createRequire } from 'module'
+// Different than the simple one which
+import {
+  DataBinding,
+  ExecutionConfig,
+  HandlerType,
+  PreprocessStreamRequest,
+  ProcessBindingsRequest,
+  ProcessConfigRequest,
+  ProcessorServiceImplementation,
+  ProcessResult,
+  ProcessStreamRequest,
+  StartRequest
+} from './gen/processor/protos/processor.js'
+
+import { Empty } from '@sentio/protos'
+import fs from 'fs-extra'
+import path from 'path'
+import os from 'os'
+import { GLOBAL_CONFIG } from './global-config.js'
+import { compareSemver, parseSemver, Semver } from './utils.js'
+import { LRUCache } from 'lru-cache'
+
+const require = createRequire(import.meta.url)
+
+const FUEL_PROTO_UPDATE_VERSION = parseSemver('2.54.0-rc.7')
+const FUEL_PROTO_NO_FUEL_TRANSACTION_AS_CALL_VERSION = parseSemver('2.55.0-rc.1')
+
+const MOVE_USE_RAW_VERSION = parseSemver('2.55.0-rc.1')
+const ETH_USE_RAW_VERSION = parseSemver('2.57.9-rc.12')
+// new driver (after MOVE_USE_RAW_VERSION) will sent the same event multiple times when fetch all true
+// so we need to cache it, key will be tx-handler_id
+const PROCESSED_MOVE_EVENT_TX_HANDLER = new LRUCache<string, boolean>({
+  max: 10000
+})
+
+function locatePackageJson(pkgId: string) {
+  const m = require.resolve(pkgId)
+
+  let dir = path.dirname(m)
+  while (!fs.existsSync(path.join(dir, 'package.json'))) {
+    dir = path.dirname(dir)
+  }
+  const content = fs.readFileSync(path.join(dir, 'package.json'), 'utf-8')
+  return JSON.parse(content)
+}
+
+export class FullProcessorServiceImpl implements ProcessorServiceImplementation {
+  constructor(instance: ProcessorServiceImplementation) {
+    this.instance = instance
+    const sdkPackageJson = locatePackageJson('@sentio/sdk')
+    const runtimePackageJson = locatePackageJson('@sentio/runtime')
+
+    console.log('Runtime version:', runtimePackageJson.version, 'SDK version:', sdkPackageJson.version)
+
+    this.sdkVersion = parseSemver(sdkPackageJson.version)
+  }
+
+  instance: ProcessorServiceImplementation
+  sdkVersion: Semver
+
+  async getConfig(request: ProcessConfigRequest, context: CallContext) {
+    const config = await this.instance.getConfig(request, context)
+    config.executionConfig = ExecutionConfig.fromPartial(GLOBAL_CONFIG.execution)
+
+    if (config.contractConfigs) {
+      for (const contract of config.contractConfigs) {
+        // for old fuel processor
+        if (
+          compareSemver(this.sdkVersion, FUEL_PROTO_NO_FUEL_TRANSACTION_AS_CALL_VERSION) < 0 &&
+          contract.fuelCallConfigs
+        ) {
+          contract.fuelTransactionConfigs = contract.fuelCallConfigs
+          contract.fuelCallConfigs = undefined
+        }
+
+        // @ts-ignore convert old fuelLogConfigs to fuelReceiptConfigs
+        if (contract.fuelLogConfigs) {
+          contract.fuelReceiptConfigs = contract.fuelLogConfigs.map((e) => ({
+            handlerId: e.handlerId,
+            handlerName: e.handlerName,
+            log: {
+              logIds: e.logIds
+            }
+          }))
+        }
+
+        // @ts-ignore old fields
+        if (contract.aptosCallConfigs) {
+          // @ts-ignore old fields
+          contract.moveCallConfigs = contract.aptosCallConfigs
+        }
+        // @ts-ignore old fields
+        if (contract.aptosEventConfigs) {
+          // @ts-ignore old fields
+          contract.moveEventConfigs = contract.aptosEventConfigs
+        }
+      }
+    }
+
+    if (compareSemver(this.sdkVersion, MOVE_USE_RAW_VERSION) < 0) {
+      PROCESSED_MOVE_EVENT_TX_HANDLER.clear()
+    }
+
+    return config
+  }
+
+  async start(request: StartRequest, context: CallContext) {
+    return await this.instance.start(request, context)
+  }
+
+  async stop(request: Empty, context: CallContext) {
+    return await this.instance.stop(request, context)
+  }
+
+  async processBindings(request: ProcessBindingsRequest, options: CallContext) {
+    // if (GLOBAL_CONFIG.execution.sequential) {
+    //   request.bindings = request.bindings.sort(dataCompare)
+    // }
+
+    for (const binding of request.bindings) {
+      this.adjustDataBinding(binding)
+    }
+    try {
+      const result = await this.instance.processBindings(request, options)
+      this.adjustResult(result.result as ProcessResult)
+      if (!result.configUpdated && result.result?.states?.configUpdated) {
+        result.configUpdated = result.result?.states?.configUpdated
+      }
+      return result
+    } catch (e) {
+      if (this.sdkVersion.minor <= 16) {
+        // Old sdk doesn't handle this well
+        if (
+          e.code === os.constants.errno.ECONNRESET ||
+          e.code === os.constants.errno.ECONNREFUSED ||
+          e.code === os.constants.errno.ECONNABORTED
+        ) {
+          process.exit(1)
+        }
+      }
+      throw e
+    }
+  }
+
+  async *adjustBindingsStream(requests: AsyncIterable<ProcessStreamRequest>): AsyncIterable<ProcessStreamRequest> {
+    for await (const request of requests) {
+      this.adjustDataBinding(request.binding)
+      yield request
+    }
+  }
+
+  async *processBindingsStream(requests: AsyncIterable<ProcessStreamRequest>, context: CallContext) {
+    yield* this.instance.processBindingsStream(this.adjustBindingsStream(requests), context)
+  }
+
+  async *preprocessBindingsStream(requests: AsyncIterable<PreprocessStreamRequest>, context: CallContext) {
+    yield* this.instance.preprocessBindingsStream(this.adjustBindingsStream(requests), context)
+  }
+
+  private adjustResult(res: ProcessResult): void {}
+
+  private adjustDataBinding(dataBinding?: DataBinding): void {
+    const isBeforeMoveUseRawVersion = compareSemver(this.sdkVersion, MOVE_USE_RAW_VERSION) < 0
+    // const isBeforeEthUseRawVersion = compareSemver(this.sdkVersion,ETH_USE_RAW_VERSION) < 0
+
+    if (!dataBinding) {
+      return
+    }
+    switch (dataBinding.handlerType) {
+      case HandlerType.ETH_LOG:
+        const ethLog = dataBinding.data?.ethLog
+        if (ethLog?.log == null && ethLog?.rawLog) {
+          ethLog.log = JSON.parse(ethLog.rawLog)
+          ethLog.transaction = ethLog.rawTransaction ? JSON.parse(ethLog.rawTransaction) : undefined
+          ethLog.block = ethLog.rawBlock ? JSON.parse(ethLog.rawBlock) : undefined
+          ethLog.transactionReceipt = ethLog.rawTransactionReceipt
+            ? JSON.parse(ethLog.rawTransactionReceipt)
+            : undefined
+        }
+        break
+      case HandlerType.ETH_TRANSACTION:
+        const ethTx = dataBinding.data?.ethTransaction
+        if (ethTx?.transaction == null && ethTx?.rawTransaction) {
+          ethTx.transaction = JSON.parse(ethTx.rawTransaction)
+          ethTx.block = ethTx.rawBlock ? JSON.parse(ethTx.rawBlock) : undefined
+          ethTx.transactionReceipt = ethTx.rawTransactionReceipt ? JSON.parse(ethTx.rawTransactionReceipt) : undefined
+        }
+        break
+      case HandlerType.FUEL_TRANSACTION:
+        if (compareSemver(this.sdkVersion, FUEL_PROTO_UPDATE_VERSION) < 0) {
+          dataBinding.handlerType = HandlerType.FUEL_CALL
+          if (dataBinding.data) {
+            dataBinding.data.fuelCall = dataBinding.data?.fuelTransaction
+          }
+        }
+        break
+      case HandlerType.FUEL_RECEIPT:
+        if (compareSemver(this.sdkVersion, FUEL_PROTO_UPDATE_VERSION) < 0) {
+          dataBinding.handlerType = HandlerType.FUEL_CALL
+          if (dataBinding.data) {
+            dataBinding.data.fuelCall = dataBinding.data?.fuelLog
+          }
+        }
+
+        break
+      case HandlerType.APT_EVENT:
+        const aptEvent = dataBinding.data?.aptEvent
+        if (aptEvent) {
+          if (isBeforeMoveUseRawVersion && aptEvent.rawTransaction) {
+            const transaction = JSON.parse(aptEvent.rawTransaction)
+            const key = `${transaction.hash}-${dataBinding.handlerIds[0]}`
+            if (PROCESSED_MOVE_EVENT_TX_HANDLER.has(key)) {
+              console.debug('skip binding', key)
+              dataBinding.handlerType = HandlerType.UNKNOWN
+              return
+            }
+            PROCESSED_MOVE_EVENT_TX_HANDLER.set(key, true)
+
+            aptEvent.transaction = transaction
+            if (!transaction.events?.length) {
+              // when fetch all is not true, then events is empty, we need to fill it to old format
+              transaction.events = [JSON.parse(aptEvent.rawEvent)]
+            }
+          }
+        }
+        break
+      case HandlerType.APT_CALL:
+        const aptCall = dataBinding.data?.aptCall
+        if (aptCall) {
+          if (isBeforeMoveUseRawVersion && aptCall.rawTransaction) {
+            aptCall.transaction = JSON.parse(aptCall.rawTransaction)
+          }
+        }
+        break
+      case HandlerType.APT_RESOURCE:
+        const aptResource = dataBinding.data?.aptResource
+        if (aptResource) {
+          if (isBeforeMoveUseRawVersion && aptResource.rawResources) {
+            aptResource.resources = aptResource.rawResources.map((e) => JSON.parse(e))
+          }
+        }
+        break
+      case HandlerType.SUI_EVENT:
+        const suiEvent = dataBinding.data?.suiEvent
+        if (suiEvent) {
+          if (isBeforeMoveUseRawVersion && suiEvent.rawTransaction) {
+            const transaction = JSON.parse(suiEvent.rawTransaction)
+            const key = `${transaction.digest}-${dataBinding.handlerIds[0]}`
+            if (PROCESSED_MOVE_EVENT_TX_HANDLER.has(key)) {
+              console.debug('skip binding', key)
+              dataBinding.handlerType = HandlerType.UNKNOWN
+              return
+            }
+            PROCESSED_MOVE_EVENT_TX_HANDLER.set(key, true)
+
+            suiEvent.transaction = transaction
+            if (!transaction.events?.length) {
+              // when fetch all is not true, then events is empty, we need to fill it to old format
+              transaction.events = [JSON.parse(suiEvent.rawEvent)]
+            }
+          }
+        }
+        break
+      case HandlerType.SUI_CALL:
+        const suiCall = dataBinding.data?.suiCall
+        if (suiCall) {
+          if (isBeforeMoveUseRawVersion && suiCall.rawTransaction) {
+            suiCall.transaction = JSON.parse(suiCall.rawTransaction)
+          }
+        }
+        break
+      case HandlerType.SUI_OBJECT:
+        const suiObject = dataBinding.data?.suiObject
+        if (suiObject) {
+          if (isBeforeMoveUseRawVersion && (suiObject.rawSelf || suiObject.rawObjects)) {
+            if (suiObject.rawSelf) {
+              suiObject.self = JSON.parse(suiObject.rawSelf)
+            }
+            suiObject.objects = suiObject.rawObjects.map((e) => JSON.parse(e))
+          }
+        }
+        break
+      case HandlerType.SUI_OBJECT_CHANGE:
+        const suiObjectChange = dataBinding.data?.suiObjectChange
+        if (suiObjectChange) {
+          if (isBeforeMoveUseRawVersion && suiObjectChange.rawChanges) {
+            suiObjectChange.changes = suiObjectChange.rawChanges.map((e) => JSON.parse(e))
+          }
+        }
+        break
+      case HandlerType.UNKNOWN:
+        // if (dataBinding.data?.ethBlock) {
+        //   if (dataBinding.data.raw.length === 0) {
+        //     // This is actually not needed in current system, just as initla test propose, move to test only
+        //     // when this is stable
+        //     dataBinding.data.raw = new TextEncoder().encode(JSON.stringify(dataBinding.data.ethBlock.block))
+        //   }
+        // }
+        break
+      default:
+        break
+    }
+  }
+}
+
+// function dataCompare(a: DataBinding, b: DataBinding): number {
+//   const timeA = getTimestamp(a) || new Date(0)
+//   const timeB = getTimestamp(b) || new Date(0)
+//   const timeCmp = timeA.getTime() - timeB.getTime()
+//   if (timeCmp !== 0) {
+//     return timeCmp
+//   }
+//   return getSecondary(a) - getSecondary(b)
+// }
+//
+// function getTimestamp(d: DataBinding): Date | undefined {
+//   return (
+//     d.data?.ethLog?.timestamp ||
+//     d.data?.ethTransaction?.timestamp ||
+//     (d.data?.ethBlock?.block?.timestamp ? new Date(Number(d.data.ethBlock.block.timestamp) * 1000) : undefined) ||
+//     d.data?.ethTrace?.timestamp ||
+//     (d.data?.aptCall?.transaction ? new Date(Number(d.data.aptCall.transaction.timestamp) / 1000) : undefined) ||
+//     (d.data?.aptEvent?.transaction ? new Date(Number(d.data.aptEvent.transaction.timestamp) / 1000) : undefined) ||
+//     (d.data?.aptResource?.timestampMicros ? new Date(Number(d.data.aptResource.timestampMicros) / 1000) : undefined) ||
+//     d.data?.fuelCall?.timestamp
+//   )
+// }
+//
+// function getSecondary(d: DataBinding) {
+//   return (
+//     d.data?.ethLog?.log?.logIndex ||
+//     d.data?.ethTransaction?.transaction?.transactionIndex ||
+//     d.data?.ethBlock?.block?.number ||
+//     d.data?.ethTrace?.trace?.transactionPosition
+//   )
+// }
+//