@sentio/sdk 3.9.0-rc.9 → 4.0.0-rc.2

package/src/testing/solana-facet.ts

@@ -1,5 +1,6 @@
 import { TestProcessorServer } from './test-processor-server.js'
-import { Data_SolInstruction, HandlerType, ProcessBindingResponse } from '@sentio/protos'
+import { Data_SolInstructionSchema, DataBindingSchema, HandlerType, type ProcessBindingResponse } from '@sentio/protos'
+import { create, type MessageInitShape } from '@bufbuild/protobuf'
 import { ChainId } from '@sentio/chain'
 
 export class SolanaFacet {
@@ -9,18 +10,22 @@ export class SolanaFacet {
     this.server = server
   }
 
-  testInstructions(instructions: Data_SolInstruction[]): Promise<ProcessBindingResponse> {
+  testInstructions(
+    instructions: MessageInitShape<typeof Data_SolInstructionSchema>[]
+  ): Promise<ProcessBindingResponse> {
     return this.server.processBindings({
       bindings: instructions.map((instruction) => {
-        return {
+        return create(DataBindingSchema, {
           data: {
-            raw: new Uint8Array(),
-            solInstruction: instruction
+            value: {
+              case: 'solInstruction',
+              value: instruction
+            }
           },
           handlerIds: [],
           handlerType: HandlerType.SOL_INSTRUCTION,
           chainId: ChainId.SOLANA_MAINNET
-        }
+        })
       })
     })
   }

package/src/testing/sui-facet.ts

@@ -1,5 +1,6 @@
 import type { GrpcTypes } from '@mysten/sui/grpc'
-import { DataBinding, HandlerType } from '@sentio/protos'
+import { type DataBinding, DataBindingSchema, HandlerType, timestampNow } from '@sentio/protos'
+import { create } from '@bufbuild/protobuf'
 import { TestProcessorServer } from './test-processor-server.js'
 import { accountTypeString, parseMoveType, SPLITTER } from '../move/index.js'
 import { SuiNetwork } from '../sui/index.js'
@@ -47,18 +48,21 @@ export class SuiFacet {
         for (const callConfig of config.moveCallConfigs) {
           for (const callFilter of callConfig.filters) {
             if (accountTypeString(config.contract.address) + '::' + callFilter.function === functionType) {
-              return {
+              return create(DataBindingSchema, {
                 data: {
-                  suiCall: {
-                    rawTransaction: JSON.stringify(transaction),
-                    timestamp: new Date(),
-                    slot: 10000n
+                  value: {
+                    case: 'suiCall',
+                    value: {
+                      rawTransaction: JSON.stringify(transaction),
+                      timestamp: timestampNow(),
+                      slot: 10000n
+                    }
                   }
                 },
                 handlerIds: [callConfig.handlerId],
                 handlerType: HandlerType.SUI_CALL,
                 chainId: network
-              }
+              })
             }
           }
         }
@@ -91,18 +95,21 @@ export class SuiFacet {
       throw Error('Invalid test global transaction: ' + JSON.stringify(transaction))
     }
 
-    const binding: DataBinding = {
+    const binding: DataBinding = create(DataBindingSchema, {
       handlerIds,
       handlerType: HandlerType.SUI_CALL,
       data: {
-        suiCall: {
-          rawTransaction: JSON.stringify(transaction),
-          timestamp: new Date(),
-          slot: BigInt(transaction.checkpoint || 0)
+        value: {
+          case: 'suiCall',
+          value: {
+            rawTransaction: JSON.stringify(transaction),
+            timestamp: timestampNow(),
+            slot: BigInt(transaction.checkpoint || 0)
+          }
         }
       },
       chainId: network
-    }
+    })
     return this.server.processBinding(binding)
   }
 
@@ -123,19 +130,22 @@ export class SuiFacet {
               accountTypeString(config.contract.address) + '::' + eventFilter.type ===
               parseMoveType(event.eventType ?? '').qname
             ) {
-              return {
+              return create(DataBindingSchema, {
                 data: {
-                  suiEvent: {
-                    rawEvent: JSON.stringify(event),
-                    rawTransaction: JSON.stringify(transaction),
-                    timestamp: new Date(),
-                    slot: 10000n
+                  value: {
+                    case: 'suiEvent',
+                    value: {
+                      rawEvent: JSON.stringify(event),
+                      rawTransaction: JSON.stringify(transaction),
+                      timestamp: timestampNow(),
+                      slot: 10000n
+                    }
                   }
                 },
                 handlerIds: [eventConfig.handlerId],
                 handlerType: HandlerType.SUI_EVENT,
                 chainId: network
-              }
+              })
             }
           }
         }

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

@@ -1,24 +1,24 @@
 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 Empty,
+  EmptySchema,
+  type PreprocessStreamRequest,
+  type ProcessBindingResponse,
+  ProcessBindingResponseSchema,
+  ProcessBindingsRequestSchema,
+  ProcessConfigRequestSchema,
+  type ProcessConfigResponse,
+  type ProcessStreamRequest,
+  ProcessStreamResponseSchema,
+  StartRequestSchema,
+  type TemplateInstance,
+  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 {
   Endpoints,
   IDataBindingContext,
@@ -40,7 +40,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 ProcessStreamResponseInit = MessageInitShape<typeof ProcessStreamResponseSchema>
+
+export const TEST_CONTEXT = {} as HandlerContext
 
 export function cleanTest() {
   // retain the DatabaseSchemaState
@@ -49,7 +51,7 @@ export function cleanTest() {
   State.INSTANCE.stateMap.set(DatabaseSchemaState.INSTANCE.key(), state)
 }
 
-export class TestProcessorServer implements ProcessorServiceImplementation {
+export class TestProcessorServer {
   service: ProcessorServiceImpl
   contractConfigs: ContractConfig[]
   accountConfigs: AccountConfig[]
@@ -82,79 +84,83 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
     }
 
     // start a memory database for testing
-    const subject = new Subject<DeepPartial<ProcessStreamResponse>>()
+    const subject = new Subject<ProcessStreamResponseInit>()
     this.storeContext = new TestStoreContext(subject, 1)
     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> {
+  stop(request: Empty = create(EmptySchema), context = TEST_CONTEXT) {
     return this.service.stop(request, context)
   }
 
-  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> {
+    const req = create(ProcessBindingsRequestSchema, request)
     return PluginManager.INSTANCE.dbContextLocalStorage.run(this.storeContext, async () => {
-      const ret = await this.service.processBindings(request, context)
+      const ret = await this.service.processBindings(req, context)
       if (ret.result?.states?.configUpdated) {
         // template may changed
-        await PluginManager.INSTANCE.updateTemplates({
-          chainId: request.bindings[0].chainId,
-          templateInstances: this.storeContext.templateInstances
-        })
+        await PluginManager.INSTANCE.updateTemplates(
+          create(UpdateTemplatesRequestSchema, {
+            chainId: req.bindings[0].chainId,
+            templateInstances: this.storeContext.templateInstances
+          })
+        )
       }
-      return ret
+      return create(ProcessBindingResponseSchema, ret)
     })
   }
 
-  async processBinding(request: DataBinding, context: CallContext = TEST_CONTEXT): Promise<ProcessBindingResponse> {
+  async processBinding(request: DataBinding, context: HandlerContext = TEST_CONTEXT): Promise<ProcessBindingResponse> {
     const ret = await PluginManager.INSTANCE.dbContextLocalStorage.run(this.storeContext, () => {
-      return this.service.processBindings({ bindings: [request] }, context)
+      return this.service.processBindings(create(ProcessBindingsRequestSchema, { bindings: [request] }), context)
     })
     if (ret.result?.states?.configUpdated) {
       // template may changed
-      await PluginManager.INSTANCE.updateTemplates({
-        chainId: request.chainId,
-        templateInstances: this.storeContext.templateInstances
-      })
+      await PluginManager.INSTANCE.updateTemplates(
+        create(UpdateTemplatesRequestSchema, {
+          chainId: request.chainId,
+          templateInstances: this.storeContext.templateInstances
+        })
+      )
     }
-    return ret
+    return create(ProcessBindingResponseSchema, ret)
   }
 
-  processBindingsStream(
-    requests: AsyncIterable<ProcessStreamRequest>,
-    context: CallContext
-  ): ServerStreamingMethodResult<DeepPartial<ProcessStreamResponse>> {
+  processBindingsStream(requests: AsyncIterable<ProcessStreamRequest>, context: HandlerContext): never {
     throw new Error('Method not implemented.')
   }
 
-  preprocessBindingsStream(
-    requests: AsyncIterable<PreprocessStreamRequest>,
-    context: CallContext
-  ): ServerStreamingMethodResult<DeepPartial<PreprocessStreamResponse>> {
+  preprocessBindingsStream(requests: AsyncIterable<PreprocessStreamRequest>, context: HandlerContext): never {
     throw new Error('Method not implemented.')
   }
 
-  // processBindingsStream(request: AsyncIterable<ProcessStreamRequest>, context: CallContext) {
+  // processBindingsStream(request: AsyncIterable<ProcessStreamRequest>, context: HandlerContext) {
   //   return this.service.processBindingsStream(request, context)
   // }
   get db() {
@@ -168,7 +174,7 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
 
 class TestStoreContext extends StoreContext implements IDataBindingContext {
   constructor(
-    readonly subject: Subject<DeepPartial<ProcessStreamResponse>>,
+    readonly subject: Subject<ProcessStreamResponseInit>,
     processId: number
   ) {
     super(subject, processId)

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) {