@sentio/sdk 1.36.3-rc.1 → 1.36.4-rc.1

package/src/core/eth-plugin.ts

@@ -0,0 +1,255 @@
+import { Plugin, PluginManager } from '../plugin'
+import {
+  AccountConfig,
+  ContractConfig,
+  DataBinding,
+  HandlerType,
+  LogFilter,
+  LogHandlerConfig,
+  ProcessConfigResponse,
+  ProcessResult,
+} from '../gen/processor/protos/processor'
+import { DEFAULT_MAX_BLOCK, errorString, mergeProcessResults, USER_PROCESSOR, Utf8ArrayToStr } from '../service'
+
+import { ServerError, Status } from 'nice-grpc'
+import { Block, Log } from '@ethersproject/abstract-provider'
+import { Trace } from '@sentio/sdk'
+import { ProcessorState } from '../binds'
+import { AccountProcessorState } from './account-processor'
+import Long from 'long'
+
+export class EthPlugin implements Plugin {
+  name: string = 'EthPlugin'
+
+  private eventHandlers: ((event: Log) => Promise<ProcessResult>)[] = []
+  private traceHandlers: ((trace: Trace) => Promise<ProcessResult>)[] = []
+  private blockHandlers: ((block: Block) => Promise<ProcessResult>)[] = []
+
+  configure(config: ProcessConfigResponse): void {
+    for (const processor of ProcessorState.INSTANCE.getValues()) {
+      // If server favor incremental update this need to change
+      // Start basic config for contract
+      const chainId = processor.getChainId()
+      // this.processorsByChainId.set(chainId, processor)
+
+      const contractConfig: ContractConfig = {
+        processorType: USER_PROCESSOR,
+        contract: {
+          name: processor.config.name,
+          chainId: chainId.toString(),
+          address: processor.config.address,
+          abi: '',
+        },
+        intervalConfigs: [],
+        logConfigs: [],
+        traceConfigs: [],
+        startBlock: processor.config.startBlock,
+        endBlock: DEFAULT_MAX_BLOCK,
+        instructionConfig: undefined,
+        aptosEventConfigs: [],
+        aptosCallConfigs: [],
+      }
+      if (processor.config.endBlock) {
+        contractConfig.endBlock = processor.config.endBlock
+      }
+
+      // Step 1. Prepare all the block handlers
+      for (const blockHandler of processor.blockHandlers) {
+        const handlerId = this.blockHandlers.push(blockHandler.handler) - 1
+        // TODO wrap the block handler into one
+
+        contractConfig.intervalConfigs.push({
+          slot: 0,
+          slotInterval: blockHandler.blockInterval,
+          minutes: 0,
+          minutesInterval: blockHandler.timeIntervalInMinutes,
+          handlerId: handlerId,
+        })
+      }
+
+      // Step 2. Prepare all trace handlers
+      for (const traceHandler of processor.traceHandlers) {
+        const handlerId = this.traceHandlers.push(traceHandler.handler) - 1
+        contractConfig.traceConfigs.push({
+          signature: traceHandler.signature,
+          handlerId: handlerId,
+        })
+      }
+
+      // Step 3. Prepare all the event handlers
+      for (const eventsHandler of processor.eventHandlers) {
+        // associate id with filter
+        const handlerId = this.eventHandlers.push(eventsHandler.handler) - 1
+        const logConfig: LogHandlerConfig = {
+          handlerId: handlerId,
+          filters: [],
+        }
+
+        for (const filter of eventsHandler.filters) {
+          if (!filter.topics) {
+            throw new ServerError(Status.INVALID_ARGUMENT, 'Topic should not be null')
+          }
+          const logFilter: LogFilter = {
+            addressType: undefined,
+            address: contractConfig.contract?.address,
+            topics: [],
+          }
+
+          for (const ts of filter.topics) {
+            let hashes: string[] = []
+            if (Array.isArray(ts)) {
+              hashes = hashes.concat(ts)
+            } else if (ts) {
+              hashes.push(ts)
+            }
+            logFilter.topics.push({ hashes: hashes })
+          }
+          logConfig.filters.push(logFilter)
+        }
+        contractConfig.logConfigs.push(logConfig)
+      }
+
+      // Finish up a contract
+      config.contractConfigs.push(contractConfig)
+    }
+
+    // part 1.b prepare EVM account processors
+    for (const processor of AccountProcessorState.INSTANCE.getValues()) {
+      const accountConfig: AccountConfig = {
+        address: processor.config.address,
+        chainId: processor.getChainId().toString(),
+        startBlock: processor.config.startBlock ? Long.fromValue(processor.config.startBlock) : Long.ZERO,
+        aptosIntervalConfigs: [],
+        intervalConfigs: [],
+        logConfigs: [],
+      }
+      // TODO add interval
+      for (const eventsHandler of processor.eventHandlers) {
+        // associate id with filter
+        const handlerId = this.eventHandlers.push(eventsHandler.handler) - 1
+        const logConfig: LogHandlerConfig = {
+          handlerId: handlerId,
+          filters: [],
+        }
+
+        for (const filter of eventsHandler.filters) {
+          if (!filter.topics) {
+            throw new ServerError(Status.INVALID_ARGUMENT, 'Topic should not be null')
+          }
+          const logFilter: LogFilter = {
+            addressType: filter.addressType,
+            address: filter.address,
+            topics: [],
+          }
+
+          for (const ts of filter.topics) {
+            let hashes: string[] = []
+            if (Array.isArray(ts)) {
+              hashes = hashes.concat(ts)
+            } else if (ts) {
+              hashes.push(ts)
+            }
+            logFilter.topics.push({ hashes: hashes })
+          }
+          logConfig.filters.push(logFilter)
+        }
+        accountConfig.logConfigs.push(logConfig)
+      }
+
+      config.accountConfigs.push(accountConfig)
+    }
+  }
+
+  supportedHandlers = [HandlerType.ETH_LOG, HandlerType.ETH_BLOCK, HandlerType.ETH_TRACE]
+
+  processBinding(request: DataBinding): Promise<ProcessResult> {
+    // return Promise.resolve(undefined);
+    switch (request.handlerType) {
+      case HandlerType.ETH_LOG:
+        return this.processLog(request)
+      case HandlerType.ETH_TRACE:
+        return this.processTrace(request)
+      case HandlerType.ETH_BLOCK:
+        return this.processBlock(request)
+      default:
+        throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
+    }
+  }
+
+  async processLog(request: DataBinding): Promise<ProcessResult> {
+    if (!request.data) {
+      throw new ServerError(Status.INVALID_ARGUMENT, "Log can't be null")
+    }
+
+    const promises: Promise<ProcessResult>[] = []
+    let log: Log
+    if (request.data.ethLog) {
+      log = request.data.ethLog.log as Log
+    } else {
+      const jsonString = Utf8ArrayToStr(request.data.raw)
+      log = JSON.parse(jsonString)
+    }
+
+    for (const handlerId of request.handlerIds) {
+      const handler = this.eventHandlers[handlerId]
+      promises.push(
+        handler(log).catch((e) => {
+          throw new ServerError(Status.INTERNAL, 'error processing log: ' + JSON.stringify(log) + '\n' + errorString(e))
+        })
+      )
+    }
+    return mergeProcessResults(await Promise.all(promises))
+  }
+
+  async processTrace(binding: DataBinding): Promise<ProcessResult> {
+    if (!binding.data) {
+      throw new ServerError(Status.INVALID_ARGUMENT, "Trace can't be empty")
+    }
+    let trace: Trace
+    if (binding.data.ethTrace?.trace) {
+      trace = binding.data.ethTrace.trace as Trace
+    } else {
+      const jsonString = Utf8ArrayToStr(binding.data.raw)
+      trace = JSON.parse(jsonString)
+    }
+
+    const promises: Promise<ProcessResult>[] = []
+
+    for (const handlerId of binding.handlerIds) {
+      promises.push(
+        this.traceHandlers[handlerId](trace).catch((e) => {
+          throw new ServerError(
+            Status.INTERNAL,
+            'error processing trace: ' + JSON.stringify(trace) + '\n' + errorString(e)
+          )
+        })
+      )
+    }
+    return mergeProcessResults(await Promise.all(promises))
+  }
+
+  async processBlock(binding: DataBinding): Promise<ProcessResult> {
+    if (!binding.data) {
+      throw new ServerError(Status.INVALID_ARGUMENT, "Block can't be empty")
+    }
+    let block: Block
+    if (binding.data.ethBlock?.block) {
+      block = binding.data.ethBlock.block as Block
+    } else {
+      const jsonString = Utf8ArrayToStr(binding.data.raw)
+      block = JSON.parse(jsonString)
+    }
+
+    const promises: Promise<ProcessResult>[] = []
+    for (const handlerId of binding.handlerIds) {
+      promises.push(
+        this.blockHandlers[handlerId](block).catch((e) => {
+          throw new ServerError(Status.INTERNAL, 'error processing block: ' + block.number + '\n' + errorString(e))
+        })
+      )
+    }
+    return mergeProcessResults(await Promise.all(promises))
+  }
+}
+
+PluginManager.INSTANCE.register(new EthPlugin())

