@sentio/sdk 1.31.6 → 1.32.1

package/src/gen/processor/protos/processor.ts

@@ -79,13 +79,13 @@ export function addressTypeToJSON(object: AddressType): string {
 export enum HandlerType {
   UNKNOWN = 0,
   ETH_LOG = 1,
-  BLOCK = 2,
-  TRANSACTION = 3,
-  INSTRUCTION = 4,
+  ETH_BLOCK = 2,
   ETH_TRACE = 5,
+  SOL_INSTRUCTIONS = 4,
   APT_EVENT = 6,
   APT_CALL = 7,
   APT_RESOURCE = 8,
+  SUI_TRANSACTION = 3,
   UNRECOGNIZED = -1,
 }
 
@@ -98,17 +98,14 @@ export function handlerTypeFromJSON(object: any): HandlerType {
     case "ETH_LOG":
       return HandlerType.ETH_LOG;
     case 2:
-    case "BLOCK":
-      return HandlerType.BLOCK;
-    case 3:
-    case "TRANSACTION":
-      return HandlerType.TRANSACTION;
-    case 4:
-    case "INSTRUCTION":
-      return HandlerType.INSTRUCTION;
+    case "ETH_BLOCK":
+      return HandlerType.ETH_BLOCK;
     case 5:
     case "ETH_TRACE":
       return HandlerType.ETH_TRACE;
+    case 4:
+    case "SOL_INSTRUCTIONS":
+      return HandlerType.SOL_INSTRUCTIONS;
     case 6:
     case "APT_EVENT":
       return HandlerType.APT_EVENT;
@@ -118,6 +115,9 @@ export function handlerTypeFromJSON(object: any): HandlerType {
     case 8:
     case "APT_RESOURCE":
       return HandlerType.APT_RESOURCE;
+    case 3:
+    case "SUI_TRANSACTION":
+      return HandlerType.SUI_TRANSACTION;
     case -1:
     case "UNRECOGNIZED":
     default:
@@ -131,20 +131,20 @@ export function handlerTypeToJSON(object: HandlerType): string {
       return "UNKNOWN";
     case HandlerType.ETH_LOG:
       return "ETH_LOG";
-    case HandlerType.BLOCK:
-      return "BLOCK";
-    case HandlerType.TRANSACTION:
-      return "TRANSACTION";
-    case HandlerType.INSTRUCTION:
-      return "INSTRUCTION";
+    case HandlerType.ETH_BLOCK:
+      return "ETH_BLOCK";
     case HandlerType.ETH_TRACE:
       return "ETH_TRACE";
+    case HandlerType.SOL_INSTRUCTIONS:
+      return "SOL_INSTRUCTIONS";
     case HandlerType.APT_EVENT:
       return "APT_EVENT";
     case HandlerType.APT_CALL:
       return "APT_CALL";
     case HandlerType.APT_RESOURCE:
       return "APT_RESOURCE";
+    case HandlerType.SUI_TRANSACTION:
+      return "SUI_TRANSACTION";
     case HandlerType.UNRECOGNIZED:
     default:
       return "UNRECOGNIZED";
@@ -315,10 +315,17 @@ export interface AccountConfig {
   logConfigs: LogHandlerConfig[];
 }
 
+export interface HandleInterval {
+  recentInterval: number;
+  backfillInterval: number;
+}
+
 export interface OnIntervalConfig {
   handlerId: number;
   minutes: number;
+  minutesInterval?: HandleInterval | undefined;
   slot: number;
+  slotInterval?: HandleInterval | undefined;
 }
 
 export interface AptosOnIntervalConfig {
@@ -440,6 +447,7 @@ export interface DataBinding {
   data: Data | undefined;
   handlerId: number;
   handlerType: HandlerType;
+  handlerIds: number[];
 }
 
 export interface BlockBinding {
@@ -1803,8 +1811,81 @@ export const AccountConfig = {
   },
 };
 
+function createBaseHandleInterval(): HandleInterval {
+  return { recentInterval: 0, backfillInterval: 0 };
+}
+
+export const HandleInterval = {
+  encode(
+    message: HandleInterval,
+    writer: _m0.Writer = _m0.Writer.create()
+  ): _m0.Writer {
+    if (message.recentInterval !== 0) {
+      writer.uint32(8).int32(message.recentInterval);
+    }
+    if (message.backfillInterval !== 0) {
+      writer.uint32(16).int32(message.backfillInterval);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): HandleInterval {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseHandleInterval();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.recentInterval = reader.int32();
+          break;
+        case 2:
+          message.backfillInterval = reader.int32();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): HandleInterval {
+    return {
+      recentInterval: isSet(object.recentInterval)
+        ? Number(object.recentInterval)
+        : 0,
+      backfillInterval: isSet(object.backfillInterval)
+        ? Number(object.backfillInterval)
+        : 0,
+    };
+  },
+
+  toJSON(message: HandleInterval): unknown {
+    const obj: any = {};
+    message.recentInterval !== undefined &&
+      (obj.recentInterval = Math.round(message.recentInterval));
+    message.backfillInterval !== undefined &&
+      (obj.backfillInterval = Math.round(message.backfillInterval));
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<HandleInterval>): HandleInterval {
+    const message = createBaseHandleInterval();
+    message.recentInterval = object.recentInterval ?? 0;
+    message.backfillInterval = object.backfillInterval ?? 0;
+    return message;
+  },
+};
+
 function createBaseOnIntervalConfig(): OnIntervalConfig {
-  return { handlerId: 0, minutes: 0, slot: 0 };
+  return {
+    handlerId: 0,
+    minutes: 0,
+    minutesInterval: undefined,
+    slot: 0,
+    slotInterval: undefined,
+  };
 }
 
 export const OnIntervalConfig = {
@@ -1818,9 +1899,21 @@ export const OnIntervalConfig = {
     if (message.minutes !== 0) {
       writer.uint32(16).int32(message.minutes);
     }
+    if (message.minutesInterval !== undefined) {
+      HandleInterval.encode(
+        message.minutesInterval,
+        writer.uint32(34).fork()
+      ).ldelim();
+    }
     if (message.slot !== 0) {
       writer.uint32(24).int32(message.slot);
     }
+    if (message.slotInterval !== undefined) {
+      HandleInterval.encode(
+        message.slotInterval,
+        writer.uint32(42).fork()
+      ).ldelim();
+    }
     return writer;
   },
 
@@ -1837,9 +1930,18 @@ export const OnIntervalConfig = {
         case 2:
           message.minutes = reader.int32();
           break;
+        case 4:
+          message.minutesInterval = HandleInterval.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
         case 3:
           message.slot = reader.int32();
           break;
+        case 5:
+          message.slotInterval = HandleInterval.decode(reader, reader.uint32());
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -1852,7 +1954,13 @@ export const OnIntervalConfig = {
     return {
       handlerId: isSet(object.handlerId) ? Number(object.handlerId) : 0,
       minutes: isSet(object.minutes) ? Number(object.minutes) : 0,
+      minutesInterval: isSet(object.minutesInterval)
+        ? HandleInterval.fromJSON(object.minutesInterval)
+        : undefined,
       slot: isSet(object.slot) ? Number(object.slot) : 0,
+      slotInterval: isSet(object.slotInterval)
+        ? HandleInterval.fromJSON(object.slotInterval)
+        : undefined,
     };
   },
 
@@ -1862,7 +1970,15 @@ export const OnIntervalConfig = {
       (obj.handlerId = Math.round(message.handlerId));
     message.minutes !== undefined &&
       (obj.minutes = Math.round(message.minutes));
+    message.minutesInterval !== undefined &&
+      (obj.minutesInterval = message.minutesInterval
+        ? HandleInterval.toJSON(message.minutesInterval)
+        : undefined);
     message.slot !== undefined && (obj.slot = Math.round(message.slot));
+    message.slotInterval !== undefined &&
+      (obj.slotInterval = message.slotInterval
+        ? HandleInterval.toJSON(message.slotInterval)
+        : undefined);
     return obj;
   },
 
@@ -1870,7 +1986,15 @@ export const OnIntervalConfig = {
     const message = createBaseOnIntervalConfig();
     message.handlerId = object.handlerId ?? 0;
     message.minutes = object.minutes ?? 0;
+    message.minutesInterval =
+      object.minutesInterval !== undefined && object.minutesInterval !== null
+        ? HandleInterval.fromPartial(object.minutesInterval)
+        : undefined;
     message.slot = object.slot ?? 0;
+    message.slotInterval =
+      object.slotInterval !== undefined && object.slotInterval !== null
+        ? HandleInterval.fromPartial(object.slotInterval)
+        : undefined;
     return message;
   },
 };
@@ -3530,7 +3654,7 @@ export const Data = {
 };
 
 function createBaseDataBinding(): DataBinding {
-  return { data: undefined, handlerId: 0, handlerType: 0 };
+  return { data: undefined, handlerId: 0, handlerType: 0, handlerIds: [] };
 }
 
 export const DataBinding = {
@@ -3547,6 +3671,11 @@ export const DataBinding = {
     if (message.handlerType !== 0) {
       writer.uint32(24).int32(message.handlerType);
     }
+    writer.uint32(34).fork();
+    for (const v of message.handlerIds) {
+      writer.int32(v);
+    }
+    writer.ldelim();
     return writer;
   },
 
@@ -3566,6 +3695,16 @@ export const DataBinding = {
         case 3:
           message.handlerType = reader.int32() as any;
           break;
+        case 4:
+          if ((tag & 7) === 2) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.handlerIds.push(reader.int32());
+            }
+          } else {
+            message.handlerIds.push(reader.int32());
+          }
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -3581,6 +3720,9 @@ export const DataBinding = {
       handlerType: isSet(object.handlerType)
         ? handlerTypeFromJSON(object.handlerType)
         : 0,
+      handlerIds: Array.isArray(object?.handlerIds)
+        ? object.handlerIds.map((e: any) => Number(e))
+        : [],
     };
   },
 
@@ -3592,6 +3734,11 @@ export const DataBinding = {
       (obj.handlerId = Math.round(message.handlerId));
     message.handlerType !== undefined &&
       (obj.handlerType = handlerTypeToJSON(message.handlerType));
+    if (message.handlerIds) {
+      obj.handlerIds = message.handlerIds.map((e) => Math.round(e));
+    } else {
+      obj.handlerIds = [];
+    }
     return obj;
   },
 
@@ -3603,6 +3750,7 @@ export const DataBinding = {
         : undefined;
     message.handlerId = object.handlerId ?? 0;
     message.handlerType = object.handlerType ?? 0;
+    message.handlerIds = object.handlerIds?.map((e) => e) || [];
     return message;
   },
 };

package/src/service.ts

@@ -12,6 +12,7 @@ import {
   EventTrackingConfig,
   ExportConfig,
   HandlerType,
+  Instruction,
   LogFilter,
   LogHandlerConfig,
   MetricConfig,
@@ -32,7 +33,7 @@ import { Empty } from './gen/google/protobuf/empty'
 import Long from 'long'
 import { TextDecoder } from 'util'
 import { Trace } from './core'
-import { Instruction } from '@project-serum/anchor'
+import { Instruction as SolInstruction } from '@project-serum/anchor'
 import { MetricState } from './core/meter'
 import { ExporterState } from './core/exporter'
 import { EventTrackerState } from './core/event-tracker'
@@ -55,9 +56,12 @@ const DEFAULT_MAX_BLOCK = Long.ZERO
 const USER_PROCESSOR = 'user_processor'
 
 export class ProcessorServiceImpl implements ProcessorServiceImplementation {
+  // eth handlers
   private eventHandlers: ((event: Log) => Promise<ProcessResult>)[] = []
   private traceHandlers: ((trace: Trace) => Promise<ProcessResult>)[] = []
   private blockHandlers: ((block: Block) => Promise<ProcessResult>)[] = []
+
+  // aptos handlers
   private aptosEventHandlers: ((event: any) => Promise<ProcessResult>)[] = []
   private aptosCallHandlers: ((func: any) => Promise<ProcessResult>)[] = []
   private aptosResourceHandlers: ((resourceWithVersion: MoveResourcesWithVersionPayload) => Promise<ProcessResult>)[] =
@@ -171,8 +175,10 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
         // TODO wrap the block handler into one
 
         contractConfig.intervalConfigs.push({
-          slot: blockHandler.blockInterval || 1,
-          minutes: blockHandler.timeIntervalInMinutes || 0,
+          slot: 0,
+          slotInterval: blockHandler.blockInterval,
+          minutes: 0,
+          minutesInterval: blockHandler.timeIntervalInMinutes,
           handlerId: handlerId,
         })
       }
@@ -387,8 +393,10 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
         accountConfig.aptosIntervalConfigs.push({
           intervalConfig: {
             handlerId: handlerId,
-            minutes: handler.timeIntervalInMinutes || 0,
-            slot: handler.versionInterval || 0,
+            minutes: 0,
+            minutesInterval: handler.timeIntervalInMinutes,
+            slot: 0,
+            slotInterval: handler.versionInterval,
           },
           type: handler.type || '',
         })
@@ -465,18 +473,37 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
   }
 
   async processBinding(request: DataBinding, options?: CallContext): Promise<ProcessResult> {
-    switch (request.handlerType) {
-      case HandlerType.APT_CALL:
-        return this.processAptosFunctionCall(request)
-      case HandlerType.APT_EVENT:
-        return this.processAptosEvent(request)
-      case HandlerType.APT_RESOURCE:
-        return this.processAptosResource(request)
-      case HandlerType.ETH_LOG:
-        return this.processLog(request)
-      default:
-        throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
+    if (request.handlerIds.length == 0) {
+      request.handlerIds = [request.handlerId]
+    }
+
+    const processBindingInternal = (request: DataBinding) => {
+      switch (request.handlerType) {
+        case HandlerType.APT_CALL:
+          return this.processAptosFunctionCall(request)
+        case HandlerType.APT_EVENT:
+          return this.processAptosEvent(request)
+        case HandlerType.APT_RESOURCE:
+          return this.processAptosResource(request)
+        case HandlerType.ETH_LOG:
+          return this.processLog(request)
+        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
+        // case HandlerType.INSTRUCTION:
+        //   return this.processInstruction(request)
+        default:
+          throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
+      }
     }
+
+    const result = await processBindingInternal(request)
+    recordRuntimeInfo(result, request.handlerType)
+    return result
   }
 
   async processLogs(request: ProcessBindingsRequest, context: CallContext): Promise<ProcessBindingResponse> {
@@ -511,17 +538,23 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     if (!l.data) {
       throw new ServerError(Status.INVALID_ARGUMENT, "Log can't be null")
     }
+    if (l.handlerIds.length == 0) {
+      l.handlerIds = [l.handlerId]
+    }
 
-    try {
-      const jsonString = Utf8ArrayToStr(l.data.raw)
-      const log: Log = JSON.parse(jsonString)
-      const handler = this.eventHandlers[l.handlerId]
-      return handler(log).catch((e) => {
-        throw new ServerError(Status.INTERNAL, 'error processing log: ' + jsonString + '\n' + errorString(e))
-      })
-    } catch (e) {
-      throw new ServerError(Status.INTERNAL, 'error parse log: ' + l)
+    const promises: Promise<ProcessResult>[] = []
+    const jsonString = Utf8ArrayToStr(l.data.raw)
+    const log: Log = JSON.parse(jsonString)
+
+    for (const handlerId of l.handlerIds) {
+      const handler = this.eventHandlers[handlerId]
+      promises.push(
+        handler(log).catch((e) => {
+          throw new ServerError(Status.INTERNAL, 'error processing log: ' + jsonString + '\n' + errorString(e))
+        })
+      )
     }
+    return mergeProcessResults(await Promise.all(promises))
   }
 
   async processTransactions(
@@ -557,7 +590,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
       await Promise.all(processorPromises)
     }
 
-    recordRuntimeInfo(result, HandlerType.TRANSACTION)
+    recordRuntimeInfo(result, HandlerType.SUI_TRANSACTION)
     return {
       result,
       configUpdated: false,
@@ -586,7 +619,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
           new Promise((resolve, _) => {
             for (const processor of SolanaProcessorState.INSTANCE.getValues()) {
               if (processor.address === instruction.programAccountId) {
-                let parsedInstruction: Instruction | null = null
+                let parsedInstruction: SolInstruction | null = null
                 if (instruction.parsed) {
                   parsedInstruction = processor.getParsedInstruction(
                     JSON.parse(new TextDecoder().decode(instruction.parsed))
@@ -620,13 +653,64 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
       await Promise.all(processorPromises)
     }
 
-    recordRuntimeInfo(result, HandlerType.INSTRUCTION)
+    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.')
+    }
+    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 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) {
+              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))
+          }
+        }
+      }
+    }
+    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.')
@@ -635,7 +719,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     const promises = request.blockBindings.map((binding) => this.processBlock(binding))
     const result = mergeProcessResults(await Promise.all(promises))
 
-    recordRuntimeInfo(result, HandlerType.BLOCK)
+    recordRuntimeInfo(result, HandlerType.ETH_BLOCK)
     return {
       result,
       configUpdated: false,
@@ -660,6 +744,30 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     return mergeProcessResults(await Promise.all(promises))
   }
 
+  // TODO remove above old processBlock logic
+  async processBlockNew(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 block: Block = JSON.parse(jsonString)
+
+    const promises: Promise<ProcessResult>[] = []
+    for (const handlerId of binding.handlerIds) {
+      promises.push(
+        this.blockHandlers[handlerId](block).catch((e) => {
+          throw new ServerError(Status.INTERNAL, 'error processing block: ' + block.number + '\n' + errorString(e))
+        })
+      )
+    }
+    return mergeProcessResults(await Promise.all(promises))
+  }
+
   async processTraces(request: ProcessBindingsRequest, context: CallContext): Promise<ProcessBindingResponse> {
     if (!this.started) {
       throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')
@@ -679,26 +787,41 @@ 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 trace: Trace = JSON.parse(jsonString)
 
-    return this.traceHandlers[binding.handlerId](trace).catch((e) => {
-      throw new ServerError(Status.INTERNAL, 'error processing trace: ' + jsonString + '\n' + errorString(e))
-    })
+    const promises: Promise<ProcessResult>[] = []
+
+    for (const handlerId of binding.handlerIds) {
+      promises.push(
+        this.traceHandlers[handlerId](trace).catch((e) => {
+          throw new ServerError(Status.INTERNAL, 'error processing trace: ' + jsonString + '\n' + errorString(e))
+        })
+      )
+    }
+    return mergeProcessResults(await Promise.all(promises))
   }
 
   async processAptosEvent(binding: DataBinding): Promise<ProcessResult> {
     if (!binding.data) {
       throw new ServerError(Status.INVALID_ARGUMENT, "Event can't be empty")
     }
+    const promises: Promise<ProcessResult>[] = []
     const jsonString = Utf8ArrayToStr(binding.data.raw)
     const event = JSON.parse(jsonString)
-    // only support aptos event for now
-    const result = await this.aptosEventHandlers[binding.handlerId](event).catch((e) => {
-      throw new ServerError(Status.INTERNAL, 'error processing event: ' + jsonString + '\n' + errorString(e))
-    })
-    recordRuntimeInfo(result, HandlerType.APT_EVENT)
-    return result
+
+    for (const handlerId of binding.handlerIds) {
+      // only support aptos event for now
+      promises.push(
+        this.aptosEventHandlers[handlerId](event).catch((e) => {
+          throw new ServerError(Status.INTERNAL, 'error processing event: ' + jsonString + '\n' + errorString(e))
+        })
+      )
+    }
+    return mergeProcessResults(await Promise.all(promises))
   }
 
   async processAptosResource(binding: DataBinding): Promise<ProcessResult> {
@@ -707,11 +830,15 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     }
     const jsonString = Utf8ArrayToStr(binding.data.raw)
     const json = JSON.parse(jsonString) as MoveResourcesWithVersionPayload
-    const result = await this.aptosResourceHandlers[binding.handlerId](json).catch((e) => {
-      throw new ServerError(Status.INTERNAL, 'error processing event: ' + jsonString + '\n' + errorString(e))
-    })
-    recordRuntimeInfo(result, HandlerType.APT_RESOURCE)
-    return result
+    const promises: Promise<ProcessResult>[] = []
+    for (const handlerId of binding.handlerIds) {
+      promises.push(
+        this.aptosResourceHandlers[handlerId](json).catch((e) => {
+          throw new ServerError(Status.INTERNAL, 'error processing event: ' + jsonString + '\n' + errorString(e))
+        })
+      )
+    }
+    return mergeProcessResults(await Promise.all(promises))
   }
 
   async processAptosFunctionCall(binding: DataBinding): Promise<ProcessResult> {
@@ -720,12 +847,16 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     }
     const jsonString = Utf8ArrayToStr(binding.data.raw)
     const call = JSON.parse(jsonString)
-    // only support aptos call for now
-    const result = await this.aptosCallHandlers[binding.handlerId](call).catch((e) => {
-      throw new ServerError(Status.INTERNAL, 'error processing call: ' + jsonString + '\n' + errorString(e))
-    })
-    recordRuntimeInfo(result, HandlerType.APT_CALL)
-    return result
+
+    const promises: Promise<ProcessResult>[] = []
+    for (const handlerId of binding.handlerIds) {
+      // only support aptos call for now
+      const promise = this.aptosCallHandlers[handlerId](call).catch((e) => {
+        throw new ServerError(Status.INTERNAL, 'error processing call: ' + jsonString + '\n' + errorString(e))
+      })
+      promises.push(promise)
+    }
+    return mergeProcessResults(await Promise.all(promises))
   }
 }