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

package/src/testing/eth-facet.ts

@@ -1,5 +1,12 @@
 import { TestProcessorServer } from './test-processor-server.js'
-import { DataBinding, HandlerType, ProcessBindingResponse } from '@sentio/protos'
+import {
+  type DataBinding,
+  DataBindingSchema,
+  HandlerType,
+  type ProcessBindingResponse,
+  timestampNow
+} from '@sentio/protos'
+import { create } from '@bufbuild/protobuf'
 import { Trace } from '../eth/eth.js'
 import { BlockParams, LogParams, TransactionResponseParams } from 'ethers/providers'
 import { ChainId, EthChainId } from '@sentio/chain'
@@ -48,17 +55,20 @@ export class EthFacet {
       }
       for (const config of contract.traceConfigs) {
         if (config.signature == signature) {
-          return {
+          return create(DataBindingSchema, {
             data: {
-              ethTrace: {
-                trace,
-                timestamp: new Date()
+              value: {
+                case: 'ethTrace',
+                value: {
+                  rawTrace: JSON.stringify(trace),
+                  timestamp: timestampNow()
+                }
               }
             },
             handlerIds: [config.handlerId],
             handlerType: HandlerType.ETH_TRACE,
             chainId: network
-          }
+          })
         }
       }
     }
@@ -116,14 +126,17 @@ export class EthFacet {
             break
           }
           if (match) {
-            return {
+            return create(DataBindingSchema, {
               data: {
-                ethLog: { log, timestamp: new Date(), rawLog: JSON.stringify(log) }
+                value: {
+                  case: 'ethLog',
+                  value: { timestamp: timestampNow(), rawLog: JSON.stringify(log) }
+                }
               },
               handlerIds: [config.handlerId],
               handlerType: HandlerType.ETH_LOG,
               chainId: network
-            }
+            })
           }
         }
       }
@@ -190,14 +203,17 @@ export class EthFacet {
             break
           }
           if (match) {
-            return {
+            return create(DataBindingSchema, {
               data: {
-                ethLog: { log, timestamp: new Date(), rawLog: JSON.stringify(log) }
+                value: {
+                  case: 'ethLog',
+                  value: { timestamp: timestampNow(), rawLog: JSON.stringify(log) }
+                }
               },
               handlerIds: [config.handlerId],
               handlerType: HandlerType.ETH_LOG,
               chainId: network
-            }
+            })
           }
         }
       }
