@sentio/runtime 4.0.0-rc.1 → 4.0.0-rc.2

package/src/full-service.ts

@@ -1,416 +1,69 @@
-import { CallContext } from 'nice-grpc'
-// Different than the simple one which
+import { create } from '@bufbuild/protobuf'
+import { type HandlerContext, type ServiceImpl } from '@connectrpc/connect'
 import {
-  DataBinding,
-  ExecutionConfig,
-  HandlerType,
-  PreprocessStreamRequest,
-  ProcessBindingsRequest,
-  ProcessConfigRequest,
-  ProcessConfigResponse,
-  ProcessorServiceImplementation,
-  ProcessResult,
-  ProcessStreamRequest,
-  StartRequest
-} from './gen/processor/protos/processor.js'
-
-import { DeepPartial, Empty, ProcessorV3ServiceImplementation, UpdateTemplatesRequest } from '@sentio/protos'
-import os from 'os'
+  type Empty,
+  ExecutionConfigSchema,
+  type PreprocessStreamRequest,
+  type ProcessBindingsRequest,
+  type ProcessConfigRequest,
+  Processor,
+  ProcessorV3,
+  type ProcessStreamRequest,
+  type StartRequest,
+  type UpdateTemplatesRequest
+} from '@sentio/protos'
+import { ProcessorServiceImpl } from './service.js'
+import { ProcessorServiceImplV3 } from './service-v3.js'
 import { GLOBAL_CONFIG } from './global-config.js'
