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

package/src/testing/memory-database.ts

@@ -1,31 +1,43 @@
 import { StoreContext } from '../store/context.js'
 import {
-  DBRequest,
-  DBRequest_DBFilter,
+  type DBRequest,
+  type DBRequest_DBFilter,
   DBRequest_DBOperator,
-  ProcessStreamResponse,
-  RichStruct,
-  RichValue,
-  RichValueList
+  type DBResponse,
+  DBResponseSchema,
+  type ProcessStreamResponseV3,
+  type RichStruct,
+  type RichValue,
+  RichValueSchema,
+  type RichValueList,
+  RichValueListSchema,
+  timestampNow
 } from '@sentio/protos'
+import { create } from '@bufbuild/protobuf'
 import { GraphQLField, GraphQLSchema, parse, StringValueNode } from 'graphql/index.js'
 import { DatabaseSchemaState } from '../core/database-schema.js'
 import { buildSchema } from '../store/schema.js'
 import { GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLOutputType } from 'graphql'
-import { PluginManager } from '@sentio/runtime'
+import { type IStoreContext, PluginManager } from '@sentio/runtime'
 import { BigDecimalConverter, BigIntConverter } from '../store/convert.js'
 import { BigDecimal } from '@sentio/bigdecimal'
 import { Store } from '../store/store.js'
+import { Subject } from 'rxjs'
 
 // Internal entity name used by MemoryCache - bypasses schema validation
 const MEMORY_CACHE_ITEM_ENTITY = 'MemoryCacheItem'
 