@@ -230,14 +246,17 @@ export class EthFacet {
     block: Partial<BlockParams> & { number: number },
     network: EthChainId = EthChainId.ETHEREUM
   ): DataBinding {
-    const binding: DataBinding = {
+    const binding: DataBinding = create(DataBindingSchema, {
       data: {
-        ethBlock: { block }
+        value: {
+          case: 'ethBlock',
+          value: { rawBlock: JSON.stringify(block) }
+        }
       },
       handlerType: HandlerType.ETH_BLOCK,
       handlerIds: [],
       chainId: network
-    }
+    })
     for (const contract of this.server.contractConfigs) {
       if (contract.contract?.chainId !== network) {
         continue
@@ -282,14 +301,17 @@ export class EthFacet {
     transaction: Partial<TransactionResponseParams>,
     network: EthChainId = EthChainId.ETHEREUM
   ): DataBinding {
-    const binding: DataBinding = {
+    const binding: DataBinding = create(DataBindingSchema, {
       data: {
-        ethTransaction: { transaction, timestamp: new Date(), rawTransaction: JSON.stringify(transaction) }
+        value: {
+          case: 'ethTransaction',
+          value: { timestamp: timestampNow(), rawTransaction: JSON.stringify(transaction) }
+        }
       },
       handlerType: HandlerType.ETH_TRANSACTION,
       handlerIds: [],
       chainId: network
-    }
+    })
     for (const contract of this.server.contractConfigs) {
       if (contract.contract?.chainId !== network) {
         continue

package/src/testing/fuel-facet.ts

@@ -1,6 +1,7 @@
 import { TestProcessorServer } from './test-processor-server.js'
 import { FuelChainId } from '@sentio/chain'
-import { DataBinding, HandlerType } from '@sentio/protos'
+import { type DataBinding, DataBindingSchema, HandlerType, timestampNow } from '@sentio/protos'
+import { create } from '@bufbuild/protobuf'
 import { FuelNetwork } from '../fuel/index.js'
 import { getRpcEndpoint } from '../fuel/network.js'
 
@@ -47,33 +48,39 @@ export class FuelFacet {
         continue
       }
       for (const callConfig of config.fuelTransactionConfigs) {
-        const binding = {
+        const binding = create(DataBindingSchema, {
           data: {
-            fuelTransaction: {
-              transaction,
-              timestamp: new Date()
+            value: {
+              case: 'fuelTransaction',
+              value: {
+                transaction,
+                timestamp: timestampNow()
+              }
             }
           },
           handlerIds: [callConfig.handlerId],
           handlerType: HandlerType.FUEL_TRANSACTION,
           chainId: network
-        }
+        })
 
         res.push(binding)
       }
 
       for (const assetConfig of config.assetConfigs) {
-        const binding = {
+        const binding = create(DataBindingSchema, {
           data: {
-            fuelTransaction: {
-              transaction,
-              timestamp: new Date()
+            value: {
+              case: 'fuelTransaction',
+              value: {
+                transaction,
+                timestamp: timestampNow()
+              }
             }
           },
           handlerIds: [assetConfig.handlerId],
           handlerType: HandlerType.FUEL_TRANSACTION,
           chainId: network
-        }
+        })
 
         res.push(binding)
       }
@@ -89,20 +96,23 @@ export class FuelFacet {
 
       for (const config of this.server.contractConfigs) {
         for (const logConfig of config.fuelReceiptConfigs) {
-          const logIds = logConfig.log?.logIds ?? []
+          const logIds = logConfig.receiptFilter?.case === 'log' ? logConfig.receiptFilter.value.logIds : []
           if (logIds.includes(receipt.rb)) {
-            const binding = {
+            const binding = create(DataBindingSchema, {
               data: {
-                fuelLog: {
-                  transaction,
-                  timestamp: new Date(),
-                  receiptIndex: BigInt(i)
+                value: {
+                  case: 'fuelLog',
+                  value: {
+                    transaction,
+                    timestamp: timestampNow(),
+                    receiptIndex: BigInt(i)
+                  }
                 }
               },
               handlerIds: [logConfig.handlerId],
               handlerType: HandlerType.FUEL_RECEIPT,
               chainId: network
-            }
+            })
             res.push(binding)
           }
         }

package/src/testing/iota-facet.ts

@@ -1,5 +1,6 @@
 import { MoveCallIotaTransaction, IotaTransactionBlockResponse } from '@iota/iota-sdk/client'
-import { DataBinding, HandlerType } from '@sentio/protos'
+import { type DataBinding, DataBindingSchema, HandlerType, timestampFromDate, 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 { IotaNetwork } from '../iota/index.js'
@@ -47,18 +48,21 @@ export class IotaFacet {
         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,23 @@ export class IotaFacet {
       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: transaction.timestampMs ? new Date(transaction.timestampMs) : new Date(),
-          slot: BigInt(transaction.checkpoint || 0)
+        value: {
+          case: 'suiCall',
+          value: {
+            rawTransaction: JSON.stringify(transaction),
+            timestamp: transaction.timestampMs
+              ? timestampFromDate(new Date(Number(transaction.timestampMs)))
+              : timestampNow(),
+            slot: BigInt(transaction.checkpoint || 0)
+          }
         }
       },
       chainId: network
-    }
+    })
     return this.server.processBinding(binding)
   }
 
@@ -123,19 +132,22 @@ export class IotaFacet {
               accountTypeString(config.contract.address) + '::' + eventFilter.type ===
               parseMoveType(event.type).qname
             ) {
-              return {
+              return create(DataBindingSchema, {
                 data: {
-                  suiEvent: {
-                    rawEvent: JSON.stringify(event),
-                    rawTransaction: JSON.stringify(transaction),
-                    timestamp: new Date(transaction.timestampMs || 0),
-                    slot: 10000n
+                  value: {
+                    case: 'suiEvent',
+                    value: {
+                      rawEvent: JSON.stringify(event),
+                      rawTransaction: JSON.stringify(transaction),
+                      timestamp: timestampFromDate(new Date(Number(transaction.timestampMs || 0))),
+                      slot: 10000n
+                    }
                   }
                 },
                 handlerIds: [eventConfig.handlerId],
                 handlerType: HandlerType.SUI_EVENT,
                 chainId: network
-              }
+              })
             }
           }
         }

package/src/testing/memory-database.ts

@@ -1,13 +1,18 @@
 import { StoreContext } from '../store/context.js'
 import {
-  DBRequest,
-  DBRequest_DBFilter,
+  type DBRequest,
+  type DBRequest_DBFilter,
   DBRequest_DBOperator,
-  ProcessStreamResponse,
-  RichStruct,
-  RichValue,
-  RichValueList
+  DBResponseSchema,
+  type ProcessStreamResponse,
+  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'
@@ -43,7 +48,9 @@ export class MemoryDatabase {
   }
 
   start() {
-    this.dbContext.subject.subscribe(this.processRequest.bind(this))
+    // The subject is typed as the `ProcessStreamResponse` 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 ProcessStreamResponse))
   }
 
   stop() {
@@ -111,20 +118,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] } }
+                      })
                     }
                   }
                 }
@@ -138,7 +150,7 @@ export class MemoryDatabase {
   }
 
   private processRequest(request: ProcessStreamResponse) {
-    const req = request.dbRequest
+    const req = request.value.case === 'dbRequest' ? request.value.value : undefined
 
     // Check if schema is required for this request
     const requiresSchema = this.requestRequiresSchema(req)
@@ -149,58 +161,63 @@ 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.dbContext.result(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.dbContext.result(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.dbContext.result(
+          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.dbContext.result(
+            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.dbContext.result(
+            create(DBResponseSchema, {
+              opId: req.opId,
+              value: { case: 'entityList', value: { entities: list.length ? [toEntity(list[0])] : [] } },
+              nextCursor: '1'
+            })
+          )
         }
       }
     }
@@ -215,19 +232,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)
+    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.delete) {
-      return !req.delete.entity.every((e) => e === MEMORY_CACHE_ITEM_ENTITY)
-    }
-    if (req.get) {
-      return req.get.entity !== MEMORY_CACHE_ITEM_ENTITY
-    }
-    if (req.list) {
-      return req.list.entity !== MEMORY_CACHE_ITEM_ENTITY
-    }
-    return false
   }
 
   private listEntities(entity: string, filters?: DBRequest_DBFilter[]) {
@@ -268,37 +284,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 +360,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 +382,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 {