@sentio/sdk 1.25.3 → 1.26.1

package/src/service.ts

@@ -3,12 +3,14 @@ import { CallContext, ServerError, Status } from 'nice-grpc'
 import { SOL_MAINMET_ID, SUI_DEVNET_ID } from './utils/chain'
 
 import {
+  AccountConfig,
   AptosCallHandlerConfig,
   AptosEventHandlerConfig,
   BlockBinding,
   ContractConfig,
   DataBinding,
   EventTrackingConfig,
+  ExportConfig,
   HandlerType,
   LogFilter,
   LogHandlerConfig,
@@ -31,6 +33,7 @@ import Long from 'long'
 import { TextDecoder } from 'util'
 import { Trace } from './core'
 import { Instruction } from '@project-serum/anchor'
+import { MoveResourcesWithVersionPayload } from './aptos/aptos-processor'
 
 const DEFAULT_MAX_BLOCK = Long.ZERO
 
@@ -42,6 +45,8 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
   private blockHandlers: ((block: Block) => Promise<ProcessResult>)[] = []
   private aptosEventHandlers: ((event: any) => Promise<ProcessResult>)[] = []
   private aptosCallHandlers: ((func: any) => Promise<ProcessResult>)[] = []
+  private aptosResourceHandlers: ((resourceWithVersion: MoveResourcesWithVersionPayload) => Promise<ProcessResult>)[] =
+    []
 
   // map from chain id to list of processors
   // private blockHandlers = new Map<string, ((block: Block) => Promise<ProcessResult>)[]>()
@@ -49,9 +54,11 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
 
   private started = false
   private contractConfigs: ContractConfig[]
+  private accountConfigs: AccountConfig[]
   private templateInstances: TemplateInstance[]
   private metricConfigs: MetricConfig[]
   private eventTrackingConfigs: EventTrackingConfig[]
+  private exportConfigs: ExportConfig[]
   private readonly loader: () => void
 
   private readonly shutdownHandler?: () => void
@@ -69,10 +76,11 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
       // TODO project setting
       config: undefined,
       contractConfigs: this.contractConfigs,
+      accountConfigs: this.accountConfigs,
       templateInstances: this.templateInstances,
       eventTrackingConfigs: this.eventTrackingConfigs,
       metricConfigs: this.metricConfigs,
-      accountConfigs: [],
+      exportConfigs: this.exportConfigs,
     }
   }
 
@@ -81,10 +89,12 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     this.templateInstances = []
     // this.processorsByChainId.clear()
     this.contractConfigs = []
+    this.accountConfigs = []
 
     this.templateInstances = [...global.PROCESSOR_STATE.templatesInstances]
     this.eventTrackingConfigs = []
     this.metricConfigs = []
+    this.exportConfigs = []
 
     // part 0, prepare metrics and event tracking configs
     for (const metric of global.PROCESSOR_STATE.metrics) {
@@ -104,6 +114,14 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
       })
     }
 
+    for (const exporter of global.PROCESSOR_STATE.exporters) {
+      this.exportConfigs.push({
+        exportName: exporter.exportName,
+        exportType: exporter.options.exportType,
+        exportUrl: exporter.options.exportUrl,
+      })
+    }
+
     // Part 1, prepare EVM processors
     for (const processor of global.PROCESSOR_STATE.processors) {
       // If server favor incremental update this need to change
@@ -247,7 +265,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
         blockConfigs: [],
         logConfigs: [],
         traceConfigs: [],
-        startBlock: aptosProcessor.config.startVersion,
+        startBlock: Long.fromString(aptosProcessor.config.startVersion.toString()),
         endBlock: DEFAULT_MAX_BLOCK,
         instructionConfig: undefined,
         aptosEventConfigs: [],
@@ -286,6 +304,28 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
       }
       this.contractConfigs.push(contractConfig)
     }
+
+    for (const aptosProcessor of global.PROCESSOR_STATE.aptosAccountProcessors) {
+      const accountConfig: AccountConfig = {
+        address: aptosProcessor.config.address,
+        chainId: aptosProcessor.getChainId(),
+        startBlock: Long.fromValue(aptosProcessor.config.startVersion.toString()),
+        onAptosIntervalConfigs: [],
+        onIntervalConfigs: [],
+      }
+      for (const handler of aptosProcessor.resourcesHandlers) {
+        const handlerId = this.aptosResourceHandlers.push(handler.handler) - 1
+        accountConfig.onAptosIntervalConfigs.push({
+          intervalConfig: {
+            handlerId: handlerId,
+            minutes: handler.timeIntervalInMinutes || 0,
+            slot: handler.versionInterval || 0,
+          },
+          type: handler.type || '',
+        })
+      }
+      this.accountConfigs.push(accountConfig)
+    }
   }
 
   async start(request: StartRequest, context: CallContext): Promise<Empty> {
@@ -361,6 +401,8 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
         return this.processAptosFunctionCall(request)
       case HandlerType.APT_EVENT:
         return this.processAptosEvent(request)
+      case HandlerType.APT_RESOURCE:
+        return this.processAptosResource(request)
       default:
         throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
     }
@@ -613,6 +655,19 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     return result
   }
 
