@sentio/sdk 4.0.0-rc.1 → 4.0.0-rc.3

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

@@ -1,31 +1,35 @@
 import {
-  AccountConfig,
-  ContractConfig,
-  DataBinding,
-  DeepPartial,
-  Empty,
-  PreprocessStreamRequest,
-  PreprocessStreamResponse,
-  ProcessBindingResponse,
-  ProcessBindingsRequest,
-  ProcessConfigRequest,
-  ProcessConfigResponse,
-  ProcessorServiceImplementation,
-  ProcessStreamRequest,
-  ProcessStreamResponse,
-  ServerStreamingMethodResult,
-  StartRequest,
-  TemplateInstance,
-  TimeseriesResult
+  type AccountConfig,
+  type ContractConfig,
+  type DataBinding,
+  type DBResponse,
+  type Empty,
+  EmptySchema,
+  type ProcessBindingResponse,
+  ProcessBindingResponseSchema,
+  ProcessBindingsRequestSchema,
+  ProcessConfigRequestSchema,
+  type ProcessConfigResponse,
+  type ProcessResult,
+  type ProcessStreamRequest,
+  ProcessStreamRequestSchema,
+  ProcessStreamResponseV3Schema,
+  StartRequestSchema,
+  type TemplateInstance,
+  TemplateInstanceSchema,
+  type TimeseriesResult,
+  UpdateTemplatesRequestSchema
 } from '@sentio/protos'
-import { CallContext } from 'nice-grpc-common'
+import { create, type MessageInitShape } from '@bufbuild/protobuf'
+import { type HandlerContext } from '@connectrpc/connect'
 import {
+  DataBindingContext,
   Endpoints,
   IDataBindingContext,
+  mergeProcessResults,
   PluginManager,
-  ProcessorServiceImpl,
   State,
-  StoreContext
+  ProcessorServiceImplV3
 } from '@sentio/runtime'
 
 import { AptosFacet } from './aptos-facet.js'
@@ -40,7 +44,9 @@ import { DatabaseSchemaState } from '../core/database-schema.js'
 import { IotaFacet } from './iota-facet.js'
 import { ChainInfo } from '@sentio/chain'
 