package/src/core/index.ts

@@ -16,3 +16,7 @@ export { SolanaBindOptions } from './solana-options'
 export { SolanaBaseProcessor } from './solana-processor'
 
 export type { TypedCallTrace, Trace } from './trace'
+
+export { EthPlugin } from './eth-plugin'
+export { SolanaPlugin } from './solana-plugin'
+export { SuiPlugin } from './sui-plugin'

package/src/core/solana-plugin.ts

@@ -0,0 +1,97 @@
+import { Plugin, PluginManager } from '../plugin'
+import {
+  ContractConfig,
+  Data_SolInstruction,
+  DataBinding,
+  HandlerType,
+  ProcessConfigResponse,
+  ProcessResult,
+} from '../gen/processor/protos/processor'
+import { DEFAULT_MAX_BLOCK, errorString, mergeProcessResults, USER_PROCESSOR, Utf8ArrayToStr } from '../service'
+
+import { ServerError, Status } from 'nice-grpc'
+
+import { SolanaProcessorState } from './solana-processor'
+import { Instruction as SolInstruction } from '@project-serum/anchor/dist/cjs/coder/borsh/instruction'
+
+export class SolanaPlugin implements Plugin {
+  name: string = 'SolanaPlugin'
+
+  configure(config: ProcessConfigResponse): void {
+    // Part 2, prepare solana constractors
+    for (const solanaProcessor of SolanaProcessorState.INSTANCE.getValues()) {
+      const contractConfig: ContractConfig = {
+        processorType: USER_PROCESSOR,
+        contract: {
+          name: solanaProcessor.contractName,
+          chainId: solanaProcessor.network,
+          address: solanaProcessor.address,
+          abi: '',
+        },
+        logConfigs: [],
+        traceConfigs: [],
+        intervalConfigs: [],
+        startBlock: solanaProcessor.config.startSlot,
+        endBlock: DEFAULT_MAX_BLOCK,
+        instructionConfig: {
+          innerInstruction: solanaProcessor.processInnerInstruction,
+          parsedInstruction: solanaProcessor.fromParsedInstruction !== null,
+          rawDataInstruction: solanaProcessor.decodeInstruction !== null,
+        },
+        aptosEventConfigs: [],
+        aptosCallConfigs: [],
+      }
+      config.contractConfigs.push(contractConfig)
+    }
+  }
+
+  supportedHandlers = [HandlerType.SOL_INSTRUCTION]
+
+  processBinding(request: DataBinding): Promise<ProcessResult> {
+    switch (request.handlerType) {
+      case HandlerType.SOL_INSTRUCTION:
+        return this.processSolInstruction(request)
+      default:
+        throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
+    }
+  }
+
+  async processSolInstruction(request: DataBinding): Promise<ProcessResult> {
+    if (!request.data) {
+      throw new ServerError(Status.INVALID_ARGUMENT, 'instruction data cannot be empty')
+    }
+
+    const instruction = request.data.solInstruction || Data_SolInstruction.decode(request.data.raw) // JSON.parse(jsonString)
+    const promises: Promise<ProcessResult>[] = []
+
+    // Only have instruction handlers for solana processors
+    for (const processor of SolanaProcessorState.INSTANCE.getValues()) {
+      if (processor.address === instruction.programAccountId) {
+        let parsedInstruction: SolInstruction | null = null
+        if (instruction.parsed) {
+          parsedInstruction = processor.getParsedInstruction(instruction.parsed as { type: string; info: any })
+        } else if (instruction.instructionData) {
+          parsedInstruction = processor.getParsedInstruction(instruction.instructionData)
+        }
+        if (parsedInstruction == null) {
+          continue
+        }
+        const insHandler = processor.getInstructionHandler(parsedInstruction)
+        if (insHandler == null) {
+          continue
+        }
+        const res = await processor.handleInstruction(
+          parsedInstruction,
+          instruction.accounts,
+          insHandler,
+          instruction.slot
+        )
+
+        promises.push(Promise.resolve(res))
+      }
+    }
+    return mergeProcessResults(await Promise.all(promises))
+  }
+}
+
+PluginManager.INSTANCE.register(new SolanaPlugin())