+  async processAptosResource(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 json = JSON.parse(jsonString) as MoveResourcesWithVersionPayload
+    const result = await this.aptosResourceHandlers[binding.handlerId](json).catch((e) => {
+      throw new ServerError(Status.INTERNAL, 'error processing event: ' + jsonString + '\n' + errorString(e))
+    })
+    recordRuntimeInfo(result, HandlerType.APT_RESOURCE)
+    return result
+  }
+
   async processAptosFunctionCall(binding: DataBinding): Promise<ProcessResult> {
     if (!binding.data) {
       throw new ServerError(Status.INVALID_ARGUMENT, "Event can't be empty")
@@ -677,28 +732,19 @@ function mergeProcessResults(results: ProcessResult[]): ProcessResult {
     res.gauges = res.gauges.concat(r.gauges)
     res.logs = res.logs.concat(r.logs)
     res.events = res.events.concat(r.events)
+    res.exports = res.exports.concat(r.exports)
   }
   return res
 }
 
 function recordRuntimeInfo(results: ProcessResult, handlerType: HandlerType) {
-  results.gauges.forEach((e) => {
-    e.runtimeInfo = {
-      from: handlerType,
-    }
-  })
-
-  results.counters.forEach((e) => {
-    e.runtimeInfo = {
-      from: handlerType,
-    }
-  })
-
-  results.logs.forEach((e) => {
-    e.runtimeInfo = {
-      from: handlerType,
-    }
-  })
+  for (const list of [results.gauges, results.counters, results.logs, results.events, results.exports]) {
+    list.forEach((e) => {
+      e.runtimeInfo = {
+        from: handlerType,
+      }
+    })
+  }
 }
 
 function errorString(e: Error): string {

package/src/tests/aptos.test.ts

@@ -115,6 +115,34 @@ describe('Test Aptos Example', () => {
     const res = await service.processBindings(request)
     expect(firstGaugeValue(res.result, 'size')).equal(2n)
   })
+
+  test('check on timer', async () => {
+    const request: ProcessBindingsRequest = {
+      bindings: [
+        {
+          data: {
+            raw: new TextEncoder().encode(
+              JSON.stringify({
+                version: '12345',
+                resources: [
+                  {
+                    type: '0x1::coin::SupplyConfig',
+                    data: {
+                      allow_upgrades: false,
+                    },
+                  },
+                ],
+              })
+            ),
+          },
+          handlerId: 0,
+          handlerType: HandlerType.APT_RESOURCE,
+        },
+      ],
+    }
+    const res = await service.processBindings(request)
+    expect(firstCounterValue(res.result, 'onTimer')).equal(1n)
+  })
 })
 
 const testData = {

package/src/tests/erc20.ts

@@ -1,5 +1,7 @@
 import { ERC20Processor, ERC20ProcessorTemplate } from '../builtin/erc20'
 import { EventTracker } from '../core/event-tracker'
+import { Exporter } from '../core/exporter'
+import { ExportConfig_ExportType } from '@sentio/sdk'
 
 export const filter = ERC20Processor.filters.Transfer(
   '0x0000000000000000000000000000000000000000',
@@ -7,6 +9,10 @@ export const filter = ERC20Processor.filters.Transfer(
 )
 
 const tracker = EventTracker.register('sdf')
+const exporter = Exporter.register('transfer', {
+  exportType: ExportConfig_ExportType.WEBHOOK,
+  exportUrl: 'http://localhost',
+})
 
 const processorTemplate = new ERC20ProcessorTemplate().onEventTransfer(async function (event, ctx) {
   console.log('')
@@ -34,6 +40,7 @@ ERC20Processor.bind({ address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', net
   .onEventTransfer(async function (event, ctx) {
     ctx.meter.Counter('c2').add(2)
     tracker.trackEvent(ctx, { distinctId: event.args.from })
+    exporter.emit(ctx, event)
   }, filter)
   .onBlock(async function (block, ctx) {
     ctx.meter.Gauge('g2').record(20, { k: 'v' })

package/src/tests/souffl3.ts

@@ -3,10 +3,11 @@ import { token } from '../builtin/aptos/0x3'
 import { voting } from '../builtin/aptos/0x1'
 import { TYPE_REGISTRY } from '../aptos/types'
 import { AccountEventTracker } from '@sentio/sdk'
+import { AptosAccountProcessor } from '../aptos/aptos-processor'
 
 const accountTracker = AccountEventTracker.register('pull')
 
-SouffleChefCampaign.bind({ startVersion: 3212312 })
+SouffleChefCampaign.bind({ startVersion: 3212312n })
   .onEntryPullTokenV2((call: SouffleChefCampaign.PullTokenV2Payload, ctx) => {
     ctx.meter.Counter('call_num').add(1)
     ctx.meter.Counter('pulled').add(call.arguments_typed[3])
@@ -45,3 +46,7 @@ voting.bind().onEventCreateProposalEvent((evt, ctx) => {
   evt.data_typed.expiration_secs + evt.data_typed.expiration_secs
   ctx.meter.Gauge('size').record(evt.data_typed.metadata.data.length)
 })
+
+AptosAccountProcessor.bind({ address: '0x1' }).onTimeInterval((resources, ctx) => {
+  ctx.meter.Counter('onTimer').add(1)
+}, 10000)