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

package/src/aptos/data.ts

@@ -1,4 +1,4 @@
-import { Data_AptEvent, Data_AptCall, Data_AptResource } from '@sentio/protos'
+import { type Data_AptEvent, type Data_AptCall, type Data_AptResource } from '@sentio/protos'
 import { UserTransactionResponse, MoveResource } from '@aptos-labs/ts-sdk'
 import { MoveCoder, decodeResourceChange, ResourceChange } from '@typemove/aptos'
 
@@ -18,7 +18,7 @@ type Data_AptResource_Ext = Data_AptResource & {
   _decodedResources?: ResourceChange<any>[]
 }
 
-export class AptEvent implements Data_AptEvent {
+export class AptEvent {
   constructor(readonly data: Data_AptEvent_Ext) {}
 
   get rawEvent(): string {
@@ -57,7 +57,7 @@ export class AptEvent implements Data_AptEvent {
   }
 }
 
-export class AptCall implements Data_AptCall {
+export class AptCall {
   constructor(readonly data: Data_AptCall_Ext) {}
 
   get rawTransaction(): string {
@@ -88,7 +88,7 @@ export class AptCall implements Data_AptCall {
   }
 }
 
-export class AptResource implements Data_AptResource {
+export class AptResource {
   constructor(readonly data: Data_AptResource_Ext) {}
 
   get version(): bigint {

package/src/core/base-context.ts

@@ -1,10 +1,17 @@
-import { ProcessResult, RecordMetaData, TemplateInstance } from '@sentio/protos'
+import {
+  type ProcessResult,
+  ProcessResultSchema,
+  type RecordMetaData,
+  RecordMetaDataSchema,
+  type TemplateInstance
+} from '@sentio/protos'
+import { create, type MessageInitShape } from '@bufbuild/protobuf'
 import { EventLoggerBinding } from './event-logger.js'
 import { Meter, Labels } from './meter.js'
 import { ChainId } from '@sentio/chain'
 import { mergeProcessResultsInPlace, PluginManager } from '@sentio/runtime'
 import { Required } from 'utility-types'
-import { ServerError, Status } from 'nice-grpc'
+import { ConnectError, Code } from '@connectrpc/connect'
 import { Store } from '../store/store.js'
 import { MemoryCache } from '../store/cache.js'
 
@@ -16,7 +23,7 @@ export abstract class BaseContext {
   baseLabels: Labels
   private active: boolean
 
-  private _res: Required<ProcessResult, 'states'> = {
+  private _res: Required<ProcessResult, 'states'> = create(ProcessResultSchema, {
     counters: [],
     events: [],
     exports: [],
@@ -25,13 +32,13 @@ export abstract class BaseContext {
       configUpdated: false
     },
     timeseriesResult: []
-  }
+  }) as Required<ProcessResult, 'states'>
 
-  public update(res: Partial<ProcessResult>) {
+  public update(res: MessageInitShape<typeof ProcessResultSchema>) {
     if (this.active) {
-      mergeProcessResultsInPlace(this._res, [ProcessResult.fromPartial(res)])
+      mergeProcessResultsInPlace(this._res, [create(ProcessResultSchema, res)])
     } else {
-      throw new ServerError(Status.INTERNAL, 'context not active, possible async function invoke without await')
+      throw new ConnectError('context not active, possible async function invoke without await', Code.Internal)
     }
   }
 
@@ -48,7 +55,7 @@ export abstract class BaseContext {
       this.active = false
       return this._res
     } else {
-      throw new ServerError(Status.INTERNAL, "Can't get result from same context twice")
+      throw new ConnectError("Can't get result from same context twice", Code.Internal)
     }
   }
 
@@ -58,19 +65,19 @@ export abstract class BaseContext {
     if (Object.keys(labels).length === 0) {
       let metadata = this.metadataCache.get(name)
       if (!metadata) {
-        metadata = {
+        metadata = create(RecordMetaDataSchema, {
           ...this.baseLabels,
           ...this.getMetaDataInternal(name, labels)
-        }
+        })
         this.metadataCache.set(name, metadata)
       }
       return metadata
     }
 
-    return {
+    return create(RecordMetaDataSchema, {
       ...this.baseLabels,
       ...this.getMetaDataInternal(name, labels)
-    }
+    })
   }
 
   protected abstract getMetaDataInternal(name: string, labels: Labels): RecordMetaData

package/src/core/core-plugin.ts

@@ -1,5 +1,6 @@
 import { GLOBAL_CONFIG, Plugin, PluginManager } from '@sentio/runtime'
-import { InitResponse, ProcessConfigResponse } from '@sentio/protos'
+import { DataBaseSchemaSchema, ExportConfigSchema, InitResponse, ProcessConfigResponse } from '@sentio/protos'
+import { create } from '@bufbuild/protobuf'
 
 import { MetricState } from './meter.js'
 import { ExporterState } from './exporter.js'
@@ -30,10 +31,12 @@ export class CorePlugin extends Plugin {
     }
 
     for (const exporter of ExporterState.INSTANCE.getValues()) {
-      config.exportConfigs.push({
-        name: exporter.name,
-        channel: exporter.channel
-      })
+      config.exportConfigs.push(
+        create(ExportConfigSchema, {
+          name: exporter.name,
+          channel: exporter.channel
+        })
+      )
     }
 
     const schemas = DatabaseSchemaState.INSTANCE.getValues()
@@ -50,9 +53,9 @@ type MemoryCacheItem @cache(sizeMB: ${GLOBAL_CONFIG.cache.size || 100}) {
     }
 
     if (mergedSources.trim().length > 0) {
-      config.dbSchema = {
+      config.dbSchema = create(DataBaseSchemaSchema, {
         gqlSchema: mergedSources
-      }
+      })
     }
   }
 }

package/src/core/event-logger.ts

@@ -1,16 +1,24 @@
 import { BaseContext } from './base-context.js'
 import {
-  CoinID,
-  EventLogConfig,
+  type CoinID,
+  CoinIDSchema,
+  CoinID_AddressIdentifierSchema,
+  type EventLogConfig,
+  EventLogConfigSchema,
   EventLogConfig_BasicFieldType,
-  EventLogConfig_Field,
-  EventLogConfig_StructFieldType,
-  EventTrackingResult,
+  type EventLogConfig_Field,
+  EventLogConfig_FieldSchema,
+  EventLogConfig_StructFieldTypeSchema,
+  type EventTrackingResult,
+  EventTrackingResultSchema,
   LogLevel,
-  RichStruct,
-  TimeseriesResult,
+  type RichStruct,
+  RichStructSchema,
+  type TimeseriesResult,
+  TimeseriesResultSchema,
   TimeseriesResult_TimeseriesType
 } from '@sentio/protos'
+import { create } from '@bufbuild/protobuf'
 import { normalizeAttribute, normalizeLabels, normalizeToRichStruct } from './normalization.js'
 import { MapStateStorage, processMetrics } from '@sentio/runtime'
 import { BN } from 'fuels'
@@ -53,7 +61,10 @@ export class EventLoggerBinding {
 export type BasicFieldType = EventLogConfig_BasicFieldType
 export const BasicFieldType = EventLogConfig_BasicFieldType
 
-export type FieldType = CoinID | BasicFieldType | Fields
+// User-facing coin descriptor (plain shape, matching the legacy CoinID surface).
+export type CoinFieldType = { symbol: string } | { address: { address: string; chain: string } }
+
+export type FieldType = CoinFieldType | BasicFieldType | Fields
 
 export type Fields = { [key: string]: FieldType }
 
@@ -61,30 +72,48 @@ export interface EventLogOptions {
   fields: Fields
 }
 
+function toCoinIDField(value: CoinFieldType): CoinID {
+  if ('symbol' in value && value.symbol) {
+    return create(CoinIDSchema, { id: { case: 'symbol', value: value.symbol } })
+  }
+  const address = (value as { address: { address: string; chain: string } }).address
+  return create(CoinIDSchema, {
+    id: {
+      case: 'address',
+      value: create(CoinID_AddressIdentifierSchema, {
+        address: address.address,
+        chain: address.chain
+      })
+    }
+  })
+}
+
 export function fieldsToProtos(fields: Fields): EventLogConfig_Field[] {
   const fieldsProto: EventLogConfig_Field[] = []
   for (const [key, value] of Object.entries(fields)) {
-    let basicType: BasicFieldType | undefined
-    let coinType: CoinID | undefined
-    let structType: EventLogConfig_StructFieldType | undefined
+    let type: EventLogConfig_Field['type']
 
     if (typeof value === 'number') {
-      basicType = value
+      type = { case: 'basicType', value }
     } else {
-      if (value.address || value.symbol) {
-        coinType = value
+      const coin = value as CoinFieldType
+      if (('address' in coin && coin.address) || ('symbol' in coin && coin.symbol)) {
+        type = { case: 'coinType', value: toCoinIDField(coin) }
       } else {
-        structType = EventLogConfig_StructFieldType.create({
-          fields: fieldsToProtos(value as Fields)
-        })
+        type = {
+          case: 'structType',
+          value: create(EventLogConfig_StructFieldTypeSchema, {
+            fields: fieldsToProtos(value as Fields)
+          })
+        }
       }
     }
-    fieldsProto.push({
-      name: key,
-      basicType,
-      coinType,
-      structType
-    })
+    fieldsProto.push(
+      create(EventLogConfig_FieldSchema, {
+        name: key,
+        type
+      })
+    )
   }
   return fieldsProto
 }
@@ -100,10 +129,10 @@ export class EventLogger {
 
   static register(eventName: string, options?: EventLogOptions): EventLogger {
     checkEventName(eventName)
-    let config = EventLogConfig.create()
+    let config = create(EventLogConfigSchema)
 
     if (options?.fields) {
-      config = EventLogConfig.create({
+      config = create(EventLogConfigSchema, {
         name: eventName,
         fields: fieldsToProtos(options.fields)
       })
@@ -128,24 +157,24 @@ function checkEventName(eventName: string) {
 function emit<T>(ctx: BaseContext, eventName: string, event: Event<T>) {
   const { distinctId, severity, message, ...payload } = event
 
-  const data: RichStruct = {
+  const data: RichStruct = create(RichStructSchema, {
     fields: {
       severity: {
-        stringValue: (severity || LogLevel.INFO).toString()
+        value: { case: 'stringValue', value: (severity || LogLevel.INFO).toString() }
       },
       message: {
-        stringValue: message || ''
+        value: { case: 'stringValue', value: message || '' }
       },
       // don't rename to distinctEntityId in new events.
       distinctId: {
-        stringValue: distinctId || ''
+        value: { case: 'stringValue', value: distinctId || '' }
       },
       ...normalizeToRichStruct(ctx.baseLabels, payload).fields
     }
-  }
+  })
 
   // legacy v2 events, deprecating
-  const eventRes: EventTrackingResult = {
+  const eventRes: EventTrackingResult = create(EventTrackingResultSchema, {
     metadata: ctx.getMetaData(eventName, {}),
     severity: severity || LogLevel.INFO,
     message: message || '',
@@ -157,14 +186,14 @@ function emit<T>(ctx: BaseContext, eventName: string, event: Event<T>) {
     runtimeInfo: undefined,
     noMetric: true,
     attributes2: normalizeToRichStruct(ctx.baseLabels, payload)
-  }
+  })
 
-  const res: TimeseriesResult = {
+  const res: TimeseriesResult = create(TimeseriesResultSchema, {
     metadata: ctx.getMetaData(eventName, {}),
     type: TimeseriesResult_TimeseriesType.EVENT,
     data,
     runtimeInfo: undefined
-  }
+  })
 
   processMetrics.process_eventemit_count.add(1)
   ctx.update({ timeseriesResult: [res], events: [eventRes] })

package/src/core/exporter.ts

@@ -1,7 +1,8 @@
 import { BaseContext } from './base-context.js'
-import { ExportResult } from '@sentio/protos'
+import { ExportResult, ExportResultSchema } from '@sentio/protos'
 import { NamedResultDescriptor } from './metadata.js'
 import { MapStateStorage } from '@sentio/runtime'
+import { create } from '@bufbuild/protobuf'
 
 export type Export = Record<string, any>
 
@@ -22,11 +23,11 @@ export class Exporter extends NamedResultDescriptor {
   }
 
   emit(ctx: BaseContext, data: Export) {
-    const res: ExportResult = {
+    const res: ExportResult = create(ExportResultSchema, {
       metadata: ctx.getMetaData(this.name, {}),
       payload: JSON.stringify(data),
-      runtimeInfo: undefined,
-    }
+      runtimeInfo: undefined
+    })
     ctx.update({ exports: [res] })
   }
 }

package/src/core/handler-options.ts

@@ -9,7 +9,7 @@ export type PartitionHandler<D> = (data: D) => string | Promise<string>
  * @template F The fetch configuration type (e.g., EthFetchConfig, MoveFetchConfig)
  * @template D The data type that will be processed (e.g., Event, Transaction, Block)
  */
-export type HandlerOptions<F, D> = Partial<F> & {
+export type HandlerOptions<F, D> = Omit<Partial<F>, '$typeName' | '$unknown'> & {
   /**
    * Optional partition key for data partitioning.
    * Can be a static string or a function that computes the key from the data.

package/src/core/handler-register.ts

@@ -1,6 +1,6 @@
-import { ServerError, Status } from 'nice-grpc'
+import { ConnectError, Code } from '@connectrpc/connect'
 import { ChainId } from '@sentio/chain'
-import { ProcessResult } from '@sentio/protos'
+import { type ProcessResult } from '@sentio/protos'
 
 export type HandlerFunction = (...args: any[]) => Promise<ProcessResult>
 
@@ -37,7 +37,7 @@ export class HandlerRegister {
   getHandlerById(chainId: ChainId | string, id: number): HandlerFunction {
     const entries = this.handlerByChain.get(chainId)
     if (!entries || id < 0 || id >= entries.length) {
-      throw new ServerError(Status.INTERNAL, `Handler with ID ${id} not found.`)
+      throw new ConnectError(`Handler with ID ${id} not found.`, Code.Internal)
     }
     return entries[id].handler
   }

package/src/core/meter.ts

@@ -2,12 +2,14 @@ import { BaseContext } from './base-context.js'
 import { Numberish, toMetricValue, toTimeSeriesData } from './numberish.js'
 import { NamedResultDescriptor } from './metadata.js'
 import {
-  AggregationConfig,
+  AggregationConfigSchema,
   AggregationType,
-  MetricConfig,
+  type MetricConfig,
+  MetricConfigSchema,
   MetricType,
   TimeseriesResult_TimeseriesType
 } from '@sentio/protos'
+import { create, type MessageInitShape } from '@bufbuild/protobuf'
 import { MapStateStorage, processMetrics } from '@sentio/runtime'
 
 export type Labels = { [key: string]: string }
@@ -17,7 +19,7 @@ export class MetricOptions {
   description?: string
   sparse?: boolean
   // persistentBetweenVersion?: boolean
-  aggregationConfig?: Partial<AggregationConfig>
+  aggregationConfig?: MessageInitShape<typeof AggregationConfigSchema>
 }
 
 export class CounterOptions {
@@ -37,9 +39,9 @@ export class CounterOptions {
 export class Metric extends NamedResultDescriptor {
   config: MetricConfig
 
-  constructor(type: MetricType, name: string, option?: MetricConfig) {
+  constructor(type: MetricType, name: string, option?: MessageInitShape<typeof MetricConfigSchema>) {
     super(name)
-    this.config = MetricConfig.fromPartial({ ...option, name: this.name, type })
+    this.config = create(MetricConfigSchema, { ...option, name: this.name, type })
     const aggregationConfig = this.config.aggregationConfig
     if (aggregationConfig && aggregationConfig.intervalInMinutes.length) {
       if (aggregationConfig.intervalInMinutes.length > 1) {
@@ -90,7 +92,7 @@ export class Counter extends Metric {
     super(
       MetricType.COUNTER,
       name,
-      MetricConfig.fromPartial({
+      create(MetricConfigSchema, {
         ...option,
         aggregationConfig: {
           intervalInMinutes: option?.resolutionConfig ? [option?.resolutionConfig?.intervalInMinutes] : []
@@ -162,7 +164,7 @@ export class Gauge extends Metric {
   }
 
   protected constructor(name: string, option?: MetricOptions) {
-    super(MetricType.GAUGE, name, MetricConfig.fromPartial({ ...option }))
+    super(MetricType.GAUGE, name, create(MetricConfigSchema, { ...option }))
   }
 
   record(ctx: BaseContext, value: Numberish, labels: Labels = {}) {

package/src/core/normalization.ts

@@ -1,7 +1,20 @@
 import { Labels } from './meter.js'
 import { BigDecimal } from './big-decimal.js'
 import { BN } from 'fuels'
-import { CoinID, RichStruct, RichValue, RichValue_NullValue, TokenAmount } from '@sentio/protos'
+import {
+  type CoinID,
+  CoinIDSchema,
+  CoinID_AddressIdentifierSchema,
+  type RichStruct,
+  RichStructSchema,
+  type RichValue,
+  RichValueSchema,
+  RichValue_NullValue,
+  type TokenAmount,
+  TokenAmountSchema,
+  timestampFromDate
+} from '@sentio/protos'
+import { create } from '@bufbuild/protobuf'
 import { toBigInteger, toBigDecimal } from './numberish.js'
 
 export const SENTIO_BIGINT_STRING_SUFFIX = ':sto_bi'
@@ -107,73 +120,78 @@ export function normalizeAttribute(record: Record<string, any>): any {
 
 function normalizeToRichValue(value: any): RichValue {
   if (value == null) {
-    return { nullValue: RichValue_NullValue.NULL_VALUE }
+    return create(RichValueSchema, { value: { case: 'nullValue', value: RichValue_NullValue.NULL_VALUE } })
   }
   switch (typeof value) {
     case 'string':
-      return { stringValue: value }
+      return create(RichValueSchema, { value: { case: 'stringValue', value } })
     case 'bigint':
       const v = BigInt(value)
-      return { bigintValue: toBigInteger(v) }
+      return create(RichValueSchema, { value: { case: 'bigintValue', value: toBigInteger(v) } })
     case 'number':
       if (isNaN(value) || !isFinite(value)) {
         throw new Error("can't submit NaN or Infinity value")
       }
-      return { bigdecimalValue: toBigDecimal(new BigDecimal(value)) }
+      return create(RichValueSchema, {
+        value: { case: 'bigdecimalValue', value: toBigDecimal(new BigDecimal(value)) }
+      })
     case 'function':
-      return { nullValue: RichValue_NullValue.UNRECOGNIZED }
+      return create(RichValueSchema, { value: { case: 'nullValue', value: RichValue_NullValue.NULL_VALUE } })
     case 'symbol':
-      return { stringValue: String(value) }
+      return create(RichValueSchema, { value: { case: 'stringValue', value: String(value) } })
     case 'boolean':
-      return { boolValue: value }
+      return create(RichValueSchema, { value: { case: 'boolValue', value } })
     default:
       if (value instanceof Uint8Array) {
-        return { bytesValue: value }
+        return create(RichValueSchema, { value: { case: 'bytesValue', value } })
       }
       if (value instanceof Date) {
-        return { timestampValue: value }
+        return create(RichValueSchema, { value: { case: 'timestampValue', value: timestampFromDate(value) } })
       }
       if (value instanceof BigDecimal) {
-        return { bigdecimalValue: toBigDecimal(value) }
+        return create(RichValueSchema, { value: { case: 'bigdecimalValue', value: toBigDecimal(value) } })
       }
       if (BN.isBN(value)) {
         const value1 = new BigDecimal(value.toString())
         if (value1.isNaN() || !value1.isFinite()) {
           throw new Error("can't submit NaN or Infinity value")
         }
-        return { bigdecimalValue: toBigDecimal(value1) }
+        return create(RichValueSchema, { value: { case: 'bigdecimalValue', value: toBigDecimal(value1) } })
       }
       if (Array.isArray(value)) {
-        return {
-          listValue: {
-            values: value.map((v) => normalizeToRichValue(v))
+        return create(RichValueSchema, {
+          value: {
+            case: 'listValue',
+            value: {
+              values: value.map((v) => normalizeToRichValue(v))
+            }
           }
-        }
+        })
       }
       if (value instanceof Promise) {
         console.error('Cannot submit promise')
-        return { nullValue: RichValue_NullValue.UNRECOGNIZED }
+        return create(RichValueSchema, { value: { case: 'nullValue', value: RichValue_NullValue.NULL_VALUE } })
       }
       if (typeof value === 'object') {
         const tokenAmount = toTokenAmount(value)
         if (tokenAmount) {
-          return { tokenValue: tokenAmount }
+          return create(RichValueSchema, { value: { case: 'tokenValue', value: tokenAmount } })
         }
 
-        return {
-          structValue: normalizeToRichStruct(value)
-        }
+        return create(RichValueSchema, {
+          value: { case: 'structValue', value: normalizeToRichStruct(value) }
+        })
       }
 
       console.warn('Cannot submit unsupported type ' + typeof value)
-      return { nullValue: RichValue_NullValue.UNRECOGNIZED }
+      return create(RichValueSchema, { value: { case: 'nullValue', value: RichValue_NullValue.NULL_VALUE } })
   }
 }
 
 export function normalizeToRichStruct(...objs: any[]): RichStruct {
-  const ret: RichStruct = {
+  const ret: RichStruct = create(RichStructSchema, {
     fields: {}
-  }
+  })
   for (const obj of objs) {
     for (const [key, value] of Object.entries(obj)) {
       try {
@@ -189,7 +207,7 @@ export function normalizeToRichStruct(...objs: any[]): RichStruct {
 }
 
 function toTokenAmount(value: any): TokenAmount | undefined {
-  const ret = TokenAmount.create()
+  const ret = create(TokenAmountSchema)
 
   for (const key of Object.getOwnPropertyNames(value)) {
     switch (key) {
@@ -211,7 +229,7 @@ function toTokenAmount(value: any): TokenAmount | undefined {
         break
       case 'specifiedAt':
         if (value.specifiedAt instanceof Date) {
-          ret.specifiedAt = value.specifiedAt
+          ret.specifiedAt = timestampFromDate(value.specifiedAt)
         } else {
           return undefined
         }
@@ -225,13 +243,17 @@ function toTokenAmount(value: any): TokenAmount | undefined {
 }
 
 function toCoinID(coin: any): CoinID | undefined {
-  const ret = CoinID.create()
+  const ret = create(CoinIDSchema)
   if (typeof coin.symbol === 'string') {
-    return (ret.symbol = coin.symbol)
+    ret.id = { case: 'symbol', value: coin.symbol }
+    return ret
   } else if (coin.hasOwnProperty('address')) {
-    ret.address = {
-      address: coin.address.address,
-      chain: coin.address.chain
+    ret.id = {
+      case: 'address',
+      value: create(CoinID_AddressIdentifierSchema, {
+        address: coin.address.address,
+        chain: coin.address.chain
+      })
     }
   } else {
     return undefined