@sentio/sdk 1.19.3 → 1.19.5

package/src/index.ts

@@ -7,5 +7,8 @@ export { EthersError } from './error'
 
 export { getProcessor, addProcessor, getContractByABI, addContractByABI, getContractName } from './binds'
 
-export * from './gen/processor/protos/processor'
+export * from './gen'
+
 export * from './core'
+
+export * as aptos from './aptos'

package/src/processor-state.ts

@@ -5,8 +5,10 @@ import {
   BaseProcessorTemplate,
   SolanaBaseProcessor,
   SuiBaseProcessor,
-  AptosBaseProcessor,
 } from './core'
+
+import { AptosBaseProcessor } from './aptos'
+
 import { BaseContract } from 'ethers'
 import { TemplateInstance } from './gen/processor/protos/processor'
 import { Provider } from '@ethersproject/providers'

package/src/service.ts

@@ -3,29 +3,26 @@ 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'
+} from './gen'
 
 import { Empty } from './gen/google/protobuf/empty'
 import Long from 'long'
@@ -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)
     }
@@ -206,15 +213,42 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
         contract: {
           name: aptosProcessor.name,
           chainId: APTOS_TESTNET_ID,
-          address: aptosProcessor.address,
+          address: aptosProcessor.config.address,
           abi: '',
         },
         blockConfigs: [],
         logConfigs: [],
         traceConfigs: [],
-        startBlock: aptosProcessor.config.startSeqNumber,
+        startBlock: aptosProcessor.config.startVersion,
         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.processAptosFunctionCall(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>[] = []
@@ -346,50 +410,47 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
       await Promise.all(processorPromises)
     }
 
-    if (request.chainId.toLowerCase().startsWith('apt') && global.PROCESSOR_STATE.aptosProcessors) {
-      const processorPromises: Promise<void>[] = []
-      for (const txn of request.transactions) {
-        processorPromises.push(
-          new Promise((resolve, _) => {
-            for (const processor of global.PROCESSOR_STATE.aptosProcessors) {
-              if (processor.address === txn.programAccountId!) {
-                const res = processor.handleTransaction(
-                  JSON.parse(new TextDecoder().decode(txn.raw)),
-                  txn.slot ?? Long.fromNumber(0)
-                )
-                if (res) {
-                  res.gauges.forEach((g) => result.gauges.push(g))
-                  res.counters.forEach((c) => result.counters.push(c))
-                  res.logs.forEach((l) => result.logs.push(l))
-                }
-              }
-            }
-            resolve()
-          })
-        )
-      }
-      await Promise.all(processorPromises)
-    }
+    // if (request.chainId.toLowerCase().startsWith('apt') && global.PROCESSOR_STATE.aptosProcessors) {
+    //   const processorPromises: Promise<void>[] = []
+    //   for (const txn of request.transactions) {
+    //     processorPromises.push(
+    //       new Promise((resolve, _) => {
+    //         for (const processor of global.PROCESSOR_STATE.aptosProcessors) {
+    //           if (processor.address === txn.programAccountId!) {
+    //             const res = processor.handleTransaction(
+    //               JSON.parse(new TextDecoder().decode(txn.raw)),
+    //               txn.slot ?? Long.fromNumber(0)
+    //             )
+    //             if (res) {
+    //               res.gauges.forEach((g) => result.gauges.push(g))
+    //               res.counters.forEach((c) => result.counters.push(c))
+    //               res.logs.forEach((l) => result.logs.push(l))
+    //             }
+    //           }
+    //         }
+    //         resolve()
+    //       })
+    //     )
+    //   }
+    //   await Promise.all(processorPromises)
+    // }
 
     recordRuntimeInfo(result, HandlerType.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 processAptosFunctionCall(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/metric-utils.ts

@@ -1,6 +1,6 @@
 import { DeepPartial } from '../gen/builtin'
-import { BigDecimal, MetricValue, ProcessResult } from '@sentio/sdk'
-import { Numberish } from '../core'
+import { MetricValue, ProcessResult } from '../gen'
+import { Numberish, BigDecimal } from '../core'
 import { BigNumber } from 'ethers'
 
 export function MetricValueToNumber(v: DeepPartial<MetricValue> | undefined): Numberish | undefined {

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,9 +24,8 @@ 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>{}
+export const TEST_CONTEXT: CallContext = <CallContext>{}
 
 function cleanTest() {
   global.PROCESSOR_STATE = new ProcessorState()
@@ -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,13 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
     }
     return binding
   }
+
+  processBindings(
+    request: ProcessBindingsRequest,
+    context: CallContext = TEST_CONTEXT
+  ): Promise<ProcessBindingResponse> {
+    return this.service.processBindings(request, context)
+  }
 }
 
 function toBytes(obj: any): Uint8Array {

package/src/testing/test-provider.ts

@@ -1,6 +1,6 @@
 import { ChainConfig } from '../chain-config'
 import { CHAIN_MAP } from '../utils/chain'
-import { setProvider } from '@sentio/sdk'
+import { setProvider } from '../provider'
 
 export function loadTestProvidersFromEnv(requiredChainIds: string[] | string): boolean {
   const dummyConfig: Record<string, ChainConfig> = {}