@sentio/sdk 1.30.3 → 1.31.0

package/src/service.ts

@@ -41,6 +41,7 @@ import {
   AptosProcessorState,
   MoveResourcesWithVersionPayload,
 } from './aptos/aptos-processor'
+import { AccountProcessorState } from './core/account-processor'
 ;(BigInt.prototype as any).toJSON = function () {
   return this.toString()
 }
@@ -131,7 +132,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
       })
     }
 
-    // Part 1, prepare EVM processors
+    // Part 1.a, prepare EVM processors
     for (const processor of global.PROCESSOR_STATE.processors) {
       // If server favor incremental update this need to change
       // Start basic config for contract
@@ -195,6 +196,8 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
             throw new ServerError(Status.INVALID_ARGUMENT, 'Topic should not be null')
           }
           const logFilter: LogFilter = {
+            addressType: undefined,
+            address: contractConfig.contract?.address,
             topics: [],
           }
 
@@ -216,6 +219,52 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
       this.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)
+      }
+
+      this.accountConfigs.push(accountConfig)
+    }
+
     // Part 2, prepare solana constractors
     for (const solanaProcessor of global.PROCESSOR_STATE.solanaProcessors) {
       const contractConfig: ContractConfig = {
@@ -327,6 +376,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
         startBlock: Long.fromValue(aptosProcessor.config.startVersion.toString()),
         aptosIntervalConfigs: [],
         intervalConfigs: [],
+        logConfigs: [],
       }
       for (const handler of aptosProcessor.resourcesHandlers) {
         const handlerId = this.aptosResourceHandlers.push(handler.handler) - 1
@@ -418,6 +468,8 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
         return this.processAptosEvent(request)
       case HandlerType.APT_RESOURCE:
         return this.processAptosResource(request)
+      case HandlerType.ETH_LOG:
+        return this.processLog(request)
       default:
         throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
     }
@@ -430,24 +482,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
 
     const promises: Promise<ProcessResult>[] = []
     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.data.raw)
-        const log: Log = JSON.parse(jsonString)
-        const handler = this.eventHandlers[l.handlerId]
-        const promise = handler(log).catch((e) => {
-          throw new ServerError(Status.INTERNAL, 'error processing log: ' + jsonString + '\n' + errorString(e))
-        })
-
-        promises.push(promise)
-      } catch (e) {
-        throw new ServerError(Status.INTERNAL, 'error parse log: ' + l)
-      }
+      promises.push(this.processLog(l))
     }
 
     const result = mergeProcessResults(await Promise.all(promises))
@@ -468,6 +503,23 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     }
   }
 