-import { compareSemver, locatePackageJson, parseSemver, Semver } from './utils.js'
-import { LRUCache } from 'lru-cache'
-import { createHash } from 'crypto'
-
-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
-})
-
-const enableTxCache = process.env.ENABLE_PARSE_CACHE === 'true'
-
-// Cache for parsed JSON data
-const PARSED_DATA_CACHE = new LRUCache<string, any>({
-  max: enableTxCache ? 5000 : 1
-})
-
-/**
- * Gets parsed JSON data from a string, using a cache to avoid repeated parsing
- * @param rawData The raw string data to parse
- * @returns The parsed JSON object
- */
-function getParsedData(rawData: string): any {
-  if (!enableTxCache) {
-    return JSON.parse(rawData)
-  }
-
-  // Create a digest of the raw data for cache key
-  const digest = createHash('md5').update(rawData).digest('hex')
-
-  // Check if we already have this data parsed
-  let parsedData = PARSED_DATA_CACHE.get(digest)
-  if (!parsedData) {
-    // Parse and cache the data
-    parsedData = JSON.parse(rawData)
-    PARSED_DATA_CACHE.set(digest, parsedData)
-  }
-
-  return parsedData
-}
-
-/**
- * The RuntimeServicePatcher class is responsible for providing backward compatibility
- * patches for different SDK versions. It ensures that the runtime can adapt to changes
- * in the SDK by applying necessary adjustments to data bindings and other configurations.
- */
-export class RuntimeServicePatcher {
-  sdkVersion: Semver
-
-  constructor() {
-    const sdkPackageJson = locatePackageJson('@sentio/sdk')
-    this.sdkVersion = parseSemver(sdkPackageJson.version)
-  }
-
-  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)
-
-          if (ethLog.rawTransaction) {
-            ethLog.transaction = getParsedData(ethLog.rawTransaction)
-          }
-          if (ethLog.rawBlock) {
-            ethLog.block = getParsedData(ethLog.rawBlock)
-          }
-          if (ethLog.rawTransactionReceipt) {
-            ethLog.transactionReceipt = getParsedData(ethLog.rawTransactionReceipt)
-          }
-        }
-        break
-      case HandlerType.ETH_TRANSACTION:
-        const ethTx = dataBinding.data?.ethTransaction
-        if (ethTx?.transaction == null && ethTx?.rawTransaction) {
-          ethTx.transaction = getParsedData(ethTx.rawTransaction)
-          if (ethTx.rawBlock) {
-            ethTx.block = getParsedData(ethTx.rawBlock)
-          } else {
-            ethTx.block = undefined
-          }
-          if (ethTx.rawTransactionReceipt) {
-            ethTx.transactionReceipt = getParsedData(ethTx.rawTransactionReceipt)
-          } else {
-            ethTx.transactionReceipt = 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 = getParsedData(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 = getParsedData(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 = getParsedData(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)
+export class FullProcessorServiceImpl implements ServiceImpl<typeof Processor> {
+  constructor(readonly instance: ProcessorServiceImpl) {}
 
-            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 = getParsedData(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
-    }
-  }
-
-  patchConfig(config: DeepPartial<ProcessConfigResponse>): void {
-    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
-        }
-      }
-    }
-  }
-}
-
-export class FullProcessorServiceImpl implements ProcessorServiceImplementation {
-  constructor(instance: ProcessorServiceImplementation) {
-    this.instance = instance
-    const sdkPackageJson = locatePackageJson('@sentio/sdk')
-    this.sdkVersion = parseSemver(sdkPackageJson.version)
-  }
-
-  instance: ProcessorServiceImplementation
-  sdkVersion: Semver
-  patcher: RuntimeServicePatcher = new RuntimeServicePatcher()
-
-  async getConfig(request: ProcessConfigRequest, context: CallContext) {
+  async getConfig(request: ProcessConfigRequest, context: HandlerContext) {
     const config = await this.instance.getConfig(request, context)
-    this.patcher.patchConfig(config)
-
-    if (compareSemver(this.sdkVersion, MOVE_USE_RAW_VERSION) < 0) {
-      PROCESSED_MOVE_EVENT_TX_HANDLER.clear()
-    }
-
+    config.executionConfig = create(ExecutionConfigSchema, GLOBAL_CONFIG.execution)
     return config
   }
 
-  async start(request: StartRequest, context: CallContext) {
+  async start(request: StartRequest, context: HandlerContext) {
     return await this.instance.start(request, context)
   }
 
-  async stop(request: Empty, context: CallContext) {
+  async stop(request: Empty, context: HandlerContext) {
     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.patcher.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: any) {
-      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.patcher.adjustDataBinding(request.binding)
-      yield request
-    }
+  async processBindings(request: ProcessBindingsRequest, context: HandlerContext) {
+    return await this.instance.processBindings(request, context)
   }
 
-  async *processBindingsStream(requests: AsyncIterable<ProcessStreamRequest>, context: CallContext) {
-    yield* this.instance.processBindingsStream(this.adjustBindingsStream(requests), context)
+  async *processBindingsStream(requests: AsyncIterable<ProcessStreamRequest>, context: HandlerContext) {
+    yield* this.instance.processBindingsStream(requests, context)
   }
 
-  async *preprocessBindingsStream(requests: AsyncIterable<PreprocessStreamRequest>, context: CallContext) {
-    yield* this.instance.preprocessBindingsStream(this.adjustBindingsStream(requests), context)
+  async *preprocessBindingsStream(requests: AsyncIterable<PreprocessStreamRequest>, context: HandlerContext) {
+    yield* this.instance.preprocessBindingsStream(requests, context)
   }
-
-  private adjustResult(res: ProcessResult): void {}
 }
 
-// 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
-//   )
-// }
-
-export class FullProcessorServiceV3Impl implements ProcessorV3ServiceImplementation {
-  patcher: RuntimeServicePatcher = new RuntimeServicePatcher()
-
-  constructor(readonly instance: ProcessorV3ServiceImplementation) {}
+export class FullProcessorServiceV3Impl implements ServiceImpl<typeof ProcessorV3> {
+  constructor(readonly instance: ProcessorServiceImplV3) {}
 
-  async start(request: StartRequest, context: CallContext): Promise<DeepPartial<Empty>> {
+  async start(request: StartRequest, context: HandlerContext) {
     return this.instance.start(request, context)
   }
 
-  async getConfig(request: ProcessConfigRequest, context: CallContext): Promise<DeepPartial<ProcessConfigResponse>> {
+  async getConfig(request: ProcessConfigRequest, context: HandlerContext) {
     const config = await this.instance.getConfig(request, context)
-    this.patcher.patchConfig(config)
+    config.executionConfig = create(ExecutionConfigSchema, GLOBAL_CONFIG.execution)
     return config
   }
 
-  async *processBindingsStream(requests: AsyncIterable<ProcessStreamRequest>, context: CallContext) {
-    yield* this.instance.processBindingsStream(this.adjustBindingsStream(requests), context)
-  }
-
-  async *adjustBindingsStream(requests: AsyncIterable<ProcessStreamRequest>): AsyncIterable<ProcessStreamRequest> {
-    for await (const request of requests) {
-      this.patcher.adjustDataBinding(request.binding)
-      yield request
-    }
+  async *processBindingsStream(requests: AsyncIterable<ProcessStreamRequest>, context: HandlerContext) {
+    yield* this.instance.processBindingsStream(requests, context)
   }
 
-  async updateTemplates(request: UpdateTemplatesRequest, context: CallContext): Promise<DeepPartial<Empty>> {
+  async updateTemplates(request: UpdateTemplatesRequest, context: HandlerContext) {
     return this.instance.updateTemplates(request, context)
   }
 }

package/src/gen/google/type/money_pb.ts

@@ -0,0 +1,41 @@
+// @generated by protoc-gen-es v2.12.0 with parameter "target=ts,import_extension=js,keep_empty_files=true"
+// @generated from file google/type/money.proto (package google.type, syntax proto3)
+/* eslint-disable */
+
+import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2";
+import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv2";
+import type { Message } from "@bufbuild/protobuf";
+
+/**
+ * Describes the file google/type/money.proto.
+ */
+export const file_google_type_money: GenFile = /*@__PURE__*/
+  fileDesc("Chdnb29nbGUvdHlwZS9tb25leS5wcm90bxILZ29vZ2xlLnR5cGUiPAoFTW9uZXkSFQoNY3VycmVuY3lfY29kZRgBIAEoCRINCgV1bml0cxgCIAEoAxINCgVuYW5vcxgDIAEoBUJdCg9jb20uZ29vZ2xlLnR5cGVCCk1vbmV5UHJvdG9QAVo2Z29vZ2xlLmdvbGFuZy5vcmcvZ2VucHJvdG8vZ29vZ2xlYXBpcy90eXBlL21vbmV5O21vbmV5ogIDR1RQYgZwcm90bzM");
+
+/**
+ * @generated from message google.type.Money
+ */
+export type Money = Message<"google.type.Money"> & {
+  /**
+   * @generated from field: string currency_code = 1;
+   */
+  currencyCode: string;
+
+  /**
+   * @generated from field: int64 units = 2;
+   */
+  units: bigint;
+
+  /**
+   * @generated from field: int32 nanos = 3;
+   */
+  nanos: number;
+};
+
+/**
+ * Describes the message google.type.Money.
+ * Use `create(MoneySchema)` to create a new message.
+ */
+export const MoneySchema: GenMessage<Money> = /*@__PURE__*/
+  messageDesc(file_google_type_money, 0);
+