package/src/core/sui-plugin.ts

@@ -0,0 +1,54 @@
+import { Plugin, PluginManager } from '../plugin'
+import {
+  ContractConfig,
+  DataBinding,
+  HandlerType,
+  ProcessConfigResponse,
+  ProcessResult,
+} from '../gen/processor/protos/processor'
+import { DEFAULT_MAX_BLOCK, USER_PROCESSOR } from '../service'
+
+import { ServerError, Status } from 'nice-grpc'
+
+import { CHAIN_IDS } from '../utils/chain'
+import { SuiProcessorState } from './sui-processor'
+
+export class SuiPlugin implements Plugin {
+  name: string = 'SolanaPlugin'
+
+  configure(config: ProcessConfigResponse): void {
+    for (const suiProcessor of SuiProcessorState.INSTANCE.getValues()) {
+      const contractConfig: ContractConfig = {
+        processorType: USER_PROCESSOR,
+        contract: {
+          name: 'sui contract',
+          chainId: CHAIN_IDS.SUI_DEVNET,
+          address: suiProcessor.address,
+          abi: '',
+        },
+        logConfigs: [],
+        intervalConfigs: [],
+        traceConfigs: [],
+        startBlock: suiProcessor.config.startSeqNumber,
+        endBlock: DEFAULT_MAX_BLOCK,
+        instructionConfig: undefined,
+        aptosEventConfigs: [],
+        aptosCallConfigs: [],
+      }
+      config.contractConfigs.push(contractConfig)
+    }
+  }
+
+  supportedHandlers = [HandlerType.SUI_TRANSACTION]
+
+  processBinding(request: DataBinding): Promise<ProcessResult> {
+    switch (request.handlerType) {
+      case HandlerType.SUI_TRANSACTION:
+      // return this.processSolInstruction(request)
+      default:
+        throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
+    }
+  }
+}
+
+PluginManager.INSTANCE.register(new SuiPlugin())

