@sentio/sdk 1.19.2 → 1.19.4

package/src/processor-runner.ts

@@ -10,7 +10,7 @@ import path from 'path'
 import fs from 'fs-extra'
 import { ProcessorState } from './processor-state'
 import { load } from './loader'
-import { CompressionAlgorithms } from '@grpc/grpc-js/src/compression-algorithms'
+import { CompressionAlgorithms } from '@grpc/grpc-js/build/src/compression-algorithms'
 
 global.PROCESSOR_STATE = new ProcessorState()
 

package/src/service.ts

@@ -3,28 +3,25 @@ import { CallContext, ServerError, Status } from 'nice-grpc'
 import { APTOS_TESTNET_ID, SOL_MAINMET_ID, SUI_DEVNET_ID } from './utils/chain'
 
 import {
+  AptosCallHandlerConfig,
+  AptosEventHandlerConfig,
   BlockBinding,
   ContractConfig,
+  DataBinding,
   HandlerType,
   LogFilter,
   LogHandlerConfig,
-  ProcessResult,
+  ProcessBindingResponse,
+  ProcessBindingsRequest,
   ProcessBlocksRequest,
-  ProcessBlocksResponse,
   ProcessConfigRequest,
   ProcessConfigResponse,
   ProcessInstructionsRequest,
-  ProcessInstructionsResponse,
-  ProcessLogsRequest,
-  ProcessLogsResponse,
   ProcessorServiceImplementation,
-  ProcessTracesRequest,
-  ProcessTracesResponse,
+  ProcessResult,
   ProcessTransactionsRequest,
-  ProcessTransactionsResponse,
   StartRequest,
   TemplateInstance,
-  TraceBinding,
 } from './gen/processor/protos/processor'
 
 import { Empty } from './gen/google/protobuf/empty'
@@ -40,6 +37,8 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
   private eventHandlers: ((event: Log) => Promise<ProcessResult>)[] = []
   private traceHandlers: ((trace: Trace) => Promise<ProcessResult>)[] = []
   private blockHandlers: ((block: Block) => Promise<ProcessResult>)[] = []
+  private aptosEventHandlers: ((event: any) => Promise<ProcessResult>)[] = []
+  private aptosCallHandlers: ((func: any) => Promise<ProcessResult>)[] = []
 
   // map from chain id to list of processors
   // private blockHandlers = new Map<string, ((block: Block) => Promise<ProcessResult>)[]>()
@@ -98,6 +97,8 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
         startBlock: processor.config.startBlock,
         endBlock: DEFAULT_MAX_BLOCK,
         instructionConfig: undefined,
+        aptosEventConfigs: [],
+        aptosCallConfigs: [],
       }
       if (processor.config.endBlock) {
         contractConfig.endBlock = processor.config.endBlock
@@ -106,6 +107,8 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
       // Step 1. Prepare all the block handlers
       for (const blockHandler of processor.blockHandlers) {
         const handlerId = this.blockHandlers.push(blockHandler) - 1
+        // TODO wrap the block handler into one
+
         contractConfig.blockConfigs.push({
           handlerId: handlerId,
         })
@@ -161,7 +164,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
         processorType: USER_PROCESSOR,
         contract: {
           name: solanaProcessor.contractName,
-          chainId: SOL_MAINMET_ID, // TODO set in processor
+          chainId: SOL_MAINMET_ID,
           address: solanaProcessor.address,
           abi: '',
         },
@@ -175,6 +178,8 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
           parsedInstruction: solanaProcessor.fromParsedInstruction !== null,
           rawDataInstruction: solanaProcessor.decodeInstruction !== null,
         },
+        aptosEventConfigs: [],
+        aptosCallConfigs: [],
       }
       this.contractConfigs.push(contractConfig)
     }
@@ -195,6 +200,8 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
         startBlock: suiProcessor.config.startSeqNumber,
         endBlock: DEFAULT_MAX_BLOCK,
         instructionConfig: undefined,