+  async processLog(l: DataBinding): Promise<ProcessResult> {
+    if (!l.data) {
+      throw new ServerError(Status.INVALID_ARGUMENT, "Log can't be null")
+    }
+
+    try {
+      const jsonString = Utf8ArrayToStr(l.data.raw)
+      const log: Log = JSON.parse(jsonString)
+      const handler = this.eventHandlers[l.handlerId]
+      return handler(log).catch((e) => {
+        throw new ServerError(Status.INTERNAL, 'error processing log: ' + jsonString + '\n' + errorString(e))
+      })
+    } catch (e) {
+      throw new ServerError(Status.INTERNAL, 'error parse log: ' + l)
+    }
+  }
+
   async processTransactions(
     request: ProcessTransactionsRequest,
     context: CallContext
@@ -501,31 +553,6 @@ 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)
-    // }
-
     recordRuntimeInfo(result, HandlerType.TRANSACTION)
     return {
       result,

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

@@ -1,4 +1,5 @@
 import {
+  AccountConfig,
   BlockBinding,
   ContractConfig,
   DataBinding,
@@ -25,6 +26,7 @@ import { ProcessorState } from '../state/processor-state'
 import { ProcessorServiceImpl } from '../service'
 import { Trace } from '../core/trace'
 import { setProvider } from '../provider'
+import { account } from '../builtin/aptos/0x1'
 
 export const TEST_CONTEXT: CallContext = <CallContext>{}
 
@@ -37,7 +39,8 @@ export function cleanTest() {
 
 export class TestProcessorServer implements ProcessorServiceImplementation {
   service: ProcessorServiceImpl
-  contractConfig: ContractConfig[]
+  contractConfigs: ContractConfig[]
+  accountConfigs: AccountConfig[]
 
   constructor(loader: () => void, httpEndpoints: Record<string, string> = {}) {
     cleanTest()
@@ -58,7 +61,9 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
 
   async start(request: StartRequest = { templateInstances: [] }, context = TEST_CONTEXT): Promise<Empty> {
     const res = await this.service.start(request, context)
-    this.contractConfig = (await this.getConfig({})).contractConfigs
+    const config = await this.getConfig({})
+    this.contractConfigs = config.contractConfigs
+    this.accountConfigs = config.accountConfigs
     return res
   }
 
@@ -114,7 +119,7 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
     }
     const signature = trace.action.input.slice(0, 10)
 
-    for (const contract of this.contractConfig) {
+    for (const contract of this.contractConfigs) {
       if (contract.contract?.chainId !== getNetwork(network).chainId.toString()) {
         continue
       }
@@ -155,7 +160,7 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
   }
 
   buildLogBinding(log: Log, network: Networkish = 1): DataBinding | undefined {
-    for (const contract of this.contractConfig) {
+    for (const contract of this.contractConfigs) {
       if (contract.contract?.chainId !== getNetwork(network).chainId.toString()) {
         continue
       }
@@ -197,6 +202,67 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
     }
     return undefined
   }
+  testAccountLog(address: string, log: Log, network: Networkish = 1): Promise<ProcessBindingResponse> {
+    return this.testAccountLogs(address, [log], network)
+  }
+
+  testAccountLogs(address: string, logs: Log[], network: Networkish = 1): Promise<ProcessBindingResponse> {
+    const bindings = []
+    for (const log of logs) {
+      const binding = this.buildAccountLogBinding(address, log, network)
+      if (!binding) {
+        throw Error('Invalid test log: ' + JSON.stringify(log))
+      }
+      bindings.push(binding)
+    }
+    return this.processLogs({
+      bindings: bindings,
+    })
+  }
+
+  buildAccountLogBinding(address: string, log: Log, network: Networkish = 1): DataBinding | undefined {
+    for (const account of this.accountConfigs) {
+      if (account.chainId !== getNetwork(network).chainId.toString()) {
+        continue
+      }
+      if (address.toLowerCase() !== account.address.toLowerCase()) {
+        continue
+      }
+      for (const config of account.logConfigs) {
+        for (const filter of config.filters) {
+          // if (filter.topics.length != log.topics.length) {
+          //   continue
+          // }
+
+          let match = true
+          for (const topicIdx in filter.topics) {
+            const logTopic = log.topics[topicIdx]
+            const possibleTopic = filter.topics[topicIdx].hashes
+            if (possibleTopic.length === 0) {
+              // match all
+              continue
+            }
+            if (possibleTopic.find((e) => e.toLowerCase() === logTopic.toLowerCase())) {
+              // find one
+              continue
+            }
+            match = false
+            break
+          }
+          if (match) {
+            return {
+              data: {
+                raw: toBytes(log),
+              },
+              handlerId: config.handlerId,
+              handlerType: HandlerType.ETH_LOG,
+            }
+          }
+        }
+      }
+    }
+    return undefined
+  }
 
   testBlock(block: Partial<Block> & { number: number }, network: Networkish = 1): Promise<ProcessBindingResponse> {
     return this.testBlocks([block], network)
@@ -223,7 +289,7 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
       },
       handlerIds: [],
     }
-    for (const contract of this.contractConfig) {
+    for (const contract of this.contractConfigs) {
       if (contract.contract?.chainId !== getNetwork(network).chainId.toString()) {
         continue
       }