-export const TEST_CONTEXT: CallContext = <CallContext>{}
+type ProcessStreamResponseV3Init = MessageInitShape<typeof ProcessStreamResponseV3Schema>
+
+export const TEST_CONTEXT = {} as HandlerContext
 
 export function cleanTest() {
   // retain the DatabaseSchemaState
@@ -49,11 +55,12 @@ export function cleanTest() {
   State.INSTANCE.stateMap.set(DatabaseSchemaState.INSTANCE.key(), state)
 }
 
-export class TestProcessorServer implements ProcessorServiceImplementation {
-  service: ProcessorServiceImpl
+export class TestProcessorServer {
+  service: ProcessorServiceImplV3
   contractConfigs: ContractConfig[]
   accountConfigs: AccountConfig[]
   storeContext: TestStoreContext
+  private nextProcessId = 1
 
   aptos: AptosFacet
   eth: EthFacet
@@ -67,7 +74,7 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
   constructor(loader: () => Promise<any>, httpEndpoints: Record<string, string> = {}) {
     cleanTest()
 
-    this.service = new ProcessorServiceImpl(loader)
+    this.service = new ProcessorServiceImplV3(loader)
     this.aptos = new AptosFacet(this)
     this.solana = new SolanaFacet(this)
     this.eth = new EthFacet(this)
@@ -82,79 +89,137 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
     }
 
     // start a memory database for testing
-    const subject = new Subject<DeepPartial<ProcessStreamResponse>>()
-    this.storeContext = new TestStoreContext(subject, 1)
+    const subject = new Subject<ProcessStreamResponseV3Init>()
+    this.storeContext = new TestStoreContext(subject, 1, this.service)
     this._db = new MemoryDatabase(this.storeContext)
   }
 
-  async start(request: StartRequest = { templateInstances: [] }, context = TEST_CONTEXT): Promise<Empty> {
-    const res = await this.service.start(request, context)
-    const config = await this.getConfig({})
+  async start(
+    request: MessageInitShape<typeof StartRequestSchema> = { templateInstances: [] },
+    context = TEST_CONTEXT
+  ) {
+    const req = create(StartRequestSchema, request)
+    const res = await this.service.start(req, context)
+    const config = await this.getConfig(create(ProcessConfigRequestSchema, {}))
     this.contractConfigs = config.contractConfigs
     this.accountConfigs = config.accountConfigs
     this._db.start()
-    this.storeContext.templateInstances = request.templateInstances
+    this.storeContext.templateInstances = req.templateInstances
     return res
   }
 
-  stop(request: Empty, context = TEST_CONTEXT): Promise<Empty> {
-    return this.service.stop(request, context)
+  stop(request: Empty = create(EmptySchema), context = TEST_CONTEXT) {
+    this._db.stop()
+    return request
   }
 
-  async getConfig(request: ProcessConfigRequest, context = TEST_CONTEXT): Promise<ProcessConfigResponse> {
-    const config = await this.service.getConfig(request, context)
-    return {
-      ...config,
-      templateInstances: this.storeContext.templateInstances
-    }
+  async getConfig(
+    request: MessageInitShape<typeof ProcessConfigRequestSchema> = {},
+    context = TEST_CONTEXT
+  ): Promise<ProcessConfigResponse> {
+    const config = await this.service.getConfig(create(ProcessConfigRequestSchema, request), context)
+    config.templateInstances = this.storeContext.templateInstances
+    return config
   }
 
   processBindings(
-    request: ProcessBindingsRequest,
-    context: CallContext = TEST_CONTEXT
+    request: MessageInitShape<typeof ProcessBindingsRequestSchema>,
+    context: HandlerContext = TEST_CONTEXT
   ): Promise<ProcessBindingResponse> {
-    return PluginManager.INSTANCE.dbContextLocalStorage.run(this.storeContext, async () => {
-      const ret = await this.service.processBindings(request, context)
-      if (ret.result?.states?.configUpdated) {
-        // template may changed
-        await PluginManager.INSTANCE.updateTemplates({
-          chainId: request.bindings[0].chainId,
-          templateInstances: this.storeContext.templateInstances
-        })
+    const req = create(ProcessBindingsRequestSchema, request)
+    return this.processBindingList(req.bindings, context)
+  }
+
+  async processBinding(request: DataBinding, context: HandlerContext = TEST_CONTEXT): Promise<ProcessBindingResponse> {
+    return this.processBindingList([request], context)
+  }
+
+  private async processBindingList(
+    bindings: DataBinding[],
+    context: HandlerContext = TEST_CONTEXT
+  ): Promise<ProcessBindingResponse> {
+    const results: ProcessResult[] = []
+    for (const binding of bindings) {
+      const result = await this.processBindingV3(binding, context)
+      results.push(result)
+
+      if (result.states?.configUpdated) {
+        await PluginManager.INSTANCE.updateTemplates(
+          create(UpdateTemplatesRequestSchema, {
+            chainId: binding.chainId,
+            templateInstances: this.storeContext.templateInstances
+          })
+        )
       }
-      return ret
+    }
+    return create(ProcessBindingResponseSchema, {
+      result: mergeProcessResults(results)
     })
   }
 
-  async processBinding(request: DataBinding, context: CallContext = TEST_CONTEXT): Promise<ProcessBindingResponse> {
-    const ret = await PluginManager.INSTANCE.dbContextLocalStorage.run(this.storeContext, () => {
-      return this.service.processBindings({ bindings: [request] }, context)
-    })
-    if (ret.result?.states?.configUpdated) {
-      // template may changed
-      await PluginManager.INSTANCE.updateTemplates({
-        chainId: request.chainId,
-        templateInstances: this.storeContext.templateInstances
+  private processBindingV3(request: DataBinding, context: HandlerContext): Promise<ProcessResult> {
+    const processId = this.nextProcessId++
+    const subject = this.storeContext.subject
+
+    return new Promise((resolve, reject) => {
+      const subscription = subject.subscribe({
+        next: (response) => {
+          if (response.processId !== processId) {
+            return
+          }
+          if (response.value?.case === 'tplRequest') {
+            this.storeContext.applyTemplateRequest(
+              (response.value.value.templates ?? []).map((template) => create(TemplateInstanceSchema, template)),
+              response.value.value.remove ?? false
+            )
+          }
+          if (response.value?.case === 'result') {
+            subscription.unsubscribe()
+            // The service always emits a fully-formed ProcessResult message here; use it directly.
+            // Do NOT re-`create(ProcessResultSchema, ...)` — that re-validates every field and throws
+            // on results carrying loosely-typed values (e.g. a hex string in an int32 field), which
+            // the old unary processBindings path passed through untouched.
+            const result = response.value.value as ProcessResult
+            // The V3 service reports handler failures as a result with `states.error` set (via
+            // DataBindingContext.error) rather than erroring the stream. Surface it as a thrown
+            // error so tests observe the same behavior as the old unary processBindings path.
+            if (result.states?.error) {
+              reject(new Error(result.states.error))
+            } else {
+              resolve(result)
+            }
+          }
+        },
+        error: (e) => {
+          subscription.unsubscribe()
+          reject(e)
+        }
       })
-    }
-    return ret
-  }
 
-  processBindingsStream(
-    requests: AsyncIterable<ProcessStreamRequest>,
-    context: CallContext
-  ): ServerStreamingMethodResult<DeepPartial<ProcessStreamResponse>> {
-    throw new Error('Method not implemented.')
+      this.service
+        .handleRequest(
+          create(ProcessStreamRequestSchema, {
+            processId,
+            value: {
+              case: 'binding',
+              value: request
+            }
+          }),
+          undefined,
+          subject
+        )
+        .catch((e) => {
+          subscription.unsubscribe()
+          reject(e)
+        })
+    })
   }
 
-  preprocessBindingsStream(
-    requests: AsyncIterable<PreprocessStreamRequest>,
-    context: CallContext
-  ): ServerStreamingMethodResult<DeepPartial<PreprocessStreamResponse>> {
-    throw new Error('Method not implemented.')
+  processBindingsStream(requests: AsyncIterable<ProcessStreamRequest>, context: HandlerContext) {
+    return this.service.processBindingsStream(requests, context)
   }
 
-  // processBindingsStream(request: AsyncIterable<ProcessStreamRequest>, context: CallContext) {
+  // processBindingsStream(request: AsyncIterable<ProcessStreamRequest>, context: HandlerContext) {
   //   return this.service.processBindingsStream(request, context)
   // }
   get db() {
@@ -166,17 +231,37 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
   }
 }
 
-class TestStoreContext extends StoreContext implements IDataBindingContext {
+class TestStoreContext extends DataBindingContext implements IDataBindingContext {
   constructor(
-    readonly subject: Subject<DeepPartial<ProcessStreamResponse>>,
-    processId: number
+    subject: Subject<ProcessStreamResponseV3Init>,
+    processId: number,
+    private readonly service: ProcessorServiceImplV3
   ) {
-    super(subject, processId)
+    super(processId, subject)
   }
 
   templateInstances: TemplateInstance[] = []
 
-  sendTemplateRequest(templates: Array<TemplateInstance>, remove: boolean): void {
+  result(dbResult: DBResponse, processId = this.processId): void {
+    // Resolve a request issued directly from this context (e.g. `service.store.get(...)` in a test,
+    // which goes through the TestStoreContext rather than a per-binding context). opIds are globally
+    // unique, so this is a no-op when the request originated from the service's per-binding context.
+    super.result(dbResult)
+    // Forward to the service's per-binding context for requests issued while processing a binding.
+    void this.service.handleRequest(
+      create(ProcessStreamRequestSchema, {
+        processId,
+        value: {
+          case: 'dbResult',
+          value: dbResult
+        }
+      }),
+      undefined,
+      this.subject
+    )
+  }
+
+  applyTemplateRequest(templates: Array<TemplateInstance>, remove: boolean): void {
     if (remove) {
       this.templateInstances = this.templateInstances.filter(
         (i) => !templates.find((t) => t.templateId === i.templateId && t.contract?.address === i.contract?.address)
@@ -185,7 +270,12 @@ class TestStoreContext extends StoreContext implements IDataBindingContext {
       this.templateInstances.push(...templates)
     }
   }
+
+  sendTemplateRequest(templates: Array<TemplateInstance>, remove: boolean): void {
+    this.applyTemplateRequest(templates, remove)
+  }
+
   sendTimeseriesRequest(timeseries: Array<TimeseriesResult>): void {
-    throw new Error('Method not implemented.')
+    // Test helpers currently expose metric/event/export results through ProcessResult.
   }
 }

package/src/utils/price.ts

@@ -1,4 +1,5 @@
-import { CoinID } from '@sentio/protos'
+import { type CoinID, CoinIDSchema } from '@sentio/protos'
+import { create } from '@bufbuild/protobuf'
 import { Endpoints, processMetrics } from '@sentio/runtime'
 import { ChainId } from '@sentio/chain'
 import { LRUCache } from 'lru-cache'
@@ -56,11 +57,14 @@ export async function getPriceByTypeOrSymbolInternal(
   const dateStr = dateString(date)
   const todayDateString = dateString(new Date())
 
+  const symbol = coinId.id.case === 'symbol' ? coinId.id.value : undefined
+  const address = coinId.id.case === 'address' ? coinId.id.value : undefined
+
   let key: string
-  if (coinId.symbol) {
-    key = `${coinId.symbol}-${dateStr}`
+  if (symbol) {
+    key = `${symbol}-${dateStr}`
   } else {
-    key = `${coinId.address?.address}-${coinId.address?.chain}-${dateStr}`
+    key = `${address?.address}-${address?.chain}-${dateStr}`
   }
   let price = priceMap.get(key)
   if (price) {
@@ -71,9 +75,9 @@ export async function getPriceByTypeOrSymbolInternal(
   const response = priceClient.getPrice({
     query: {
       timestamp: date.toISOString(),
-      'coinId.symbol': coinId.symbol,
-      'coinId.address.address': coinId.address?.address,
-      'coinId.address.chain': coinId.address?.chain
+      'coinId.symbol': symbol,
+      'coinId.address.address': address?.address,
+      'coinId.address.chain': address?.chain
     }
   })
   price = response
@@ -131,12 +135,15 @@ export async function getPriceByType(
 ): Promise<number | undefined> {
   return getPriceByTypeOrSymbol(
     date,
-    {
-      address: {
-        chain: chainId,
-        address: coinType
+    create(CoinIDSchema, {
+      id: {
+        case: 'address',
+        value: {
+          chain: chainId,
+          address: coinType
+        }
       }
-    },
+    }),
     options
   )
 }
@@ -151,7 +158,7 @@ export async function getPriceBySymbol(
   date: Date,
   options?: PriceOptions
 ): Promise<number | undefined> {
-  return getPriceByTypeOrSymbol(date, { symbol }, options)
+  return getPriceByTypeOrSymbol(date, create(CoinIDSchema, { id: { case: 'symbol', value: symbol } }), options)
 }
 
 function dateString(date: Date) {