@sentio/sdk 1.33.2 → 1.34.1-rc.1

package/src/gen/service/price/protos/price.ts

@@ -1,12 +1,12 @@
 /* eslint-disable */
-import { CallContext, CallOptions } from "nice-grpc-common";
-import { Timestamp } from "../../../google/protobuf/timestamp";
 import Long from "long";
+import type { CallContext, CallOptions } from "nice-grpc-common";
 import _m0 from "protobufjs/minimal";
+import { Timestamp } from "../../../google/protobuf/timestamp";
 
 export interface CoinID {
-  symbol: string | undefined;
-  address: CoinID_AddressIdentifier | undefined;
+  symbol?: string | undefined;
+  address?: CoinID_AddressIdentifier | undefined;
 }
 
 export interface CoinID_AddressIdentifier {
@@ -29,18 +29,12 @@ function createBaseCoinID(): CoinID {
 }
 
 export const CoinID = {
-  encode(
-    message: CoinID,
-    writer: _m0.Writer = _m0.Writer.create()
-  ): _m0.Writer {
+  encode(message: CoinID, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.symbol !== undefined) {
       writer.uint32(18).string(message.symbol);
     }
     if (message.address !== undefined) {
-      CoinID_AddressIdentifier.encode(
-        message.address,
-        writer.uint32(26).fork()
-      ).ldelim();
+      CoinID_AddressIdentifier.encode(message.address, writer.uint32(26).fork()).ldelim();
     }
     return writer;
   },
@@ -56,10 +50,7 @@ export const CoinID = {
           message.symbol = reader.string();
           break;
         case 3:
-          message.address = CoinID_AddressIdentifier.decode(
-            reader,
-            reader.uint32()
-          );
+          message.address = CoinID_AddressIdentifier.decode(reader, reader.uint32());
           break;
         default:
           reader.skipType(tag & 7);
@@ -72,9 +63,7 @@ export const CoinID = {
   fromJSON(object: any): CoinID {
     return {
       symbol: isSet(object.symbol) ? String(object.symbol) : undefined,
-      address: isSet(object.address)
-        ? CoinID_AddressIdentifier.fromJSON(object.address)
-        : undefined,
+      address: isSet(object.address) ? CoinID_AddressIdentifier.fromJSON(object.address) : undefined,
     };
   },
 
@@ -82,19 +71,16 @@ export const CoinID = {
     const obj: any = {};
     message.symbol !== undefined && (obj.symbol = message.symbol);
     message.address !== undefined &&
-      (obj.address = message.address
-        ? CoinID_AddressIdentifier.toJSON(message.address)
-        : undefined);
+      (obj.address = message.address ? CoinID_AddressIdentifier.toJSON(message.address) : undefined);
     return obj;
   },
 
   fromPartial(object: DeepPartial<CoinID>): CoinID {
     const message = createBaseCoinID();
     message.symbol = object.symbol ?? undefined;
-    message.address =
-      object.address !== undefined && object.address !== null
-        ? CoinID_AddressIdentifier.fromPartial(object.address)
-        : undefined;
+    message.address = (object.address !== undefined && object.address !== null)
+      ? CoinID_AddressIdentifier.fromPartial(object.address)
+      : undefined;
     return message;
   },
 };
@@ -104,10 +90,7 @@ function createBaseCoinID_AddressIdentifier(): CoinID_AddressIdentifier {
 }
 
 export const CoinID_AddressIdentifier = {
-  encode(
-    message: CoinID_AddressIdentifier,
-    writer: _m0.Writer = _m0.Writer.create()
-  ): _m0.Writer {
+  encode(message: CoinID_AddressIdentifier, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.address !== "") {
       writer.uint32(10).string(message.address);
     }
@@ -117,10 +100,7 @@ export const CoinID_AddressIdentifier = {
     return writer;
   },
 
-  decode(
-    input: _m0.Reader | Uint8Array,
-    length?: number
-  ): CoinID_AddressIdentifier {
+  decode(input: _m0.Reader | Uint8Array, length?: number): CoinID_AddressIdentifier {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseCoinID_AddressIdentifier();
@@ -155,9 +135,7 @@ export const CoinID_AddressIdentifier = {
     return obj;
   },
 
-  fromPartial(
-    object: DeepPartial<CoinID_AddressIdentifier>
-  ): CoinID_AddressIdentifier {
+  fromPartial(object: DeepPartial<CoinID_AddressIdentifier>): CoinID_AddressIdentifier {
     const message = createBaseCoinID_AddressIdentifier();
     message.address = object.address ?? "";
     message.chain = object.chain ?? "";
@@ -170,15 +148,9 @@ function createBaseGetPriceRequest(): GetPriceRequest {
 }
 
 export const GetPriceRequest = {
-  encode(
-    message: GetPriceRequest,
-    writer: _m0.Writer = _m0.Writer.create()
-  ): _m0.Writer {
+  encode(message: GetPriceRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.timestamp !== undefined) {
-      Timestamp.encode(
-        toTimestamp(message.timestamp),
-        writer.uint32(10).fork()
-      ).ldelim();
+      Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(10).fork()).ldelim();
     }
     if (message.coinId !== undefined) {
       CoinID.encode(message.coinId, writer.uint32(18).fork()).ldelim();
@@ -194,9 +166,7 @@ export const GetPriceRequest = {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.timestamp = fromTimestamp(
-            Timestamp.decode(reader, reader.uint32())
-          );
+          message.timestamp = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
           break;
         case 2:
           message.coinId = CoinID.decode(reader, reader.uint32());
@@ -211,29 +181,24 @@ export const GetPriceRequest = {
 
   fromJSON(object: any): GetPriceRequest {
     return {
-      timestamp: isSet(object.timestamp)
-        ? fromJsonTimestamp(object.timestamp)
-        : undefined,
+      timestamp: isSet(object.timestamp) ? fromJsonTimestamp(object.timestamp) : undefined,
       coinId: isSet(object.coinId) ? CoinID.fromJSON(object.coinId) : undefined,
     };
   },
 
   toJSON(message: GetPriceRequest): unknown {
     const obj: any = {};
-    message.timestamp !== undefined &&
-      (obj.timestamp = message.timestamp.toISOString());
-    message.coinId !== undefined &&
-      (obj.coinId = message.coinId ? CoinID.toJSON(message.coinId) : undefined);
+    message.timestamp !== undefined && (obj.timestamp = message.timestamp.toISOString());
+    message.coinId !== undefined && (obj.coinId = message.coinId ? CoinID.toJSON(message.coinId) : undefined);
     return obj;
   },
 
   fromPartial(object: DeepPartial<GetPriceRequest>): GetPriceRequest {
     const message = createBaseGetPriceRequest();
     message.timestamp = object.timestamp ?? undefined;
-    message.coinId =
-      object.coinId !== undefined && object.coinId !== null
-        ? CoinID.fromPartial(object.coinId)
-        : undefined;
+    message.coinId = (object.coinId !== undefined && object.coinId !== null)
+      ? CoinID.fromPartial(object.coinId)
+      : undefined;
     return message;
   },
 };
@@ -243,18 +208,12 @@ function createBaseGetPriceResponse(): GetPriceResponse {
 }
 
 export const GetPriceResponse = {
-  encode(
-    message: GetPriceResponse,
-    writer: _m0.Writer = _m0.Writer.create()
-  ): _m0.Writer {
+  encode(message: GetPriceResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.price !== 0) {
       writer.uint32(9).double(message.price);
     }
     if (message.timestamp !== undefined) {
-      Timestamp.encode(
-        toTimestamp(message.timestamp),
-        writer.uint32(18).fork()
-      ).ldelim();
+      Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(18).fork()).ldelim();
     }
     return writer;
   },
@@ -270,9 +229,7 @@ export const GetPriceResponse = {
           message.price = reader.double();
           break;
         case 2:
-          message.timestamp = fromTimestamp(
-            Timestamp.decode(reader, reader.uint32())
-          );
+          message.timestamp = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
           break;
         default:
           reader.skipType(tag & 7);
@@ -285,17 +242,14 @@ export const GetPriceResponse = {
   fromJSON(object: any): GetPriceResponse {
     return {
       price: isSet(object.price) ? Number(object.price) : 0,
-      timestamp: isSet(object.timestamp)
-        ? fromJsonTimestamp(object.timestamp)
-        : undefined,
+      timestamp: isSet(object.timestamp) ? fromJsonTimestamp(object.timestamp) : undefined,
     };
   },
 
   toJSON(message: GetPriceResponse): unknown {
     const obj: any = {};
     message.price !== undefined && (obj.price = message.price);
-    message.timestamp !== undefined &&
-      (obj.timestamp = message.timestamp.toISOString());
+    message.timestamp !== undefined && (obj.timestamp = message.timestamp.toISOString());
     return obj;
   },
 
@@ -323,39 +277,20 @@ export const PriceServiceDefinition = {
   },
 } as const;
 
-export interface PriceServiceServiceImplementation<CallContextExt = {}> {
-  getPrice(
-    request: GetPriceRequest,
-    context: CallContext & CallContextExt
-  ): Promise<DeepPartial<GetPriceResponse>>;
+export interface PriceServiceImplementation<CallContextExt = {}> {
+  getPrice(request: GetPriceRequest, context: CallContext & CallContextExt): Promise<DeepPartial<GetPriceResponse>>;
 }
 
 export interface PriceServiceClient<CallOptionsExt = {}> {
-  getPrice(
-    request: DeepPartial<GetPriceRequest>,
-    options?: CallOptions & CallOptionsExt
-  ): Promise<GetPriceResponse>;
+  getPrice(request: DeepPartial<GetPriceRequest>, options?: CallOptions & CallOptionsExt): Promise<GetPriceResponse>;
 }
 
-type Builtin =
-  | Date
-  | Function
-  | Uint8Array
-  | string
-  | number
-  | boolean
-  | undefined;
-
-type DeepPartial<T> = T extends Builtin
-  ? T
-  : T extends Long
-  ? string | number | Long
-  : T extends Array<infer U>
-  ? Array<DeepPartial<U>>
-  : T extends ReadonlyArray<infer U>
-  ? ReadonlyArray<DeepPartial<U>>
-  : T extends {}
-  ? { [K in keyof T]?: DeepPartial<T[K]> }
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+type DeepPartial<T> = T extends Builtin ? T
+  : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
   : Partial<T>;
 
 function toTimestamp(date: Date): Timestamp {

package/src/service.ts

@@ -6,25 +6,23 @@ import {
   AccountConfig,
   AptosCallHandlerConfig,
   AptosEventHandlerConfig,
-  BlockBinding,
   ContractConfig,
+  Data,
+  Data_SolInstruction,
   DataBinding,
   EventTrackingConfig,
   ExportConfig,
   HandlerType,
-  Instruction,
   LogFilter,
   LogHandlerConfig,
   MetricConfig,
   ProcessBindingResponse,
   ProcessBindingsRequest,
-  ProcessBlocksRequest,
   ProcessConfigRequest,
   ProcessConfigResponse,
-  ProcessInstructionsRequest,
   ProcessorServiceImplementation,
   ProcessResult,
-  ProcessTransactionsRequest,
+  ServerStreamingMethodResult,
   StartRequest,
   TemplateInstance,
 } from './gen'
@@ -154,7 +152,6 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
           address: processor.config.address,
           abi: '',
         },
-        blockConfigs: [],
         intervalConfigs: [],
         logConfigs: [],
         traceConfigs: [],
@@ -284,7 +281,6 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
           address: solanaProcessor.address,
           abi: '',
         },
-        blockConfigs: [],
         logConfigs: [],
         traceConfigs: [],
         intervalConfigs: [],
@@ -311,7 +307,6 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
           address: suiProcessor.address,
           abi: '',
         },
-        blockConfigs: [],
         logConfigs: [],
         intervalConfigs: [],
         traceConfigs: [],
@@ -334,7 +329,6 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
           address: aptosProcessor.config.address,
           abi: '',
         },
-        blockConfigs: [],
         intervalConfigs: [],
         logConfigs: [],
         traceConfigs: [],
@@ -472,10 +466,6 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
   }
 
   async processBinding(request: DataBinding, options?: CallContext): Promise<ProcessResult> {
-    if (request.handlerIds.length == 0) {
-      request.handlerIds = [request.handlerId]
-    }
-
     const processBindingInternal = (request: DataBinding) => {
       switch (request.handlerType) {
         case HandlerType.APT_CALL:
@@ -489,10 +479,10 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
         case HandlerType.ETH_TRACE:
           return this.processTrace(request)
         case HandlerType.ETH_BLOCK:
-          return this.processBlockNew(request)
-        case HandlerType.SOL_INSTRUCTIONS:
-          return this.processInstructionsNew(request)
-        // TODO migrate SOLANA SUI cases
+          return this.processBlock(request)
+        case HandlerType.SOL_INSTRUCTION:
+          return this.procecessSolInstructions(request)
+        // TODO migrate SUI cases
         // case HandlerType.INSTRUCTION:
         //   return this.processInstruction(request)
         default:
@@ -505,6 +495,24 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     return result
   }
 
+  async *processBindingsStream(requests: AsyncIterable<DataBinding>, context: CallContext) {
+    for await (const request of requests) {
+      const result = await this.processBinding(request)
+      let updated = false
+      if (
+        global.PROCESSOR_STATE.templatesInstances &&
+        this.templateInstances.length != global.PROCESSOR_STATE.templatesInstances.length
+      ) {
+        await this.configure()
+        updated = true
+      }
+      yield {
+        result,
+        configUpdated: updated,
+      }
+    }
+  }
+
   async processLogs(request: ProcessBindingsRequest, context: CallContext): Promise<ProcessBindingResponse> {
     if (!this.started) {
       throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')
@@ -533,19 +541,16 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     }
   }
 
-  async processLog(l: DataBinding): Promise<ProcessResult> {
-    if (!l.data) {
+  async processLog(request: DataBinding): Promise<ProcessResult> {
+    if (!request.data) {
       throw new ServerError(Status.INVALID_ARGUMENT, "Log can't be null")
     }
-    if (l.handlerIds.length == 0) {
-      l.handlerIds = [l.handlerId]
-    }
 
     const promises: Promise<ProcessResult>[] = []
-    const jsonString = Utf8ArrayToStr(l.data.raw)
+    const jsonString = Utf8ArrayToStr(request.data.ethLog?.data || request.data.raw)
     const log: Log = JSON.parse(jsonString)
 
-    for (const handlerId of l.handlerIds) {
+    for (const handlerId of request.handlerIds) {
       const handler = this.eventHandlers[handlerId]
       promises.push(
         handler(log).catch((e) => {
@@ -556,203 +561,50 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     return mergeProcessResults(await Promise.all(promises))
   }
 
-  async processTransactions(
-    request: ProcessTransactionsRequest,
-    context: CallContext
-  ): Promise<ProcessBindingResponse> {
-    if (!this.started) {
-      throw new ServerError(Status.UNAVAILABLE, 'Service not started.')
-    }
-
-    const result = ProcessResult.fromPartial({})
-
-    if (request.chainId.toLowerCase().startsWith('sui') && SuiProcessorState.INSTANCE.getValues()) {
-      const processorPromises: Promise<void>[] = []
-      for (const txn of request.transactions) {
-        processorPromises.push(
-          new Promise((resolve, _) => {
-            for (const processor of SuiProcessorState.INSTANCE.getValues()) {
-              const res = processor.handleTransaction(
-                JSON.parse(new TextDecoder().decode(txn.raw)),
-                txn.slot ?? Long.fromNumber(0)
-              )
-              if (res) {
-                res.gauges.forEach((g) => result.gauges.push(g))
-                res.counters.forEach((c) => result.counters.push(c))
-                res.logs.forEach((l) => result.logs.push(l))
-              }
-            }
-            resolve()
-          })
-        )
-      }
-      await Promise.all(processorPromises)
-    }
-
-    recordRuntimeInfo(result, HandlerType.SUI_TRANSACTION)
-    return {
-      result,
-      configUpdated: false,
-    }
-  }
-
-  async processInstructions(
-    request: ProcessInstructionsRequest,
-    context: CallContext
-  ): Promise<ProcessBindingResponse> {
-    if (!this.started) {
-      throw new ServerError(Status.UNAVAILABLE, 'Service not started.')
-    }
-
-    const result = ProcessResult.fromPartial({})
-
-    // Only have instruction handlers for solana processors
-    if (SolanaProcessorState.INSTANCE.getValues()) {
-      const processorPromises: Promise<void>[] = []
-      for (const instruction of request.instructions) {
-        if (!instruction) {
-          throw new ServerError(Status.INVALID_ARGUMENT, 'instruction cannot be null')
-        }
-
-        processorPromises.push(
-          new Promise((resolve, _) => {
-            for (const processor of SolanaProcessorState.INSTANCE.getValues()) {
-              if (processor.address === instruction.programAccountId) {
-                let parsedInstruction: SolInstruction | null = null
-                if (instruction.parsed) {
-                  parsedInstruction = processor.getParsedInstruction(
-                    JSON.parse(new TextDecoder().decode(instruction.parsed))
-                  )
-                } else if (instruction.instructionData) {
-                  parsedInstruction = processor.getParsedInstruction(instruction.instructionData)
-                }
-                if (parsedInstruction == null) {
-                  continue
-                }
-                const insHandler = processor.getInstructionHandler(parsedInstruction)
-                if (insHandler == null) {
-                  continue
-                }
-                const res = processor.handleInstruction(
-                  parsedInstruction,
-                  instruction.accounts,
-                  insHandler,
-                  instruction.slot
-                )
-                res.gauges.forEach((g) => result.gauges.push(g))
-                res.counters.forEach((c) => result.counters.push(c))
-                res.logs.forEach((l) => result.logs.push(l))
-              }
-            }
-            resolve()
-          })
-        )
-      }
-
-      await Promise.all(processorPromises)
-    }
-
-    recordRuntimeInfo(result, HandlerType.SOL_INSTRUCTIONS)
-    return {
-      result,
-      configUpdated: false,
-    }
-  }
-
-  async processInstructionsNew(request: DataBinding): Promise<ProcessResult> {
-    if (!this.started) {
-      throw new ServerError(Status.UNAVAILABLE, 'Service not started.')
-    }
+  async procecessSolInstructions(request: DataBinding): Promise<ProcessResult> {
     if (!request.data) {
       throw new ServerError(Status.INVALID_ARGUMENT, 'instruction data cannot be empty')
     }
 
-    const jsonString = Utf8ArrayToStr(request.data.raw)
-    const instructions: Instruction[] = JSON.parse(jsonString)
+    const instruction = request.data.solInstruction || Data_SolInstruction.decode(request.data.raw) // JSON.parse(jsonString)
     const promises: Promise<ProcessResult>[] = []
 
     // Only have instruction handlers for solana processors
-    if (SolanaProcessorState.INSTANCE.getValues()) {
-      for (const instruction of instructions) {
-        if (!instruction) {
-          throw new ServerError(Status.INVALID_ARGUMENT, 'instruction cannot be null')
+    for (const processor of SolanaProcessorState.INSTANCE.getValues()) {
+      if (processor.address === instruction.programAccountId) {
+        let parsedInstruction: SolInstruction | null = null
+        if (instruction.parsed) {
+          const a1 = JSON.parse(new TextDecoder().decode(instruction.parsed))
+          parsedInstruction = processor.getParsedInstruction(a1)
+        } else if (instruction.instructionData) {
+          parsedInstruction = processor.getParsedInstruction(instruction.instructionData)
         }
-
-        for (const processor of SolanaProcessorState.INSTANCE.getValues()) {
-          if (processor.address === instruction.programAccountId) {
-            let parsedInstruction: SolInstruction | null = null
-            if (instruction.parsed) {
-              parsedInstruction = processor.getParsedInstruction(
-                JSON.parse(new TextDecoder().decode(instruction.parsed))
-              )
-            } else if (instruction.instructionData) {
-              parsedInstruction = processor.getParsedInstruction(instruction.instructionData)
-            }
-            if (parsedInstruction == null) {
-              continue
-            }
-            const insHandler = processor.getInstructionHandler(parsedInstruction)
-            if (insHandler == null) {
-              continue
-            }
-            const res = await processor.handleInstruction(
-              parsedInstruction,
-              instruction.accounts,
-              insHandler,
-              instruction.slot
-            )
-
-            promises.push(Promise.resolve(res))
-          }
+        if (parsedInstruction == null) {
+          continue
         }
-      }
-    }
-    return mergeProcessResults(await Promise.all(promises))
-  }
-
-  async processBlocks(request: ProcessBlocksRequest, context: CallContext): Promise<ProcessBindingResponse> {
-    if (!this.started) {
-      throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')
-    }
-
-    const promises = request.blockBindings.map((binding) => this.processBlock(binding))
-    const result = mergeProcessResults(await Promise.all(promises))
-
-    recordRuntimeInfo(result, HandlerType.ETH_BLOCK)
-    return {
-      result,
-      configUpdated: false,
-    }
-  }
-
-  async processBlock(binding: BlockBinding): Promise<ProcessResult> {
-    if (!binding.block) {
-      throw new ServerError(Status.INVALID_ARGUMENT, "Block can't be empty")
-    }
-    const jsonString = Utf8ArrayToStr(binding.block.raw)
-
-    const block: Block = JSON.parse(jsonString)
+        const insHandler = processor.getInstructionHandler(parsedInstruction)
+        if (insHandler == null) {
+          continue
+        }
+        const res = await processor.handleInstruction(
+          parsedInstruction,
+          instruction.accounts,
+          insHandler,
+          instruction.slot
+        )
 
-    const promises: Promise<ProcessResult>[] = []
-    for (const handlerId of binding.handlerIds) {
-      const promise = this.blockHandlers[handlerId](block).catch((e) => {
-        throw new ServerError(Status.INTERNAL, 'error processing block: ' + block.number + '\n' + errorString(e))
-      })
-      promises.push(promise)
+        promises.push(Promise.resolve(res))
+      }
     }
     return mergeProcessResults(await Promise.all(promises))
   }
 
-  // TODO remove above old processBlock logic
-  async processBlockNew(binding: DataBinding): Promise<ProcessResult> {
+  async processBlock(binding: DataBinding): Promise<ProcessResult> {
     if (!binding.data) {
       throw new ServerError(Status.INVALID_ARGUMENT, "Block can't be empty")
     }
-    if (binding.handlerIds.length == 0) {
-      binding.handlerIds = [binding.handlerId]
-    }
 
-    const jsonString = Utf8ArrayToStr(binding.data.raw)
+    const jsonString = Utf8ArrayToStr(binding.data.ethBlock?.data || binding.data.raw)
 
     const block: Block = JSON.parse(jsonString)
 
@@ -786,10 +638,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     if (!binding.data) {
       throw new ServerError(Status.INVALID_ARGUMENT, "Trace can't be empty")
     }
-    if (binding.handlerIds.length == 0) {
-      binding.handlerIds = [binding.handlerId]
-    }
-    const jsonString = Utf8ArrayToStr(binding.data.raw)
+    const jsonString = Utf8ArrayToStr(binding.data.ethTrace?.data || binding.data.raw)
     const trace: Trace = JSON.parse(jsonString)
 
     const promises: Promise<ProcessResult>[] = []
@@ -809,7 +658,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
       throw new ServerError(Status.INVALID_ARGUMENT, "Event can't be empty")
     }
     const promises: Promise<ProcessResult>[] = []
-    const jsonString = Utf8ArrayToStr(binding.data.raw)
+    const jsonString = Utf8ArrayToStr(binding.data.aptEvent?.data || binding.data.raw)
     const event = JSON.parse(jsonString)
 
     for (const handlerId of binding.handlerIds) {
@@ -827,7 +676,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     if (!binding.data) {
       throw new ServerError(Status.INVALID_ARGUMENT, "Event can't be empty")
     }
-    const jsonString = Utf8ArrayToStr(binding.data.raw)
+    const jsonString = Utf8ArrayToStr(binding.data.aptResource?.data || binding.data.raw)
     const json = JSON.parse(jsonString) as MoveResourcesWithVersionPayload
     const promises: Promise<ProcessResult>[] = []
     for (const handlerId of binding.handlerIds) {
@@ -844,7 +693,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     if (!binding.data) {
       throw new ServerError(Status.INVALID_ARGUMENT, "Event can't be empty")
     }
-    const jsonString = Utf8ArrayToStr(binding.data.raw)
+    const jsonString = Utf8ArrayToStr(binding.data.aptCall?.data || binding.data.raw)
     const call = JSON.parse(jsonString)
 
     const promises: Promise<ProcessResult>[] = []