+        aptosEventConfigs: [],
+        aptosCallConfigs: [],
       }
       this.contractConfigs.push(contractConfig)
     }
@@ -215,6 +222,33 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
         startBlock: aptosProcessor.config.startSeqNumber,
         endBlock: DEFAULT_MAX_BLOCK,
         instructionConfig: undefined,
+        aptosEventConfigs: [],
+        aptosCallConfigs: [],
+      }
+      // 1. Prepare event handlers
+      for (const handler of aptosProcessor.eventHandlers) {
+        const handlerId = this.aptosEventHandlers.push(handler.handler) - 1
+        const eventHandlerConfig: AptosEventHandlerConfig = {
+          filters: handler.filters,
+          handlerId,
+        }
+        contractConfig.aptosEventConfigs.push(eventHandlerConfig)
+      }
+
+      // 2. Prepare function handlers
+      for (const handler of aptosProcessor.callHandlers) {
+        const handlerId = this.aptosCallHandlers.push(handler.handler) - 1
+        const functionHandlerConfig: AptosCallHandlerConfig = {
+          filters: handler.filters.map((filter) => {
+            return {
+              function: filter.function,
+              typeArguments: filter.typeArguments ?? [],
+              withTypeArguments: filter.typeArguments ? true : false,
+            }
+          }),
+          handlerId,
+        }
+        contractConfig.aptosCallConfigs.push(functionHandlerConfig)
       }
       this.contractConfigs.push(contractConfig)
     }
@@ -264,21 +298,55 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     return {}
   }
 