package/src/gen/index.ts

@@ -1 +1,3 @@
-export * from '../gen/processor/protos/processor'
+export * from './builtin'
+
+export * from './processor/protos/processor'

package/src/plugin.ts

@@ -0,0 +1,41 @@
+import { DataBinding, HandlerType, ProcessConfigResponse, ProcessResult } from './gen'
+
+export interface Plugin {
+  name: string
+  supportedHandlers: HandlerType[]
+
+  configure(config: ProcessConfigResponse): void
+  processBinding(request: DataBinding): Promise<ProcessResult>
+}
+
+export class PluginManager {
+  static INSTANCE = new PluginManager()
+
+  plugins: Plugin[] = []
+  typesToPlugin = new Map<HandlerType, Plugin>()
+
+  register(plugin: Plugin) {
+    this.plugins.push(plugin)
+    // for (const plugin of this.plugins) {
+    for (const handlerType of plugin.supportedHandlers) {
+      const exsited = this.typesToPlugin.get(handlerType)
+      if (exsited) {
+        throw new Error(`Duplicate plugin for ${handlerType}: ${exsited.name} and ${plugin.name}`)
+      }
+      this.typesToPlugin.set(handlerType, plugin)
+    }
+    // }
+  }
+
+  configure(config: ProcessConfigResponse) {
+    this.plugins.forEach((plugin) => plugin.configure(config))
+  }
+
+  processBinding(request: DataBinding): Promise<ProcessResult> {
+    const plugin = this.typesToPlugin.get(request.handlerType)
+    if (!plugin) {
+      throw new Error(`No plugin for ${request.handlerType}`)
+    }
+    return plugin.processBinding(request)
+  }
+}