+type MemoryDatabaseContext = IStoreContext & {
+  subject: Subject<any>
+  result(dbResult: DBResponse, processId?: number): void
+}
+
 export class MemoryDatabase {
   db = new Map<string, Record<string, any>>()
   public lastDbRequest: DBRequest | undefined
   _schema: GraphQLSchema
 
-  constructor(readonly dbContext: StoreContext) {}
+  constructor(readonly dbContext: MemoryDatabaseContext) {}
 
   get schema() {
     if (!this._schema) {
@@ -43,7 +55,9 @@ export class MemoryDatabase {
   }
 
   start() {
-    this.dbContext.subject.subscribe(this.processRequest.bind(this))
+    // The subject is typed as the `ProcessStreamResponseV3` init-shape, but at runtime it always carries a
+    // full response (the store context emits the complete oneof). Treat it as a full message and narrow inside.
+    this.dbContext.subject.subscribe((request) => this.processRequest(request as unknown as ProcessStreamResponseV3))
   }
 
   stop() {
@@ -111,20 +125,25 @@ export class MemoryDatabase {
               if (elemDb) {
                 for (const elemID of Object.keys(elemDb)) {
                   const value = elemDb[elemID]
-                  const deriveField = value.fields[derivedFrom]
+                  const deriveField: RichValue | undefined = value.fields[derivedFrom]
                   let hasRelation = false
-                  if (deriveField?.stringValue === id) {
+                  if (deriveField?.value.case === 'stringValue' && deriveField.value.value === id) {
                     hasRelation = true
                   }
-                  if (deriveField?.listValue) {
-                    hasRelation = deriveField.listValue.values.some((v: any) => v.stringValue === id)
+                  if (deriveField?.value.case === 'listValue') {
+                    hasRelation = deriveField.value.value.values.some(
+                      (v) => v.value.case === 'stringValue' && v.value.value === id
+                    )
                   }
                   if (hasRelation) {
-                    const arr = result.fields[field.name]
-                    if (arr) {
-                      arr.listValue.values.push({ stringValue: elemID })
+                    const arr: RichValue | undefined = result.fields[field.name]
+                    const elem = create(RichValueSchema, { value: { case: 'stringValue', value: elemID } })
+                    if (arr && arr.value.case === 'listValue') {
+                      arr.value.value.values.push(elem)
                     } else {
-                      result.fields[field.name] = { listValue: { values: [{ stringValue: elemID }] } }
+                      result.fields[field.name] = create(RichValueSchema, {
+                        value: { case: 'listValue', value: { values: [elem] } }
+                      })
                     }
                   }
                 }
@@ -137,8 +156,8 @@ export class MemoryDatabase {
     return result
   }
 
-  private processRequest(request: ProcessStreamResponse) {
-    const req = request.dbRequest
+  private processRequest(request: ProcessStreamResponseV3) {
+    const req = request.value.case === 'dbRequest' ? request.value.value : undefined
 
     // Check if schema is required for this request
     const requiresSchema = this.requestRequiresSchema(req)
@@ -149,63 +168,75 @@ export class MemoryDatabase {
 
     this.lastDbRequest = req
     if (req) {
-      if (req.upsert) {
-        const { entityData, entity } = req.upsert
+      if (req.op.case === 'upsert') {
+        const { entityData, entity } = req.op.value
         entityData.forEach((d, i) => {
-          const id = d.fields['id'].stringValue!
+          const idField = d.fields['id']
+          const id = idField?.value.case === 'stringValue' ? idField.value.value : ''
           const entityName = entity[i]
           this.upsert(entityName, id, d)
         })
 
-        this.dbContext.result({
-          opId: req.opId
-        })
+        this.sendResult(request, create(DBResponseSchema, { opId: req.opId }))
       }
-      if (req.delete) {
-        const { id, entity } = req.delete
+      if (req.op.case === 'delete') {
+        const { id, entity } = req.op.value
         id.forEach((i, idx) => {
           const entityName = entity[idx]
           this.delete(entityName, i)
         })
-        this.dbContext.result({
-          opId: req.opId
-        })
+        this.sendResult(request, create(DBResponseSchema, { opId: req.opId }))
       }
 
-      if (req.get) {
-        const { entity, id } = req.get
+      if (req.op.case === 'get') {
+        const { entity, id } = req.op.value
         const data = this.getById(entity, id)
-        this.dbContext.result({
-          opId: req.opId,
-          // entities: { entities: data ? [data] : [] },
-          entityList: {
-            entities: data ? [toEntity(data)] : []
-          }
-        })
+        this.sendResult(
+          request,
+          create(DBResponseSchema, {
+            opId: req.opId,
+            value: {
+              case: 'entityList',
+              value: {
+                entities: data ? [toEntity(data)] : []
+              }
+            }
+          })
+        )
       }
-      if (req.list) {
-        const { entity, cursor, filters } = req.list
+      if (req.op.case === 'list') {
+        const { entity, cursor, filters } = req.op.value
         const list = this.listEntities(entity, filters)
 
         if (cursor) {
           const idx = parseInt(cursor)
 
-          this.dbContext.result({
-            opId: req.opId,
-            entityList: { entities: list.slice(idx, idx + 1).map((d) => toEntity(d)) },
-            nextCursor: idx + 1 < list.length ? `${idx + 1}` : undefined
-          })
+          this.sendResult(
+            request,
+            create(DBResponseSchema, {
+              opId: req.opId,
+              value: { case: 'entityList', value: { entities: list.slice(idx, idx + 1).map((d) => toEntity(d)) } },
+              nextCursor: idx + 1 < list.length ? `${idx + 1}` : undefined
+            })
+          )
         } else {
-          this.dbContext.result({
-            opId: req.opId,
-            entityList: { entities: list.length ? [toEntity(list[0])] : [] },
-            nextCursor: '1'
-          })
+          this.sendResult(
+            request,
+            create(DBResponseSchema, {
+              opId: req.opId,
+              value: { case: 'entityList', value: { entities: list.length ? [toEntity(list[0])] : [] } },
+              nextCursor: '1'
+            })
+          )
         }
       }
     }
   }
 
+  private sendResult(request: ProcessStreamResponseV3, response: DBResponse) {
+    this.dbContext.result(response, request.processId)
+  }
+
   reset() {
     this.db.clear()
   }
@@ -215,19 +246,18 @@ export class MemoryDatabase {
     if (!req) return false
 
     // Check if all entities in the request are MemoryCacheItem
-    if (req.upsert) {
-      return !req.upsert.entity.every((e) => e === MEMORY_CACHE_ITEM_ENTITY)
-    }
-    if (req.delete) {
-      return !req.delete.entity.every((e) => e === MEMORY_CACHE_ITEM_ENTITY)
-    }
-    if (req.get) {
-      return req.get.entity !== MEMORY_CACHE_ITEM_ENTITY
+    switch (req.op.case) {
+      case 'upsert':
+        return !req.op.value.entity.every((e) => e === MEMORY_CACHE_ITEM_ENTITY)
+      case 'delete':
+        return !req.op.value.entity.every((e) => e === MEMORY_CACHE_ITEM_ENTITY)
+      case 'get':
+        return req.op.value.entity !== MEMORY_CACHE_ITEM_ENTITY
+      case 'list':
+        return req.op.value.entity !== MEMORY_CACHE_ITEM_ENTITY
+      default:
+        return false
     }
-    if (req.list) {
-      return req.list.entity !== MEMORY_CACHE_ITEM_ENTITY
-    }
-    return false
   }
 
   private listEntities(entity: string, filters?: DBRequest_DBFilter[]) {
@@ -268,37 +298,46 @@ function filter(entity: RichStruct, filter: DBRequest_DBFilter) {
     case DBRequest_DBOperator.LE:
       return lessThan(value, filter.value) || equal(value, filter.value)
     case DBRequest_DBOperator.IN:
-      return filter.value?.values.some((v) => equal(value, { values: [v] }))
+      return filter.value?.values.some((v) => equal(value, singleList(v)))
     case DBRequest_DBOperator.NOT_IN:
-      return !filter.value?.values.some((v) => equal(value, { values: [v] }))
+      return !filter.value?.values.some((v) => equal(value, singleList(v)))
     case DBRequest_DBOperator.HAS_ALL:
-      return filter.value?.values.every((v) => equal(value, { values: [v] }))
+      return filter.value?.values.every((v) => equal(value, singleList(v)))
     case DBRequest_DBOperator.HAS_ANY:
       for (const a of filter.value?.values ?? []) {
-        if ((value.listValue?.values ?? []).some((v) => equal(a, { values: [v] }))) {
+        const listValues = value.value.case === 'listValue' ? value.value.value.values : []
+        if (listValues.some((v) => equal(a, singleList(v)))) {
           return true
         }
       }
       return false
     case DBRequest_DBOperator.LIKE:
-      return like(value.stringValue, filter.value?.values[0]?.stringValue)
+      return like(richString(value), filter.value?.values[0] ? richString(filter.value.values[0]) : undefined)
     default:
       return false
   }
 }
 
+function singleList(v: RichValue): RichValueList {
+  return create(RichValueListSchema, { values: [v] })
+}
+
+function richString(v?: RichValue): string | undefined {
+  return v?.value.case === 'stringValue' ? v.value.value : undefined
+}
+
 function getValue(entity: RichStruct, field: string) {
   return entity.fields[field]
 }
 
 function equal(field: RichValue, value?: RichValueList): boolean {
-  if (field.stringValue !== undefined) {
-    return field.stringValue === value?.values[0]?.stringValue
+  if (field.value.case === 'stringValue') {
+    return field.value.value === richString(value?.values[0])
   }
-  if (field.listValue) {
-    return field.listValue.values.every((v, i) => {
+  if (field.value.case === 'listValue') {
+    return field.value.value.values.every((v, i) => {
       const vv = value?.values[i]
-      return equal(v, vv ? { values: [vv] } : undefined)
+      return equal(v, vv ? singleList(vv) : undefined)
     })
   }
   const a = toNumber(field)
@@ -335,19 +374,21 @@ function lessThan(field: RichValue, value: RichValueList | undefined) {
 }
 
 function toNumber(value?: RichValue) {
-  if (value?.intValue !== undefined) {
-    return value.intValue
-  }
-  if (value?.floatValue !== undefined) {
-    return value.floatValue
-  }
-  if (value?.bigintValue !== undefined) {
-    return BigIntConverter.to(value) as bigint
+  if (value === undefined) {
+    return undefined
   }
-  if (value?.bigdecimalValue !== undefined) {
-    return BigDecimalConverter.to(value) as BigDecimal
+  switch (value.value.case) {
+    case 'intValue':
+      return value.value.value
+    case 'floatValue':
+      return value.value.value
+    case 'bigintValue':
+      return BigIntConverter.to(value) as bigint
+    case 'bigdecimalValue':
+      return BigDecimalConverter.to(value) as BigDecimal
+    default:
+      return undefined
   }
-  return undefined
 }
 
 function toEntity(data: any) {
@@ -355,7 +396,7 @@ function toEntity(data: any) {
     entity: data.entity,
     genBlockChain: '',
     genBlockNumber: 0n,
-    genBlockTime: new Date(),
+    genBlockTime: timestampNow(),
     data: { fields: data.fields }
   }
 }

package/src/testing/metric-utils.ts

@@ -1,26 +1,27 @@
-import { MetricValue, ProcessResult } from '@sentio/protos'
+import type { MetricValue, ProcessResult } from '@sentio/protos'
 import { Numberish, BigDecimal } from '../core/index.js'
 import { bytesToBigInt } from '../utils/conversion.js'
 
-export function MetricValueToNumber(v: Partial<MetricValue> | undefined): Numberish | undefined {
+export function MetricValueToNumber(v: MetricValue | undefined): Numberish | undefined {
   if (v === undefined) {
     return undefined
   }
 
-  if (v.doubleValue !== undefined) {
-    return v.doubleValue
-  }
-  if (v.bigInteger !== undefined) {
-    let intValue = bytesToBigInt(v.bigInteger.data)
-    if (v.bigInteger.negative) {
-      intValue = -intValue
+  switch (v.value.case) {
+    case 'doubleValue':
+      return v.value.value
+    case 'bigInteger': {
+      let intValue = bytesToBigInt(v.value.value.data)
+      if (v.value.value.negative) {
+        intValue = -intValue
+      }
+      return intValue
     }
-    return intValue
-  }
-  if (v.bigDecimal !== undefined) {
-    return new BigDecimal(v.bigDecimal)
+    case 'bigDecimal':
+      return new BigDecimal(v.value.value)
+    default:
+      return undefined
   }
-  return undefined
 }
 
 export function firstCounterValue(result: ProcessResult | undefined, name: string): Numberish | undefined {

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
-              }
+              })
             }
           }
         }