-  async processLogs(request: ProcessLogsRequest, context: CallContext): Promise<ProcessLogsResponse> {
+  async processBindings(request: ProcessBindingsRequest, options?: CallContext): Promise<ProcessBindingResponse> {
+    if (!this.started) {
+      throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')
+    }
+
+    const promises = request.bindings.map((binding) => this.processBinding(binding))
+    const result = mergeProcessResults(await Promise.all(promises))
+
+    let updated = false
+    if (
+      global.PROCESSOR_STATE.templatesInstances &&
+      this.templateInstances.length != global.PROCESSOR_STATE.templatesInstances.length
+    ) {
+      await this.configure()
+      updated = true
+    }
+
+    return {
+      result,
+      configUpdated: updated,
+    }
+  }
+
+  async processBinding(request: DataBinding, options?: CallContext): Promise<ProcessResult> {
+    switch (request.handlerType) {
+      case HandlerType.APT_CALL:
+        return this.processAptosCall(request)
+      case HandlerType.APT_EVENT:
+        return this.processAptosEvent(request)
+      default:
+        throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
+    }
+  }
+
+  async processLogs(request: ProcessBindingsRequest, context: CallContext): Promise<ProcessBindingResponse> {
     if (!this.started) {
       throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')
     }
 
     const promises: Promise<ProcessResult>[] = []
-    for (const l of request.logBindings) {
-      if (!l.log) {
+    for (const l of request.bindings) {
+      if (!l.data) {
         throw new ServerError(Status.INVALID_ARGUMENT, "Log can't be null")
       }
       // const jsonString = Buffer.from(l.log.raw.buffer).toString("utf-8")
       // const jsonString = String.fromCharCode.apply(null, l.log.raw)
 
       try {
-        const jsonString = Utf8ArrayToStr(l.log.raw)
+        const jsonString = Utf8ArrayToStr(l.data.raw)
         const log: Log = JSON.parse(jsonString)
         const handler = this.eventHandlers[l.handlerId]
         const promise = handler(log).catch((e) => {
@@ -302,7 +370,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
       updated = true
     }
 
-    recordRuntimeInfo(result, HandlerType.LOG)
+    recordRuntimeInfo(result, HandlerType.ETH_LOG)
     return {
       result,
       configUpdated: updated,
@@ -312,16 +380,12 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
   async processTransactions(
     request: ProcessTransactionsRequest,
     context: CallContext
-  ): Promise<ProcessTransactionsResponse> {
+  ): Promise<ProcessBindingResponse> {
     if (!this.started) {
       throw new ServerError(Status.UNAVAILABLE, 'Service not started.')
     }
 
-    const result: ProcessResult = {
-      gauges: [],
-      counters: [],
-      logs: [],
-    }
+    const result = ProcessResult.fromPartial({})
 
     if (request.chainId.toLowerCase().startsWith('sui') && global.PROCESSOR_STATE.suiProcessors) {
       const processorPromises: Promise<void>[] = []
@@ -374,22 +438,19 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     recordRuntimeInfo(result, HandlerType.TRANSACTION)
     return {
       result,
+      configUpdated: false,
     }
   }
 
   async processInstructions(
     request: ProcessInstructionsRequest,
     context: CallContext
-  ): Promise<ProcessInstructionsResponse> {
+  ): Promise<ProcessBindingResponse> {
     if (!this.started) {
       throw new ServerError(Status.UNAVAILABLE, 'Service not started.')
     }
 
-    const result: ProcessResult = {
-      gauges: [],
-      counters: [],
-      logs: [],
-    }
+    const result = ProcessResult.fromPartial({})
 
     // Only have instruction handlers for solana processors
     if (global.PROCESSOR_STATE.solanaProcessors) {
@@ -436,10 +497,11 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     recordRuntimeInfo(result, HandlerType.INSTRUCTION)
     return {
       result,
+      configUpdated: false,
     }
   }
 
-  async processBlocks(request: ProcessBlocksRequest, context: CallContext): Promise<ProcessBlocksResponse> {
+  async processBlocks(request: ProcessBlocksRequest, context: CallContext): Promise<ProcessBindingResponse> {
     if (!this.started) {
       throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')
     }
@@ -450,6 +512,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     recordRuntimeInfo(result, HandlerType.BLOCK)
     return {
       result,
+      configUpdated: false,
     }
   }
 
@@ -471,31 +534,60 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     return mergeProcessResults(await Promise.all(promises))
   }
 
-  async processTraces(request: ProcessTracesRequest, context: CallContext): Promise<ProcessTracesResponse> {
+  async processTraces(request: ProcessBindingsRequest, context: CallContext): Promise<ProcessBindingResponse> {
     if (!this.started) {
       throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')
     }
 
-    const promises = request.traceBindings.map((binding) => this.processTrace(binding))
+    const promises = request.bindings.map((binding) => this.processTrace(binding))
     const result = mergeProcessResults(await Promise.all(promises))
 
-    recordRuntimeInfo(result, HandlerType.TRACE)
+    recordRuntimeInfo(result, HandlerType.ETH_TRACE)
     return {
       result,
+      configUpdated: false,
     }
   }
 
-  async processTrace(binding: TraceBinding): Promise<ProcessResult> {
-    if (!binding.trace) {
+  async processTrace(binding: DataBinding): Promise<ProcessResult> {
+    if (!binding.data) {
       throw new ServerError(Status.INVALID_ARGUMENT, "Trace can't be empty")
     }
-    const jsonString = Utf8ArrayToStr(binding.trace.raw)
+    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))
     })
   }
+
+  async processAptosEvent(binding: DataBinding): Promise<ProcessResult> {
+    if (!binding.data) {
+      throw new ServerError(Status.INVALID_ARGUMENT, "Event can't be empty")
+    }
+    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
+  }
+
+  async processAptosCall(binding: DataBinding): Promise<ProcessResult> {
+    if (!binding.data) {
+      throw new ServerError(Status.INVALID_ARGUMENT, "Event can't be empty")
+    }
+    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
+  }
 }
 
 // https://ourcodeworld.com/articles/read/164/how-to-convert-an-uint8array-to-string-in-javascript

package/src/testing/test-processor-server.ts

@@ -1,25 +1,21 @@
 import {
   BlockBinding,
   ContractConfig,
-  LogBinding,
+  DataBinding,
+  HandlerType,
+  ProcessBindingResponse,
+  ProcessBindingsRequest,
   ProcessBlocksRequest,
-  ProcessBlocksResponse,
   ProcessConfigRequest,
   ProcessConfigResponse,
   ProcessInstructionsRequest,
-  ProcessInstructionsResponse,
-  ProcessLogsRequest,
-  ProcessLogsResponse,
   ProcessorServiceImpl,
   ProcessorServiceImplementation,
   ProcessorState,
-  ProcessTracesRequest,
-  ProcessTracesResponse,
   ProcessTransactionsRequest,
-  ProcessTransactionsResponse,
   setProvider,
   StartRequest,
-  TraceBinding,
+  Trace,
 } from '@sentio/sdk'
 import { CallContext } from 'nice-grpc-common'
 import { Empty } from '../gen/google/protobuf/empty'
@@ -28,7 +24,6 @@ import { CHAIN_MAP } from '../utils/chain'
 import { Block, Log } from '@ethersproject/abstract-provider'
 import Long from 'long'
 import { getNetwork, Networkish } from '@ethersproject/providers'
-import { Trace } from '@sentio/sdk'
 
 const TEST_CONTEXT: CallContext = <CallContext>{}
 
@@ -71,37 +66,31 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
     return this.service.getConfig(request, context)
   }
 
-  processBlocks(request: ProcessBlocksRequest, context = TEST_CONTEXT): Promise<ProcessBlocksResponse> {
+  processBlocks(request: ProcessBlocksRequest, context = TEST_CONTEXT): Promise<ProcessBindingResponse> {
     return this.service.processBlocks(request, context)
   }
 
-  processInstructions(
-    request: ProcessInstructionsRequest,
-    context = TEST_CONTEXT
-  ): Promise<ProcessInstructionsResponse> {
+  processInstructions(request: ProcessInstructionsRequest, context = TEST_CONTEXT): Promise<ProcessBindingResponse> {
     return this.service.processInstructions(request, context)
   }
 
-  processLogs(request: ProcessLogsRequest, context = TEST_CONTEXT): Promise<ProcessLogsResponse> {
+  processLogs(request: ProcessBindingsRequest, context = TEST_CONTEXT): Promise<ProcessBindingResponse> {
     return this.service.processLogs(request, context)
   }
 
-  processTraces(request: ProcessTracesRequest, context: CallContext = TEST_CONTEXT): Promise<ProcessTracesResponse> {
+  processTraces(request: ProcessBindingsRequest, context: CallContext = TEST_CONTEXT): Promise<ProcessBindingResponse> {
     return this.service.processTraces(request, context)
   }
 
-  processTransactions(
-    request: ProcessTransactionsRequest,
-    context = TEST_CONTEXT
-  ): Promise<ProcessTransactionsResponse> {
+  processTransactions(request: ProcessTransactionsRequest, context = TEST_CONTEXT): Promise<ProcessBindingResponse> {
     return this.service.processTransactions(request, context)
   }
 
-  testTrace(trace: Trace, network: Networkish = 1): Promise<ProcessTracesResponse> {
+  testTrace(trace: Trace, network: Networkish = 1): Promise<ProcessBindingResponse> {
     return this.testTraces([trace], network)
   }
 
-  testTraces(traces: Trace[], network: Networkish = 1): Promise<ProcessTracesResponse> {
+  testTraces(traces: Trace[], network: Networkish = 1): Promise<ProcessBindingResponse> {
     const bindings = []
     for (const trace of traces) {
       const binding = this.buildTraceBinding(trace, network)
@@ -111,11 +100,11 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
       bindings.push(binding)
     }
     return this.processTraces({
-      traceBindings: bindings,
+      bindings: bindings,
     })
   }
 
-  buildTraceBinding(trace: Trace, network: Networkish = 1): TraceBinding | undefined {
+  buildTraceBinding(trace: Trace, network: Networkish = 1): DataBinding | undefined {
     if (trace.type !== 'call' || !trace.action.input) {
       throw Error('Invalid test trace: ' + JSON.stringify(trace))
     }
@@ -131,10 +120,11 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
       for (const config of contract.traceConfigs) {
         if (config.signature == signature) {
           return {
-            trace: {
+            data: {
               raw: toBytes(trace),
             },
             handlerId: config.handlerId,
+            handlerType: HandlerType.ETH_TRACE,
           }
         }
       }
@@ -142,11 +132,11 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
     return undefined
   }
 
-  testLog(log: Log, network: Networkish = 1): Promise<ProcessLogsResponse> {
+  testLog(log: Log, network: Networkish = 1): Promise<ProcessBindingResponse> {
     return this.testLogs([log], network)
   }
 
-  testLogs(logs: Log[], network: Networkish = 1): Promise<ProcessLogsResponse> {
+  testLogs(logs: Log[], network: Networkish = 1): Promise<ProcessBindingResponse> {
     const bindings = []
     for (const log of logs) {
       const binding = this.buildLogBinding(log, network)
@@ -156,11 +146,11 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
       bindings.push(binding)
     }
     return this.processLogs({
-      logBindings: bindings,
+      bindings: bindings,
     })
   }
 
-  buildLogBinding(log: Log, network: Networkish = 1): LogBinding | undefined {
+  buildLogBinding(log: Log, network: Networkish = 1): DataBinding | undefined {
     for (const contract of this.contractConfig) {
       if (contract.contract?.chainId !== getNetwork(network).chainId.toString()) {
         continue
@@ -191,10 +181,11 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
           }
           if (match) {
             return {
-              log: {
+              data: {
                 raw: toBytes(log),
               },
               handlerId: config.handlerId,
+              handlerType: HandlerType.ETH_LOG,
             }
           }
         }
@@ -203,7 +194,7 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
     return undefined
   }
 
-  testBlock(block: Partial<Block> & { number: number }, network: Networkish = 1): Promise<ProcessBlocksResponse> {
+  testBlock(block: Partial<Block> & { number: number }, network: Networkish = 1): Promise<ProcessBindingResponse> {
     return this.testBlocks([block], network)
   }
 
@@ -246,6 +237,10 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
     }
     return binding
   }
+
+  processBindings(request: ProcessBindingsRequest, context: CallContext): Promise<ProcessBindingResponse> {
+    return this.service.processBindings(request, context)
+  }
 }
 
 function toBytes(obj: any): Uint8Array {

package/src/tests/erc20.test.ts

@@ -57,7 +57,7 @@ describe('Test Basic Examples', () => {
     expect(firstCounterValue(res.result, 'c1')).equals(1n)
 
     expect(counters?.[0].metadata?.chainId).equals('1')
-    expect(counters?.[0].runtimeInfo?.from).equals(HandlerType.LOG)
+    expect(counters?.[0].runtimeInfo?.from).equals(HandlerType.ETH_LOG)
     expect(res.configUpdated).equals(true)
 
     const logData2 = Object.assign({}, logData)

package/src/tests/logger.test.ts

@@ -41,6 +41,6 @@ describe('Test Error Capture', () => {
     )
     const log = res.result?.logs?.[0]
     expect(log?.message).eq('transferred 0')
-    expect(log?.metadata?.labels['from'].toLowerCase()).eq('0x80009ff8154bd5653c6dda2fa5f5053e5a5c1a91')
+    expect(JSON.parse(log?.attributes || '')['from'].toLowerCase()).eq('0x80009ff8154bd5653c6dda2fa5f5053e5a5c1a91')
   })
 })

package/src/utils/erc20.test.ts

@@ -1,7 +1,4 @@
-import { ProcessorState, DummyProvider } from '@sentio/sdk'
-
-console.log(DummyProvider)
-
+import { ProcessorState } from '@sentio/sdk'
 import { getERC20TokenInfo } from './token'
 import { loadTestProvidersFromEnv } from '../testing/test-provider'