@sentio/sdk 1.19.2 → 1.19.4

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

@@ -6,11 +6,13 @@ import _m0 from "protobufjs/minimal";
 
 export enum HandlerType {
   UNKNOWN = 0,
-  LOG = 1,
+  ETH_LOG = 1,
   BLOCK = 2,
   TRANSACTION = 3,
   INSTRUCTION = 4,
-  TRACE = 5,
+  ETH_TRACE = 5,
+  APT_EVENT = 6,
+  APT_CALL = 7,
   UNRECOGNIZED = -1,
 }
 
@@ -20,8 +22,8 @@ export function handlerTypeFromJSON(object: any): HandlerType {
     case "UNKNOWN":
       return HandlerType.UNKNOWN;
     case 1:
-    case "LOG":
-      return HandlerType.LOG;
+    case "ETH_LOG":
+      return HandlerType.ETH_LOG;
     case 2:
     case "BLOCK":
       return HandlerType.BLOCK;
@@ -32,8 +34,14 @@ export function handlerTypeFromJSON(object: any): HandlerType {
     case "INSTRUCTION":
       return HandlerType.INSTRUCTION;
     case 5:
-    case "TRACE":
-      return HandlerType.TRACE;
+    case "ETH_TRACE":
+      return HandlerType.ETH_TRACE;
+    case 6:
+    case "APT_EVENT":
+      return HandlerType.APT_EVENT;
+    case 7:
+    case "APT_CALL":
+      return HandlerType.APT_CALL;
     case -1:
     case "UNRECOGNIZED":
     default:
@@ -45,16 +53,20 @@ export function handlerTypeToJSON(object: HandlerType): string {
   switch (object) {
     case HandlerType.UNKNOWN:
       return "UNKNOWN";
-    case HandlerType.LOG:
-      return "LOG";
+    case HandlerType.ETH_LOG:
+      return "ETH_LOG";
     case HandlerType.BLOCK:
       return "BLOCK";
     case HandlerType.TRANSACTION:
       return "TRANSACTION";
     case HandlerType.INSTRUCTION:
       return "INSTRUCTION";
-    case HandlerType.TRACE:
-      return "TRACE";
+    case HandlerType.ETH_TRACE:
+      return "ETH_TRACE";
+    case HandlerType.APT_EVENT:
+      return "APT_EVENT";
+    case HandlerType.APT_CALL:
+      return "APT_CALL";
     case HandlerType.UNRECOGNIZED:
     default:
       return "UNRECOGNIZED";
@@ -130,9 +142,11 @@ export interface ContractConfig {
   blockConfigs: BlockHandlerConfig[];
   logConfigs: LogHandlerConfig[];
   traceConfigs: TraceHandlerConfig[];
+  aptosEventConfigs: AptosEventHandlerConfig[];
+  aptosCallConfigs: AptosCallHandlerConfig[];
+  instructionConfig: InstructionHandlerConfig | undefined;
   startBlock: Long;
   endBlock: Long;
-  instructionConfig: InstructionHandlerConfig | undefined;
   processorType: string;
 }
 
@@ -178,25 +192,28 @@ export interface InstructionHandlerConfig {
   rawDataInstruction: boolean;
 }
 
-export interface Topic {
-  hashes: string[];
+export interface AptosEventHandlerConfig {
+  filters: AptosEventFilter[];
+  handlerId: number;
 }
 
-export interface ProcessLogsRequest {
-  logBindings: LogBinding[];
+export interface AptosEventFilter {
+  type: string;
 }
 
-export interface ProcessLogsResponse {
-  result: ProcessResult | undefined;
-  configUpdated: boolean;
+export interface AptosCallHandlerConfig {
+  filters: AptosCallFilter[];
+  handlerId: number;
 }
 
-export interface ProcessTracesRequest {
-  traceBindings: TraceBinding[];
+export interface AptosCallFilter {
+  function: string;
+  typeArguments: string[];
+  withTypeArguments: boolean;
 }
 
-export interface ProcessTracesResponse {
-  result: ProcessResult | undefined;
+export interface Topic {
+  hashes: string[];
 }
 
 export interface ProcessTransactionsRequest {
@@ -208,38 +225,17 @@ export interface ProcessInstructionsRequest {
   instructions: Instruction[];
 }
 
-export interface ProcessTransactionsResponse {
-  result: ProcessResult | undefined;
-}
-
-export interface ProcessInstructionsResponse {
-  result: ProcessResult | undefined;
-}
-
 export interface ProcessBlocksRequest {
   blockBindings: BlockBinding[];
 }
 
-export interface ProcessBlocksResponse {
-  result: ProcessResult | undefined;
-}
-
-export interface LogBinding {
-  log: RawLog | undefined;
-  handlerId: number;
-}
-
-export interface RawLog {
-  raw: Uint8Array;
-}
-
-export interface TraceBinding {
-  trace: RawTrace | undefined;
-  handlerId: number;
+export interface ProcessBindingsRequest {
+  bindings: DataBinding[];
 }
 
-export interface RawTrace {
-  raw: Uint8Array;
+export interface ProcessBindingResponse {
+  result: ProcessResult | undefined;
+  configUpdated: boolean;
 }
 
 export interface RawTransaction {
@@ -255,6 +251,16 @@ export interface Instruction {
   parsed?: Uint8Array | undefined;
 }
 
+export interface Data {
+  raw: Uint8Array;
+}
+
+export interface DataBinding {
+  data: Data | undefined;
+  handlerId: number;
+  handlerType: HandlerType;
+}
+
 export interface BlockBinding {
   block: RawBlock | undefined;
   handlerIds: number[];
@@ -322,9 +328,11 @@ export interface CounterResult {
 }
 
 export interface LogResult {
+  name: string;
   metadata: RecordMetaData | undefined;
   level: LogLevel;
   message: string;
+  attributes: string;
   runtimeInfo: RuntimeInfo | undefined;
 }
 
@@ -546,9 +554,11 @@ function createBaseContractConfig(): ContractConfig {
     blockConfigs: [],
     logConfigs: [],
     traceConfigs: [],
+    aptosEventConfigs: [],
+    aptosCallConfigs: [],
+    instructionConfig: undefined,
     startBlock: Long.UZERO,
     endBlock: Long.UZERO,
-    instructionConfig: undefined,
     processorType: "",
   };
 }
@@ -570,11 +580,11 @@ export const ContractConfig = {
     for (const v of message.traceConfigs) {
       TraceHandlerConfig.encode(v!, writer.uint32(18).fork()).ldelim();
     }
-    if (!message.startBlock.isZero()) {
-      writer.uint32(32).uint64(message.startBlock);
+    for (const v of message.aptosEventConfigs) {
+      AptosEventHandlerConfig.encode(v!, writer.uint32(74).fork()).ldelim();
     }
-    if (!message.endBlock.isZero()) {
-      writer.uint32(40).uint64(message.endBlock);
+    for (const v of message.aptosCallConfigs) {
+      AptosCallHandlerConfig.encode(v!, writer.uint32(82).fork()).ldelim();
     }
     if (message.instructionConfig !== undefined) {
       InstructionHandlerConfig.encode(
@@ -582,6 +592,12 @@ export const ContractConfig = {
         writer.uint32(50).fork()
       ).ldelim();
     }
+    if (!message.startBlock.isZero()) {
+      writer.uint32(32).uint64(message.startBlock);
+    }
+    if (!message.endBlock.isZero()) {
+      writer.uint32(40).uint64(message.endBlock);
+    }
     if (message.processorType !== "") {
       writer.uint32(66).string(message.processorType);
     }
@@ -613,11 +629,15 @@ export const ContractConfig = {
             TraceHandlerConfig.decode(reader, reader.uint32())
           );
           break;
-        case 4:
-          message.startBlock = reader.uint64() as Long;
+        case 9:
+          message.aptosEventConfigs.push(
+            AptosEventHandlerConfig.decode(reader, reader.uint32())
+          );
           break;
-        case 5:
-          message.endBlock = reader.uint64() as Long;
+        case 10:
+          message.aptosCallConfigs.push(
+            AptosCallHandlerConfig.decode(reader, reader.uint32())
+          );
           break;
         case 6:
           message.instructionConfig = InstructionHandlerConfig.decode(
@@ -625,6 +645,12 @@ export const ContractConfig = {
             reader.uint32()
           );
           break;
+        case 4:
+          message.startBlock = reader.uint64() as Long;
+          break;
+        case 5:
+          message.endBlock = reader.uint64() as Long;
+          break;
         case 8:
           message.processorType = reader.string();
           break;
@@ -650,15 +676,25 @@ export const ContractConfig = {
       traceConfigs: Array.isArray(object?.traceConfigs)
         ? object.traceConfigs.map((e: any) => TraceHandlerConfig.fromJSON(e))
         : [],
+      aptosEventConfigs: Array.isArray(object?.aptosEventConfigs)
+        ? object.aptosEventConfigs.map((e: any) =>
+            AptosEventHandlerConfig.fromJSON(e)
+          )
+        : [],
+      aptosCallConfigs: Array.isArray(object?.aptosCallConfigs)
+        ? object.aptosCallConfigs.map((e: any) =>
+            AptosCallHandlerConfig.fromJSON(e)
+          )
+        : [],
+      instructionConfig: isSet(object.instructionConfig)
+        ? InstructionHandlerConfig.fromJSON(object.instructionConfig)
+        : undefined,
       startBlock: isSet(object.startBlock)
         ? Long.fromValue(object.startBlock)
         : Long.UZERO,
       endBlock: isSet(object.endBlock)
         ? Long.fromValue(object.endBlock)
         : Long.UZERO,
-      instructionConfig: isSet(object.instructionConfig)
-        ? InstructionHandlerConfig.fromJSON(object.instructionConfig)
-        : undefined,
       processorType: isSet(object.processorType)
         ? String(object.processorType)
         : "",
@@ -692,14 +728,28 @@ export const ContractConfig = {
     } else {
       obj.traceConfigs = [];
     }
-    message.startBlock !== undefined &&
-      (obj.startBlock = (message.startBlock || Long.UZERO).toString());
-    message.endBlock !== undefined &&
-      (obj.endBlock = (message.endBlock || Long.UZERO).toString());
+    if (message.aptosEventConfigs) {
+      obj.aptosEventConfigs = message.aptosEventConfigs.map((e) =>
+        e ? AptosEventHandlerConfig.toJSON(e) : undefined
+      );
+    } else {
+      obj.aptosEventConfigs = [];
+    }
+    if (message.aptosCallConfigs) {
+      obj.aptosCallConfigs = message.aptosCallConfigs.map((e) =>
+        e ? AptosCallHandlerConfig.toJSON(e) : undefined
+      );
+    } else {
+      obj.aptosCallConfigs = [];
+    }
     message.instructionConfig !== undefined &&
       (obj.instructionConfig = message.instructionConfig
         ? InstructionHandlerConfig.toJSON(message.instructionConfig)
         : undefined);
+    message.startBlock !== undefined &&
+      (obj.startBlock = (message.startBlock || Long.UZERO).toString());
+    message.endBlock !== undefined &&
+      (obj.endBlock = (message.endBlock || Long.UZERO).toString());
     message.processorType !== undefined &&
       (obj.processorType = message.processorType);
     return obj;
@@ -717,6 +767,19 @@ export const ContractConfig = {
       object.logConfigs?.map((e) => LogHandlerConfig.fromPartial(e)) || [];
     message.traceConfigs =
       object.traceConfigs?.map((e) => TraceHandlerConfig.fromPartial(e)) || [];
+    message.aptosEventConfigs =
+      object.aptosEventConfigs?.map((e) =>
+        AptosEventHandlerConfig.fromPartial(e)
+      ) || [];
+    message.aptosCallConfigs =
+      object.aptosCallConfigs?.map((e) =>
+        AptosCallHandlerConfig.fromPartial(e)
+      ) || [];
+    message.instructionConfig =
+      object.instructionConfig !== undefined &&
+      object.instructionConfig !== null
+        ? InstructionHandlerConfig.fromPartial(object.instructionConfig)
+        : undefined;
     message.startBlock =
       object.startBlock !== undefined && object.startBlock !== null
         ? Long.fromValue(object.startBlock)
@@ -725,11 +788,6 @@ export const ContractConfig = {
       object.endBlock !== undefined && object.endBlock !== null
         ? Long.fromValue(object.endBlock)
         : Long.UZERO;
-    message.instructionConfig =
-      object.instructionConfig !== undefined &&
-      object.instructionConfig !== null
-        ? InstructionHandlerConfig.fromPartial(object.instructionConfig)
-        : undefined;
     message.processorType = object.processorType ?? "";
     return message;
   },
@@ -1315,27 +1373,41 @@ export const InstructionHandlerConfig = {
   },
 };
 
-function createBaseTopic(): Topic {
-  return { hashes: [] };
+function createBaseAptosEventHandlerConfig(): AptosEventHandlerConfig {
+  return { filters: [], handlerId: 0 };
 }
 
-export const Topic = {
-  encode(message: Topic, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    for (const v of message.hashes) {
-      writer.uint32(10).string(v!);
+export const AptosEventHandlerConfig = {
+  encode(
+    message: AptosEventHandlerConfig,
+    writer: _m0.Writer = _m0.Writer.create()
+  ): _m0.Writer {
+    for (const v of message.filters) {
+      AptosEventFilter.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.handlerId !== 0) {
+      writer.uint32(16).int32(message.handlerId);
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): Topic {
+  decode(
+    input: _m0.Reader | Uint8Array,
+    length?: number
+  ): AptosEventHandlerConfig {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseTopic();
+    const message = createBaseAptosEventHandlerConfig();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.hashes.push(reader.string());
+          message.filters.push(
+            AptosEventFilter.decode(reader, reader.uint32())
+          );
+          break;
+        case 2:
+          message.handlerId = reader.int32();
           break;
         default:
           reader.skipType(tag & 7);
@@ -1345,55 +1417,64 @@ export const Topic = {
     return message;
   },
 
-  fromJSON(object: any): Topic {
+  fromJSON(object: any): AptosEventHandlerConfig {
     return {
-      hashes: Array.isArray(object?.hashes)
-        ? object.hashes.map((e: any) => String(e))
+      filters: Array.isArray(object?.filters)
+        ? object.filters.map((e: any) => AptosEventFilter.fromJSON(e))
         : [],
+      handlerId: isSet(object.handlerId) ? Number(object.handlerId) : 0,
     };
   },
 
-  toJSON(message: Topic): unknown {
+  toJSON(message: AptosEventHandlerConfig): unknown {
     const obj: any = {};
-    if (message.hashes) {
-      obj.hashes = message.hashes.map((e) => e);
+    if (message.filters) {
+      obj.filters = message.filters.map((e) =>
+        e ? AptosEventFilter.toJSON(e) : undefined
+      );
     } else {
-      obj.hashes = [];
+      obj.filters = [];
     }
+    message.handlerId !== undefined &&
+      (obj.handlerId = Math.round(message.handlerId));
     return obj;
   },
 
-  fromPartial(object: DeepPartial<Topic>): Topic {
-    const message = createBaseTopic();
-    message.hashes = object.hashes?.map((e) => e) || [];
+  fromPartial(
+    object: DeepPartial<AptosEventHandlerConfig>
+  ): AptosEventHandlerConfig {
+    const message = createBaseAptosEventHandlerConfig();
+    message.filters =
+      object.filters?.map((e) => AptosEventFilter.fromPartial(e)) || [];
+    message.handlerId = object.handlerId ?? 0;
     return message;
   },
 };
 
-function createBaseProcessLogsRequest(): ProcessLogsRequest {
-  return { logBindings: [] };
+function createBaseAptosEventFilter(): AptosEventFilter {
+  return { type: "" };
 }
 
-export const ProcessLogsRequest = {
+export const AptosEventFilter = {
   encode(
-    message: ProcessLogsRequest,
+    message: AptosEventFilter,
     writer: _m0.Writer = _m0.Writer.create()
   ): _m0.Writer {
-    for (const v of message.logBindings) {
-      LogBinding.encode(v!, writer.uint32(10).fork()).ldelim();
+    if (message.type !== "") {
+      writer.uint32(10).string(message.type);
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): ProcessLogsRequest {
+  decode(input: _m0.Reader | Uint8Array, length?: number): AptosEventFilter {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseProcessLogsRequest();
+    const message = createBaseAptosEventFilter();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.logBindings.push(LogBinding.decode(reader, reader.uint32()));
+          message.type = reader.string();
           break;
         default:
           reader.skipType(tag & 7);
@@ -1403,64 +1484,58 @@ export const ProcessLogsRequest = {
     return message;
   },
 
-  fromJSON(object: any): ProcessLogsRequest {
+  fromJSON(object: any): AptosEventFilter {
     return {
-      logBindings: Array.isArray(object?.logBindings)
-        ? object.logBindings.map((e: any) => LogBinding.fromJSON(e))
-        : [],
+      type: isSet(object.type) ? String(object.type) : "",
     };
   },
 
-  toJSON(message: ProcessLogsRequest): unknown {
+  toJSON(message: AptosEventFilter): unknown {
     const obj: any = {};
-    if (message.logBindings) {
-      obj.logBindings = message.logBindings.map((e) =>
-        e ? LogBinding.toJSON(e) : undefined
-      );
-    } else {
-      obj.logBindings = [];
-    }
+    message.type !== undefined && (obj.type = message.type);
     return obj;
   },
 
-  fromPartial(object: DeepPartial<ProcessLogsRequest>): ProcessLogsRequest {
-    const message = createBaseProcessLogsRequest();
-    message.logBindings =
-      object.logBindings?.map((e) => LogBinding.fromPartial(e)) || [];
+  fromPartial(object: DeepPartial<AptosEventFilter>): AptosEventFilter {
+    const message = createBaseAptosEventFilter();
+    message.type = object.type ?? "";
     return message;
   },
 };
 
-function createBaseProcessLogsResponse(): ProcessLogsResponse {
-  return { result: undefined, configUpdated: false };
+function createBaseAptosCallHandlerConfig(): AptosCallHandlerConfig {
+  return { filters: [], handlerId: 0 };
 }
 
-export const ProcessLogsResponse = {
+export const AptosCallHandlerConfig = {
   encode(
-    message: ProcessLogsResponse,
+    message: AptosCallHandlerConfig,
     writer: _m0.Writer = _m0.Writer.create()
   ): _m0.Writer {
-    if (message.result !== undefined) {
-      ProcessResult.encode(message.result, writer.uint32(10).fork()).ldelim();
+    for (const v of message.filters) {
+      AptosCallFilter.encode(v!, writer.uint32(10).fork()).ldelim();
     }
-    if (message.configUpdated === true) {
-      writer.uint32(32).bool(message.configUpdated);
+    if (message.handlerId !== 0) {
+      writer.uint32(16).int32(message.handlerId);
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): ProcessLogsResponse {
+  decode(
+    input: _m0.Reader | Uint8Array,
+    length?: number
+  ): AptosCallHandlerConfig {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseProcessLogsResponse();
+    const message = createBaseAptosCallHandlerConfig();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.result = ProcessResult.decode(reader, reader.uint32());
+          message.filters.push(AptosCallFilter.decode(reader, reader.uint32()));
           break;
-        case 4:
-          message.configUpdated = reader.bool();
+        case 2:
+          message.handlerId = reader.int32();
           break;
         default:
           reader.skipType(tag & 7);
@@ -1470,68 +1545,76 @@ export const ProcessLogsResponse = {
     return message;
   },
 
-  fromJSON(object: any): ProcessLogsResponse {
+  fromJSON(object: any): AptosCallHandlerConfig {
     return {
-      result: isSet(object.result)
-        ? ProcessResult.fromJSON(object.result)
-        : undefined,
-      configUpdated: isSet(object.configUpdated)
-        ? Boolean(object.configUpdated)
-        : false,
+      filters: Array.isArray(object?.filters)
+        ? object.filters.map((e: any) => AptosCallFilter.fromJSON(e))
+        : [],
+      handlerId: isSet(object.handlerId) ? Number(object.handlerId) : 0,
     };
   },
 
-  toJSON(message: ProcessLogsResponse): unknown {
+  toJSON(message: AptosCallHandlerConfig): unknown {
     const obj: any = {};
-    message.result !== undefined &&
-      (obj.result = message.result
-        ? ProcessResult.toJSON(message.result)
-        : undefined);
-    message.configUpdated !== undefined &&
-      (obj.configUpdated = message.configUpdated);
+    if (message.filters) {
+      obj.filters = message.filters.map((e) =>
+        e ? AptosCallFilter.toJSON(e) : undefined
+      );
+    } else {
+      obj.filters = [];
+    }
+    message.handlerId !== undefined &&
+      (obj.handlerId = Math.round(message.handlerId));
     return obj;
   },
 
-  fromPartial(object: DeepPartial<ProcessLogsResponse>): ProcessLogsResponse {
-    const message = createBaseProcessLogsResponse();
-    message.result =
-      object.result !== undefined && object.result !== null
-        ? ProcessResult.fromPartial(object.result)
-        : undefined;
-    message.configUpdated = object.configUpdated ?? false;
+  fromPartial(
+    object: DeepPartial<AptosCallHandlerConfig>
+  ): AptosCallHandlerConfig {
+    const message = createBaseAptosCallHandlerConfig();
+    message.filters =
+      object.filters?.map((e) => AptosCallFilter.fromPartial(e)) || [];
+    message.handlerId = object.handlerId ?? 0;
     return message;
   },
 };
 
-function createBaseProcessTracesRequest(): ProcessTracesRequest {
-  return { traceBindings: [] };
+function createBaseAptosCallFilter(): AptosCallFilter {
+  return { function: "", typeArguments: [], withTypeArguments: false };
 }
 
-export const ProcessTracesRequest = {
+export const AptosCallFilter = {
   encode(
-    message: ProcessTracesRequest,
+    message: AptosCallFilter,
     writer: _m0.Writer = _m0.Writer.create()
   ): _m0.Writer {
-    for (const v of message.traceBindings) {
-      TraceBinding.encode(v!, writer.uint32(10).fork()).ldelim();
+    if (message.function !== "") {
+      writer.uint32(10).string(message.function);
+    }
+    for (const v of message.typeArguments) {
+      writer.uint32(18).string(v!);
+    }
+    if (message.withTypeArguments === true) {
+      writer.uint32(24).bool(message.withTypeArguments);
     }
     return writer;
   },
 
-  decode(
-    input: _m0.Reader | Uint8Array,
-    length?: number
-  ): ProcessTracesRequest {
+  decode(input: _m0.Reader | Uint8Array, length?: number): AptosCallFilter {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseProcessTracesRequest();
+    const message = createBaseAptosCallFilter();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.traceBindings.push(
-            TraceBinding.decode(reader, reader.uint32())
-          );
+          message.function = reader.string();
+          break;
+        case 2:
+          message.typeArguments.push(reader.string());
+          break;
+        case 3:
+          message.withTypeArguments = reader.bool();
           break;
         default:
           reader.skipType(tag & 7);
@@ -1541,61 +1624,61 @@ export const ProcessTracesRequest = {
     return message;
   },
 
-  fromJSON(object: any): ProcessTracesRequest {
+  fromJSON(object: any): AptosCallFilter {
     return {
-      traceBindings: Array.isArray(object?.traceBindings)
-        ? object.traceBindings.map((e: any) => TraceBinding.fromJSON(e))
+      function: isSet(object.function) ? String(object.function) : "",
+      typeArguments: Array.isArray(object?.typeArguments)
+        ? object.typeArguments.map((e: any) => String(e))
         : [],
+      withTypeArguments: isSet(object.withTypeArguments)
+        ? Boolean(object.withTypeArguments)
+        : false,
     };
   },
 
-  toJSON(message: ProcessTracesRequest): unknown {
+  toJSON(message: AptosCallFilter): unknown {
     const obj: any = {};
-    if (message.traceBindings) {
-      obj.traceBindings = message.traceBindings.map((e) =>
-        e ? TraceBinding.toJSON(e) : undefined
-      );
+    message.function !== undefined && (obj.function = message.function);
+    if (message.typeArguments) {
+      obj.typeArguments = message.typeArguments.map((e) => e);
     } else {
-      obj.traceBindings = [];
+      obj.typeArguments = [];
     }
+    message.withTypeArguments !== undefined &&
+      (obj.withTypeArguments = message.withTypeArguments);
     return obj;
   },
 
-  fromPartial(object: DeepPartial<ProcessTracesRequest>): ProcessTracesRequest {
-    const message = createBaseProcessTracesRequest();
-    message.traceBindings =
-      object.traceBindings?.map((e) => TraceBinding.fromPartial(e)) || [];
+  fromPartial(object: DeepPartial<AptosCallFilter>): AptosCallFilter {
+    const message = createBaseAptosCallFilter();
+    message.function = object.function ?? "";
+    message.typeArguments = object.typeArguments?.map((e) => e) || [];
+    message.withTypeArguments = object.withTypeArguments ?? false;
     return message;
   },
 };
 
-function createBaseProcessTracesResponse(): ProcessTracesResponse {
-  return { result: undefined };
+function createBaseTopic(): Topic {
+  return { hashes: [] };
 }
 
-export const ProcessTracesResponse = {
-  encode(
-    message: ProcessTracesResponse,
-    writer: _m0.Writer = _m0.Writer.create()
-  ): _m0.Writer {
-    if (message.result !== undefined) {
-      ProcessResult.encode(message.result, writer.uint32(10).fork()).ldelim();
+export const Topic = {
+  encode(message: Topic, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.hashes) {
+      writer.uint32(10).string(v!);
     }
     return writer;
   },
 
-  decode(
-    input: _m0.Reader | Uint8Array,
-    length?: number
-  ): ProcessTracesResponse {
+  decode(input: _m0.Reader | Uint8Array, length?: number): Topic {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseProcessTracesResponse();
+    const message = createBaseTopic();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.result = ProcessResult.decode(reader, reader.uint32());
+          message.hashes.push(reader.string());
           break;
         default:
           reader.skipType(tag & 7);
@@ -1605,31 +1688,27 @@ export const ProcessTracesResponse = {
     return message;
   },
 
-  fromJSON(object: any): ProcessTracesResponse {
+  fromJSON(object: any): Topic {
     return {
-      result: isSet(object.result)
-        ? ProcessResult.fromJSON(object.result)
-        : undefined,
+      hashes: Array.isArray(object?.hashes)
+        ? object.hashes.map((e: any) => String(e))
+        : [],
     };
   },
 
-  toJSON(message: ProcessTracesResponse): unknown {
+  toJSON(message: Topic): unknown {
     const obj: any = {};
-    message.result !== undefined &&
-      (obj.result = message.result
-        ? ProcessResult.toJSON(message.result)
-        : undefined);
+    if (message.hashes) {
+      obj.hashes = message.hashes.map((e) => e);
+    } else {
+      obj.hashes = [];
+    }
     return obj;
   },
 
-  fromPartial(
-    object: DeepPartial<ProcessTracesResponse>
-  ): ProcessTracesResponse {
-    const message = createBaseProcessTracesResponse();
-    message.result =
-      object.result !== undefined && object.result !== null
-        ? ProcessResult.fromPartial(object.result)
-        : undefined;
+  fromPartial(object: DeepPartial<Topic>): Topic {
+    const message = createBaseTopic();
+    message.hashes = object.hashes?.map((e) => e) || [];
     return message;
   },
 };
@@ -1739,337 +1818,7 @@ export const ProcessInstructionsRequest = {
         case 1:
           message.instructions.push(
             Instruction.decode(reader, reader.uint32())
-          );
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
-      }
-    }
-    return message;
-  },
-
-  fromJSON(object: any): ProcessInstructionsRequest {
-    return {
-      instructions: Array.isArray(object?.instructions)
-        ? object.instructions.map((e: any) => Instruction.fromJSON(e))
-        : [],
-    };
-  },
-
-  toJSON(message: ProcessInstructionsRequest): unknown {
-    const obj: any = {};
-    if (message.instructions) {
-      obj.instructions = message.instructions.map((e) =>
-        e ? Instruction.toJSON(e) : undefined
-      );
-    } else {
-      obj.instructions = [];
-    }
-    return obj;
-  },
-
-  fromPartial(
-    object: DeepPartial<ProcessInstructionsRequest>
-  ): ProcessInstructionsRequest {
-    const message = createBaseProcessInstructionsRequest();
-    message.instructions =
-      object.instructions?.map((e) => Instruction.fromPartial(e)) || [];
-    return message;
-  },
-};
-
-function createBaseProcessTransactionsResponse(): ProcessTransactionsResponse {
-  return { result: undefined };
-}
-
-export const ProcessTransactionsResponse = {
-  encode(
-    message: ProcessTransactionsResponse,
-    writer: _m0.Writer = _m0.Writer.create()
-  ): _m0.Writer {
-    if (message.result !== undefined) {
-      ProcessResult.encode(message.result, writer.uint32(10).fork()).ldelim();
-    }
-    return writer;
-  },
-
-  decode(
-    input: _m0.Reader | Uint8Array,
-    length?: number
-  ): ProcessTransactionsResponse {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseProcessTransactionsResponse();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1:
-          message.result = ProcessResult.decode(reader, reader.uint32());
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
-      }
-    }
-    return message;
-  },
-
-  fromJSON(object: any): ProcessTransactionsResponse {
-    return {
-      result: isSet(object.result)
-        ? ProcessResult.fromJSON(object.result)
-        : undefined,
-    };
-  },
-
-  toJSON(message: ProcessTransactionsResponse): unknown {
-    const obj: any = {};
-    message.result !== undefined &&
-      (obj.result = message.result
-        ? ProcessResult.toJSON(message.result)
-        : undefined);
-    return obj;
-  },
-
-  fromPartial(
-    object: DeepPartial<ProcessTransactionsResponse>
-  ): ProcessTransactionsResponse {
-    const message = createBaseProcessTransactionsResponse();
-    message.result =
-      object.result !== undefined && object.result !== null
-        ? ProcessResult.fromPartial(object.result)
-        : undefined;
-    return message;
-  },
-};
-
-function createBaseProcessInstructionsResponse(): ProcessInstructionsResponse {
-  return { result: undefined };
-}
-
-export const ProcessInstructionsResponse = {
-  encode(
-    message: ProcessInstructionsResponse,
-    writer: _m0.Writer = _m0.Writer.create()
-  ): _m0.Writer {
-    if (message.result !== undefined) {
-      ProcessResult.encode(message.result, writer.uint32(10).fork()).ldelim();
-    }
-    return writer;
-  },
-
-  decode(
-    input: _m0.Reader | Uint8Array,
-    length?: number
-  ): ProcessInstructionsResponse {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseProcessInstructionsResponse();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1:
-          message.result = ProcessResult.decode(reader, reader.uint32());
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
-      }
-    }
-    return message;
-  },
-
-  fromJSON(object: any): ProcessInstructionsResponse {
-    return {
-      result: isSet(object.result)
-        ? ProcessResult.fromJSON(object.result)
-        : undefined,
-    };
-  },
-
-  toJSON(message: ProcessInstructionsResponse): unknown {
-    const obj: any = {};
-    message.result !== undefined &&
-      (obj.result = message.result
-        ? ProcessResult.toJSON(message.result)
-        : undefined);
-    return obj;
-  },
-
-  fromPartial(
-    object: DeepPartial<ProcessInstructionsResponse>
-  ): ProcessInstructionsResponse {
-    const message = createBaseProcessInstructionsResponse();
-    message.result =
-      object.result !== undefined && object.result !== null
-        ? ProcessResult.fromPartial(object.result)
-        : undefined;
-    return message;
-  },
-};
-
-function createBaseProcessBlocksRequest(): ProcessBlocksRequest {
-  return { blockBindings: [] };
-}
-
-export const ProcessBlocksRequest = {
-  encode(
-    message: ProcessBlocksRequest,
-    writer: _m0.Writer = _m0.Writer.create()
-  ): _m0.Writer {
-    for (const v of message.blockBindings) {
-      BlockBinding.encode(v!, writer.uint32(18).fork()).ldelim();
-    }
-    return writer;
-  },
-
-  decode(
-    input: _m0.Reader | Uint8Array,
-    length?: number
-  ): ProcessBlocksRequest {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseProcessBlocksRequest();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 2:
-          message.blockBindings.push(
-            BlockBinding.decode(reader, reader.uint32())
-          );
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
-      }
-    }
-    return message;
-  },
-
-  fromJSON(object: any): ProcessBlocksRequest {
-    return {
-      blockBindings: Array.isArray(object?.blockBindings)
-        ? object.blockBindings.map((e: any) => BlockBinding.fromJSON(e))
-        : [],
-    };
-  },
-
-  toJSON(message: ProcessBlocksRequest): unknown {
-    const obj: any = {};
-    if (message.blockBindings) {
-      obj.blockBindings = message.blockBindings.map((e) =>
-        e ? BlockBinding.toJSON(e) : undefined
-      );
-    } else {
-      obj.blockBindings = [];
-    }
-    return obj;
-  },
-
-  fromPartial(object: DeepPartial<ProcessBlocksRequest>): ProcessBlocksRequest {
-    const message = createBaseProcessBlocksRequest();
-    message.blockBindings =
-      object.blockBindings?.map((e) => BlockBinding.fromPartial(e)) || [];
-    return message;
-  },
-};
-
-function createBaseProcessBlocksResponse(): ProcessBlocksResponse {
-  return { result: undefined };
-}
-
-export const ProcessBlocksResponse = {
-  encode(
-    message: ProcessBlocksResponse,
-    writer: _m0.Writer = _m0.Writer.create()
-  ): _m0.Writer {
-    if (message.result !== undefined) {
-      ProcessResult.encode(message.result, writer.uint32(18).fork()).ldelim();
-    }
-    return writer;
-  },
-
-  decode(
-    input: _m0.Reader | Uint8Array,
-    length?: number
-  ): ProcessBlocksResponse {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseProcessBlocksResponse();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 2:
-          message.result = ProcessResult.decode(reader, reader.uint32());
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
-      }
-    }
-    return message;
-  },
-
-  fromJSON(object: any): ProcessBlocksResponse {
-    return {
-      result: isSet(object.result)
-        ? ProcessResult.fromJSON(object.result)
-        : undefined,
-    };
-  },
-
-  toJSON(message: ProcessBlocksResponse): unknown {
-    const obj: any = {};
-    message.result !== undefined &&
-      (obj.result = message.result
-        ? ProcessResult.toJSON(message.result)
-        : undefined);
-    return obj;
-  },
-
-  fromPartial(
-    object: DeepPartial<ProcessBlocksResponse>
-  ): ProcessBlocksResponse {
-    const message = createBaseProcessBlocksResponse();
-    message.result =
-      object.result !== undefined && object.result !== null
-        ? ProcessResult.fromPartial(object.result)
-        : undefined;
-    return message;
-  },
-};
-
-function createBaseLogBinding(): LogBinding {
-  return { log: undefined, handlerId: 0 };
-}
-
-export const LogBinding = {
-  encode(
-    message: LogBinding,
-    writer: _m0.Writer = _m0.Writer.create()
-  ): _m0.Writer {
-    if (message.log !== undefined) {
-      RawLog.encode(message.log, writer.uint32(10).fork()).ldelim();
-    }
-    if (message.handlerId !== 0) {
-      writer.uint32(16).int32(message.handlerId);
-    }
-    return writer;
-  },
-
-  decode(input: _m0.Reader | Uint8Array, length?: number): LogBinding {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseLogBinding();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1:
-          message.log = RawLog.decode(reader, reader.uint32());
-          break;
-        case 2:
-          message.handlerId = reader.int32();
+          );
           break;
         default:
           reader.skipType(tag & 7);
@@ -2079,57 +1828,65 @@ export const LogBinding = {
     return message;
   },
 
-  fromJSON(object: any): LogBinding {
+  fromJSON(object: any): ProcessInstructionsRequest {
     return {
-      log: isSet(object.log) ? RawLog.fromJSON(object.log) : undefined,
-      handlerId: isSet(object.handlerId) ? Number(object.handlerId) : 0,
+      instructions: Array.isArray(object?.instructions)
+        ? object.instructions.map((e: any) => Instruction.fromJSON(e))
+        : [],
     };
   },
 
-  toJSON(message: LogBinding): unknown {
+  toJSON(message: ProcessInstructionsRequest): unknown {
     const obj: any = {};
-    message.log !== undefined &&
-      (obj.log = message.log ? RawLog.toJSON(message.log) : undefined);
-    message.handlerId !== undefined &&
-      (obj.handlerId = Math.round(message.handlerId));
+    if (message.instructions) {
+      obj.instructions = message.instructions.map((e) =>
+        e ? Instruction.toJSON(e) : undefined
+      );
+    } else {
+      obj.instructions = [];
+    }
     return obj;
   },
 
-  fromPartial(object: DeepPartial<LogBinding>): LogBinding {
-    const message = createBaseLogBinding();
-    message.log =
-      object.log !== undefined && object.log !== null
-        ? RawLog.fromPartial(object.log)
-        : undefined;
-    message.handlerId = object.handlerId ?? 0;
+  fromPartial(
+    object: DeepPartial<ProcessInstructionsRequest>
+  ): ProcessInstructionsRequest {
+    const message = createBaseProcessInstructionsRequest();
+    message.instructions =
+      object.instructions?.map((e) => Instruction.fromPartial(e)) || [];
     return message;
   },
 };
 
-function createBaseRawLog(): RawLog {
-  return { raw: new Uint8Array() };
+function createBaseProcessBlocksRequest(): ProcessBlocksRequest {
+  return { blockBindings: [] };
 }
 
-export const RawLog = {
+export const ProcessBlocksRequest = {
   encode(
-    message: RawLog,
+    message: ProcessBlocksRequest,
     writer: _m0.Writer = _m0.Writer.create()
   ): _m0.Writer {
-    if (message.raw.length !== 0) {
-      writer.uint32(10).bytes(message.raw);
+    for (const v of message.blockBindings) {
+      BlockBinding.encode(v!, writer.uint32(18).fork()).ldelim();
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): RawLog {
+  decode(
+    input: _m0.Reader | Uint8Array,
+    length?: number
+  ): ProcessBlocksRequest {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseRawLog();
+    const message = createBaseProcessBlocksRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
-          message.raw = reader.bytes();
+        case 2:
+          message.blockBindings.push(
+            BlockBinding.decode(reader, reader.uint32())
+          );
           break;
         default:
           reader.skipType(tag & 7);
@@ -2139,58 +1896,61 @@ export const RawLog = {
     return message;
   },
 
-  fromJSON(object: any): RawLog {
+  fromJSON(object: any): ProcessBlocksRequest {
     return {
-      raw: isSet(object.raw) ? bytesFromBase64(object.raw) : new Uint8Array(),
+      blockBindings: Array.isArray(object?.blockBindings)
+        ? object.blockBindings.map((e: any) => BlockBinding.fromJSON(e))
+        : [],
     };
   },
 
-  toJSON(message: RawLog): unknown {
+  toJSON(message: ProcessBlocksRequest): unknown {
     const obj: any = {};
-    message.raw !== undefined &&
-      (obj.raw = base64FromBytes(
-        message.raw !== undefined ? message.raw : new Uint8Array()
-      ));
+    if (message.blockBindings) {
+      obj.blockBindings = message.blockBindings.map((e) =>
+        e ? BlockBinding.toJSON(e) : undefined
+      );
+    } else {
+      obj.blockBindings = [];
+    }
     return obj;
   },
 
-  fromPartial(object: DeepPartial<RawLog>): RawLog {
-    const message = createBaseRawLog();
-    message.raw = object.raw ?? new Uint8Array();
+  fromPartial(object: DeepPartial<ProcessBlocksRequest>): ProcessBlocksRequest {
+    const message = createBaseProcessBlocksRequest();
+    message.blockBindings =
+      object.blockBindings?.map((e) => BlockBinding.fromPartial(e)) || [];
     return message;
   },
 };
 
-function createBaseTraceBinding(): TraceBinding {
-  return { trace: undefined, handlerId: 0 };
+function createBaseProcessBindingsRequest(): ProcessBindingsRequest {
+  return { bindings: [] };
 }
 
-export const TraceBinding = {
+export const ProcessBindingsRequest = {
   encode(
-    message: TraceBinding,
+    message: ProcessBindingsRequest,
     writer: _m0.Writer = _m0.Writer.create()
   ): _m0.Writer {
-    if (message.trace !== undefined) {
-      RawTrace.encode(message.trace, writer.uint32(10).fork()).ldelim();
-    }
-    if (message.handlerId !== 0) {
-      writer.uint32(16).int32(message.handlerId);
+    for (const v of message.bindings) {
+      DataBinding.encode(v!, writer.uint32(10).fork()).ldelim();
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): TraceBinding {
+  decode(
+    input: _m0.Reader | Uint8Array,
+    length?: number
+  ): ProcessBindingsRequest {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseTraceBinding();
+    const message = createBaseProcessBindingsRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.trace = RawTrace.decode(reader, reader.uint32());
-          break;
-        case 2:
-          message.handlerId = reader.int32();
+          message.bindings.push(DataBinding.decode(reader, reader.uint32()));
           break;
         default:
           reader.skipType(tag & 7);
@@ -2200,57 +1960,69 @@ export const TraceBinding = {
     return message;
   },
 
-  fromJSON(object: any): TraceBinding {
+  fromJSON(object: any): ProcessBindingsRequest {
     return {
-      trace: isSet(object.trace) ? RawTrace.fromJSON(object.trace) : undefined,
-      handlerId: isSet(object.handlerId) ? Number(object.handlerId) : 0,
+      bindings: Array.isArray(object?.bindings)
+        ? object.bindings.map((e: any) => DataBinding.fromJSON(e))
+        : [],
     };
   },
 
-  toJSON(message: TraceBinding): unknown {
+  toJSON(message: ProcessBindingsRequest): unknown {
     const obj: any = {};
-    message.trace !== undefined &&
-      (obj.trace = message.trace ? RawTrace.toJSON(message.trace) : undefined);
-    message.handlerId !== undefined &&
-      (obj.handlerId = Math.round(message.handlerId));
+    if (message.bindings) {
+      obj.bindings = message.bindings.map((e) =>
+        e ? DataBinding.toJSON(e) : undefined
+      );
+    } else {
+      obj.bindings = [];
+    }
     return obj;
   },
 
-  fromPartial(object: DeepPartial<TraceBinding>): TraceBinding {
-    const message = createBaseTraceBinding();
-    message.trace =
-      object.trace !== undefined && object.trace !== null
-        ? RawTrace.fromPartial(object.trace)
-        : undefined;
-    message.handlerId = object.handlerId ?? 0;
+  fromPartial(
+    object: DeepPartial<ProcessBindingsRequest>
+  ): ProcessBindingsRequest {
+    const message = createBaseProcessBindingsRequest();
+    message.bindings =
+      object.bindings?.map((e) => DataBinding.fromPartial(e)) || [];
     return message;
   },
 };
 
-function createBaseRawTrace(): RawTrace {
-  return { raw: new Uint8Array() };
+function createBaseProcessBindingResponse(): ProcessBindingResponse {
+  return { result: undefined, configUpdated: false };
 }
 
-export const RawTrace = {
+export const ProcessBindingResponse = {
   encode(
-    message: RawTrace,
+    message: ProcessBindingResponse,
     writer: _m0.Writer = _m0.Writer.create()
   ): _m0.Writer {
-    if (message.raw.length !== 0) {
-      writer.uint32(10).bytes(message.raw);
+    if (message.result !== undefined) {
+      ProcessResult.encode(message.result, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.configUpdated === true) {
+      writer.uint32(32).bool(message.configUpdated);
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): RawTrace {
+  decode(
+    input: _m0.Reader | Uint8Array,
+    length?: number
+  ): ProcessBindingResponse {
     const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseRawTrace();
+    const message = createBaseProcessBindingResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.raw = reader.bytes();
+          message.result = ProcessResult.decode(reader, reader.uint32());
+          break;
+        case 4:
+          message.configUpdated = reader.bool();
           break;
         default:
           reader.skipType(tag & 7);
@@ -2260,24 +2032,37 @@ export const RawTrace = {
     return message;
   },
 
-  fromJSON(object: any): RawTrace {
+  fromJSON(object: any): ProcessBindingResponse {
     return {
-      raw: isSet(object.raw) ? bytesFromBase64(object.raw) : new Uint8Array(),
+      result: isSet(object.result)
+        ? ProcessResult.fromJSON(object.result)
+        : undefined,
+      configUpdated: isSet(object.configUpdated)
+        ? Boolean(object.configUpdated)
+        : false,
     };
   },
 
-  toJSON(message: RawTrace): unknown {
+  toJSON(message: ProcessBindingResponse): unknown {
     const obj: any = {};
-    message.raw !== undefined &&
-      (obj.raw = base64FromBytes(
-        message.raw !== undefined ? message.raw : new Uint8Array()
-      ));
+    message.result !== undefined &&
+      (obj.result = message.result
+        ? ProcessResult.toJSON(message.result)
+        : undefined);
+    message.configUpdated !== undefined &&
+      (obj.configUpdated = message.configUpdated);
     return obj;
   },
 
-  fromPartial(object: DeepPartial<RawTrace>): RawTrace {
-    const message = createBaseRawTrace();
-    message.raw = object.raw ?? new Uint8Array();
+  fromPartial(
+    object: DeepPartial<ProcessBindingResponse>
+  ): ProcessBindingResponse {
+    const message = createBaseProcessBindingResponse();
+    message.result =
+      object.result !== undefined && object.result !== null
+        ? ProcessResult.fromPartial(object.result)
+        : undefined;
+    message.configUpdated = object.configUpdated ?? false;
     return message;
   },
 };
@@ -2464,6 +2249,136 @@ export const Instruction = {
   },
 };
 
+function createBaseData(): Data {
+  return { raw: new Uint8Array() };
+}
+
+export const Data = {
+  encode(message: Data, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.raw.length !== 0) {
+      writer.uint32(10).bytes(message.raw);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Data {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseData();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.raw = reader.bytes();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Data {
+    return {
+      raw: isSet(object.raw) ? bytesFromBase64(object.raw) : new Uint8Array(),
+    };
+  },
+
+  toJSON(message: Data): unknown {
+    const obj: any = {};
+    message.raw !== undefined &&
+      (obj.raw = base64FromBytes(
+        message.raw !== undefined ? message.raw : new Uint8Array()
+      ));
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<Data>): Data {
+    const message = createBaseData();
+    message.raw = object.raw ?? new Uint8Array();
+    return message;
+  },
+};
+
+function createBaseDataBinding(): DataBinding {
+  return { data: undefined, handlerId: 0, handlerType: 0 };
+}
+
+export const DataBinding = {
+  encode(
+    message: DataBinding,
+    writer: _m0.Writer = _m0.Writer.create()
+  ): _m0.Writer {
+    if (message.data !== undefined) {
+      Data.encode(message.data, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.handlerId !== 0) {
+      writer.uint32(16).int32(message.handlerId);
+    }
+    if (message.handlerType !== 0) {
+      writer.uint32(24).int32(message.handlerType);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): DataBinding {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDataBinding();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.data = Data.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.handlerId = reader.int32();
+          break;
+        case 3:
+          message.handlerType = reader.int32() as any;
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): DataBinding {
+    return {
+      data: isSet(object.data) ? Data.fromJSON(object.data) : undefined,
+      handlerId: isSet(object.handlerId) ? Number(object.handlerId) : 0,
+      handlerType: isSet(object.handlerType)
+        ? handlerTypeFromJSON(object.handlerType)
+        : 0,
+    };
+  },
+
+  toJSON(message: DataBinding): unknown {
+    const obj: any = {};
+    message.data !== undefined &&
+      (obj.data = message.data ? Data.toJSON(message.data) : undefined);
+    message.handlerId !== undefined &&
+      (obj.handlerId = Math.round(message.handlerId));
+    message.handlerType !== undefined &&
+      (obj.handlerType = handlerTypeToJSON(message.handlerType));
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<DataBinding>): DataBinding {
+    const message = createBaseDataBinding();
+    message.data =
+      object.data !== undefined && object.data !== null
+        ? Data.fromPartial(object.data)
+        : undefined;
+    message.handlerId = object.handlerId ?? 0;
+    message.handlerType = object.handlerType ?? 0;
+    return message;
+  },
+};
+
 function createBaseBlockBinding(): BlockBinding {
   return { block: undefined, handlerIds: [] };
 }
@@ -3449,7 +3364,14 @@ export const CounterResult = {
 };
 
 function createBaseLogResult(): LogResult {
-  return { metadata: undefined, level: 0, message: "", runtimeInfo: undefined };
+  return {
+    name: "",
+    metadata: undefined,
+    level: 0,
+    message: "",
+    attributes: "",
+    runtimeInfo: undefined,
+  };
 }
 
 export const LogResult = {
@@ -3457,6 +3379,9 @@ export const LogResult = {
     message: LogResult,
     writer: _m0.Writer = _m0.Writer.create()
   ): _m0.Writer {
+    if (message.name !== "") {
+      writer.uint32(42).string(message.name);
+    }
     if (message.metadata !== undefined) {
       RecordMetaData.encode(
         message.metadata,
@@ -3469,6 +3394,9 @@ export const LogResult = {
     if (message.message !== "") {
       writer.uint32(26).string(message.message);
     }
+    if (message.attributes !== "") {
+      writer.uint32(50).string(message.attributes);
+    }
     if (message.runtimeInfo !== undefined) {
       RuntimeInfo.encode(
         message.runtimeInfo,
@@ -3485,6 +3413,9 @@ export const LogResult = {
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
+        case 5:
+          message.name = reader.string();
+          break;
         case 1:
           message.metadata = RecordMetaData.decode(reader, reader.uint32());
           break;
@@ -3494,6 +3425,9 @@ export const LogResult = {
         case 3:
           message.message = reader.string();
           break;
+        case 6:
+          message.attributes = reader.string();
+          break;
         case 4:
           message.runtimeInfo = RuntimeInfo.decode(reader, reader.uint32());
           break;
@@ -3507,11 +3441,13 @@ export const LogResult = {
 
   fromJSON(object: any): LogResult {
     return {
+      name: isSet(object.name) ? String(object.name) : "",
       metadata: isSet(object.metadata)
         ? RecordMetaData.fromJSON(object.metadata)
         : undefined,
       level: isSet(object.level) ? logLevelFromJSON(object.level) : 0,
       message: isSet(object.message) ? String(object.message) : "",
+      attributes: isSet(object.attributes) ? String(object.attributes) : "",
       runtimeInfo: isSet(object.runtimeInfo)
         ? RuntimeInfo.fromJSON(object.runtimeInfo)
         : undefined,
@@ -3520,12 +3456,14 @@ export const LogResult = {
 
   toJSON(message: LogResult): unknown {
     const obj: any = {};
+    message.name !== undefined && (obj.name = message.name);
     message.metadata !== undefined &&
       (obj.metadata = message.metadata
         ? RecordMetaData.toJSON(message.metadata)
         : undefined);
     message.level !== undefined && (obj.level = logLevelToJSON(message.level));
     message.message !== undefined && (obj.message = message.message);
+    message.attributes !== undefined && (obj.attributes = message.attributes);
     message.runtimeInfo !== undefined &&
       (obj.runtimeInfo = message.runtimeInfo
         ? RuntimeInfo.toJSON(message.runtimeInfo)
@@ -3535,12 +3473,14 @@ export const LogResult = {
 
   fromPartial(object: DeepPartial<LogResult>): LogResult {
     const message = createBaseLogResult();
+    message.name = object.name ?? "";
     message.metadata =
       object.metadata !== undefined && object.metadata !== null
         ? RecordMetaData.fromPartial(object.metadata)
         : undefined;
     message.level = object.level ?? 0;
     message.message = object.message ?? "";
+    message.attributes = object.attributes ?? "";
     message.runtimeInfo =
       object.runtimeInfo !== undefined && object.runtimeInfo !== null
         ? RuntimeInfo.fromPartial(object.runtimeInfo)
@@ -3580,17 +3520,17 @@ export const ProcessorDefinition = {
     },
     processLogs: {
       name: "ProcessLogs",
-      requestType: ProcessLogsRequest,
+      requestType: ProcessBindingsRequest,
       requestStream: false,
-      responseType: ProcessLogsResponse,
+      responseType: ProcessBindingResponse,
       responseStream: false,
       options: {},
     },
     processTraces: {
       name: "ProcessTraces",
-      requestType: ProcessTracesRequest,
+      requestType: ProcessBindingsRequest,
       requestStream: false,
-      responseType: ProcessTracesResponse,
+      responseType: ProcessBindingResponse,
       responseStream: false,
       options: {},
     },
@@ -3598,7 +3538,15 @@ export const ProcessorDefinition = {
       name: "ProcessTransactions",
       requestType: ProcessTransactionsRequest,
       requestStream: false,
-      responseType: ProcessTransactionsResponse,
+      responseType: ProcessBindingResponse,
+      responseStream: false,
+      options: {},
+    },
+    processInstructions: {
+      name: "ProcessInstructions",
+      requestType: ProcessInstructionsRequest,
+      requestStream: false,
+      responseType: ProcessBindingResponse,
       responseStream: false,
       options: {},
     },
@@ -3606,15 +3554,15 @@ export const ProcessorDefinition = {
       name: "ProcessBlocks",
       requestType: ProcessBlocksRequest,
       requestStream: false,
-      responseType: ProcessBlocksResponse,
+      responseType: ProcessBindingResponse,
       responseStream: false,
       options: {},
     },
-    processInstructions: {
-      name: "ProcessInstructions",
-      requestType: ProcessInstructionsRequest,
+    processBindings: {
+      name: "ProcessBindings",
+      requestType: ProcessBindingsRequest,
       requestStream: false,
-      responseType: ProcessInstructionsResponse,
+      responseType: ProcessBindingResponse,
       responseStream: false,
       options: {},
     },
@@ -3635,25 +3583,29 @@ export interface ProcessorServiceImplementation<CallContextExt = {}> {
     context: CallContext & CallContextExt
   ): Promise<DeepPartial<ProcessConfigResponse>>;
   processLogs(
-    request: ProcessLogsRequest,
+    request: ProcessBindingsRequest,
     context: CallContext & CallContextExt
-  ): Promise<DeepPartial<ProcessLogsResponse>>;
+  ): Promise<DeepPartial<ProcessBindingResponse>>;
   processTraces(
-    request: ProcessTracesRequest,
+    request: ProcessBindingsRequest,
     context: CallContext & CallContextExt
-  ): Promise<DeepPartial<ProcessTracesResponse>>;
+  ): Promise<DeepPartial<ProcessBindingResponse>>;
   processTransactions(
     request: ProcessTransactionsRequest,
     context: CallContext & CallContextExt
-  ): Promise<DeepPartial<ProcessTransactionsResponse>>;
+  ): Promise<DeepPartial<ProcessBindingResponse>>;
+  processInstructions(
+    request: ProcessInstructionsRequest,
+    context: CallContext & CallContextExt
+  ): Promise<DeepPartial<ProcessBindingResponse>>;
   processBlocks(
     request: ProcessBlocksRequest,
     context: CallContext & CallContextExt
-  ): Promise<DeepPartial<ProcessBlocksResponse>>;
-  processInstructions(
-    request: ProcessInstructionsRequest,
+  ): Promise<DeepPartial<ProcessBindingResponse>>;
+  processBindings(
+    request: ProcessBindingsRequest,
     context: CallContext & CallContextExt
-  ): Promise<DeepPartial<ProcessInstructionsResponse>>;
+  ): Promise<DeepPartial<ProcessBindingResponse>>;
 }
 
 export interface ProcessorClient<CallOptionsExt = {}> {
@@ -3670,25 +3622,29 @@ export interface ProcessorClient<CallOptionsExt = {}> {
     options?: CallOptions & CallOptionsExt
   ): Promise<ProcessConfigResponse>;
   processLogs(
-    request: DeepPartial<ProcessLogsRequest>,
+    request: DeepPartial<ProcessBindingsRequest>,
     options?: CallOptions & CallOptionsExt
-  ): Promise<ProcessLogsResponse>;
+  ): Promise<ProcessBindingResponse>;
   processTraces(
-    request: DeepPartial<ProcessTracesRequest>,
+    request: DeepPartial<ProcessBindingsRequest>,
     options?: CallOptions & CallOptionsExt
-  ): Promise<ProcessTracesResponse>;
+  ): Promise<ProcessBindingResponse>;
   processTransactions(
     request: DeepPartial<ProcessTransactionsRequest>,
     options?: CallOptions & CallOptionsExt
-  ): Promise<ProcessTransactionsResponse>;
+  ): Promise<ProcessBindingResponse>;
+  processInstructions(
+    request: DeepPartial<ProcessInstructionsRequest>,
+    options?: CallOptions & CallOptionsExt
+  ): Promise<ProcessBindingResponse>;
   processBlocks(
     request: DeepPartial<ProcessBlocksRequest>,
     options?: CallOptions & CallOptionsExt
-  ): Promise<ProcessBlocksResponse>;
-  processInstructions(
-    request: DeepPartial<ProcessInstructionsRequest>,
+  ): Promise<ProcessBindingResponse>;
+  processBindings(
+    request: DeepPartial<ProcessBindingsRequest>,
     options?: CallOptions & CallOptionsExt
-  ): Promise<ProcessInstructionsResponse>;
+  ): Promise<ProcessBindingResponse>;
 }
 
 declare var self: any | undefined;