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

package/src/core/numberish.ts

@@ -1,4 +1,16 @@
-import { BigDecimalRichValue, BigInteger, MetricValue, RichStruct, RichValue_NullValue } from '@sentio/protos'
+import {
+  type BigDecimalRichValue,
+  BigDecimalRichValueSchema,
+  type BigInteger,
+  BigIntegerSchema,
+  type MetricValue,
+  MetricValueSchema,
+  type RichStruct,
+  RichStructSchema,
+  RichValueSchema,
+  RichValue_NullValue
+} from '@sentio/protos'
+import { create } from '@bufbuild/protobuf'
 import { BigDecimal } from './big-decimal.js'
 
 export type Numberish = number | bigint | BigDecimal | string
@@ -12,30 +24,30 @@ export function toMetricValue(value: Numberish): MetricValue {
       throw new Error('Cannot record infinite value')
     }
     if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
-      return MetricValue.fromPartial({
-        bigInteger: toBigInteger(value)
+      return create(MetricValueSchema, {
+        value: { case: 'bigInteger', value: toBigInteger(value) }
       })
     }
 
-    return MetricValue.fromPartial({
-      doubleValue: Number(value)
+    return create(MetricValueSchema, {
+      value: { case: 'doubleValue', value: Number(value) }
     })
   }
   if (typeof value === 'bigint') {
-    return MetricValue.fromPartial({
-      bigInteger: toBigInteger(value)
+    return create(MetricValueSchema, {
+      value: { case: 'bigInteger', value: toBigInteger(value) }
     })
   }
   if (typeof value === 'string') {
-    return MetricValue.fromPartial({
-      bigDecimal: value
+    return create(MetricValueSchema, {
+      value: { case: 'bigDecimal', value: value }
     })
   }
   // if (value instanceof BigDecimal) {
   // Carefully consider the use case here
   if (value.isInteger()) {
-    return MetricValue.fromPartial({
-      bigInteger: bigDecimalToBigInteger(value)
+    return create(MetricValueSchema, {
+      value: { case: 'bigInteger', value: bigDecimalToBigInteger(value) }
     })
   } else {
     if (value.isNaN()) {
@@ -45,8 +57,8 @@ export function toMetricValue(value: Numberish): MetricValue {
       // NaN also not finite
       throw new Error('Cannot record infinite value')
     }
-    return MetricValue.fromPartial({
-      bigDecimal: value.toString() // e.g. -7.350918e-428
+    return create(MetricValueSchema, {
+      value: { case: 'bigDecimal', value: value.toString() } // e.g. -7.350918e-428
     })
   }
   // }
@@ -101,10 +113,10 @@ function hexToBigInteger(hex: string, negative: boolean): BigInteger {
   }
   const buffer = Buffer.from(hex, 'hex')
 
-  return {
+  return create(BigIntegerSchema, {
     negative: negative,
     data: new Uint8Array(buffer)
-  }
+  })
 }
 
 export function toBigDecimal(value: BigDecimal): BigDecimalRichValue {
@@ -115,41 +127,45 @@ export function toBigDecimal(value: BigDecimal): BigDecimalRichValue {
     .join('')
   const exp = -(s.length - (value.e ?? 0) - 1)
 
-  return {
+  return create(BigDecimalRichValueSchema, {
     value: toBigInteger(BigInt(s) * BigInt(value.s ?? 1)),
     exp: exp
-  }
+  })
 }
 
 export function toTimeSeriesData(value: Numberish, labels: Record<string, string>, neg: boolean) {
   const mv = toMetricValue(value)
-  const data: RichStruct = {
+  const data: RichStruct = create(RichStructSchema, {
     fields: {
       value: {}
     }
-  }
+  })
 
   for (const key in labels) {
     if (labels[key] == null) {
-      data.fields[key] = { nullValue: RichValue_NullValue.NULL_VALUE }
+      data.fields[key] = create(RichValueSchema, {
+        value: { case: 'nullValue', value: RichValue_NullValue.NULL_VALUE }
+      })
     } else {
-      data.fields[key] = { stringValue: labels[key] }
+      data.fields[key] = create(RichValueSchema, { value: { case: 'stringValue', value: labels[key] } })
     }
   }
 
-  if (mv.bigInteger != null) {
-    mv.bigInteger.negative = neg ? !mv.bigInteger.negative : mv.bigInteger.negative
-    data.fields.value.bigintValue = mv.bigInteger
-  } else if (mv.bigDecimal != null) {
-    let v = new BigDecimal(mv.bigDecimal)
+  if (mv.value.case === 'bigInteger') {
+    const bigInteger = mv.value.value
+    bigInteger.negative = neg ? !bigInteger.negative : bigInteger.negative
+    data.fields.value.value = { case: 'bigintValue', value: bigInteger }
+  } else if (mv.value.case === 'bigDecimal') {
+    let v = new BigDecimal(mv.value.value)
     if (neg) {
       v = v.negated()
     }
-    data.fields.value.bigdecimalValue = toBigDecimal(v)
-  } else if (mv.doubleValue != null) {
-    data.fields.value.floatValue = neg ? -mv.doubleValue : mv.doubleValue
+    data.fields.value.value = { case: 'bigdecimalValue', value: toBigDecimal(v) }
+  } else if (mv.value.case === 'doubleValue') {
+    const doubleValue = mv.value.value
+    data.fields.value.value = { case: 'floatValue', value: neg ? -doubleValue : doubleValue }
   } else {
-    data.fields.value.nullValue = RichValue_NullValue.NULL_VALUE
+    data.fields.value.value = { case: 'nullValue', value: RichValue_NullValue.NULL_VALUE }
   }
   return data
 }

package/src/core/partition-handler-manager.ts

@@ -1,9 +1,11 @@
 import {
   HandlerType,
-  ProcessStreamResponse_Partitions_Partition,
+  type ProcessStreamResponse_Partitions_Partition,
+  ProcessStreamResponse_Partitions_PartitionSchema,
   ProcessStreamResponse_Partitions_Partition_SysValue
 } from '@sentio/protos'
-import { ServerError, Status } from 'nice-grpc'
+import { create } from '@bufbuild/protobuf'
+import { ConnectError, Code } from '@connectrpc/connect'
 
 /**
  * Type for partition handler functions that can process any data type
@@ -51,20 +53,20 @@ export class PartitionHandlerManager {
       if (partitionHandler && data) {
         try {
           const partitionValue = await partitionHandler(data)
-          result[handlerId] = {
-            userValue: partitionValue
-          }
+          result[handlerId] = create(ProcessStreamResponse_Partitions_PartitionSchema, {
+            value: { case: 'userValue', value: partitionValue ?? '' }
+          })
         } catch (error) {
           // If partition handler fails, fall back to unrecognized
-          throw new ServerError(
-            Status.INVALID_ARGUMENT,
-            'compute partition key failed, error:' + (error instanceof Error ? error.message : String(error))
+          throw new ConnectError(
+            'compute partition key failed, error:' + (error instanceof Error ? error.message : String(error)),
+            Code.InvalidArgument
           )
         }
       } else {
-        result[handlerId] = {
-          sysValue: ProcessStreamResponse_Partitions_Partition_SysValue.UNRECOGNIZED
-        }
+        result[handlerId] = create(ProcessStreamResponse_Partitions_PartitionSchema, {
+          value: { case: 'sysValue', value: ProcessStreamResponse_Partitions_Partition_SysValue.BLOCK_NUMBER }
+        })
       }
     }
 

package/src/cosmos/context.ts

@@ -1,6 +1,7 @@
 import { BaseContext, Labels, normalizeLabels } from '../core/index.js'
 import { ChainId, CosmosChainId } from '@sentio/chain'
-import { RecordMetaData } from '@sentio/protos'
+import { RecordMetaData, RecordMetaDataSchema } from '@sentio/protos'
+import { create } from '@bufbuild/protobuf'
 import { CosmosTransaction } from './transaction.js'
 
 export class CosmosContext extends BaseContext {
@@ -23,7 +24,7 @@ export class CosmosContext extends BaseContext {
   }
 
   protected getMetaDataInternal(name: string, labels: Labels): RecordMetaData {
-    return {
+    return create(RecordMetaDataSchema, {
       address: this.contractAddress,
       contractName: labels['name'] || '',
       blockNumber: BigInt(this.transaction?.height || 0),
@@ -33,6 +34,6 @@ export class CosmosContext extends BaseContext {
       name: name,
       logIndex: this.logIndex,
       labels: normalizeLabels(labels)
-    }
+    })
   }
 }

package/src/cosmos/cosmos-plugin.ts

@@ -1,6 +1,7 @@
 import { errorString, GLOBAL_CONFIG, mergeProcessResults, Plugin, PluginManager, USER_PROCESSOR } from '@sentio/runtime'
 import {
-  ContractConfig,
+  ContractConfigSchema,
+  CosmosLogHandlerConfigSchema,
   DataBinding,
   HandlerType,
   InitResponse,
@@ -8,7 +9,8 @@ import {
   ProcessResult,
   StartRequest
 } from '@sentio/protos'
-import { ServerError, Status } from 'nice-grpc'
+import { create } from '@bufbuild/protobuf'
+import { ConnectError, Code } from '@connectrpc/connect'
 import { HandlerRegister } from '../core/handler-register.js'
 import { CosmosProcessorState } from './types.js'
 
@@ -31,7 +33,7 @@ export class CosmosPlugin extends Plugin {
       if (forChainId !== undefined && forChainId !== chainId.toString()) {
         continue
       }
-      const contractConfig = ContractConfig.fromPartial({
+      const contractConfig = create(ContractConfigSchema, {
         processorType: USER_PROCESSOR,
         contract: {
           name: processor.config.name,
@@ -46,11 +48,13 @@ export class CosmosPlugin extends Plugin {
       for (const callHandler of processor.callHandlers) {
         const handlerId = this.handlerRegister.register(callHandler.handler, chainId)
 
-        contractConfig.cosmosLogConfigs.push({
-          handlerId,
-          handlerName: callHandler.handlerName,
-          logFilters: callHandler.logConfig?.logFilters || []
-        })
+        contractConfig.cosmosLogConfigs.push(
+          create(CosmosLogHandlerConfigSchema, {
+            handlerId,
+            handlerName: callHandler.handlerName,
+            logFilters: callHandler.logConfig?.logFilters || []
+          })
+        )
       }
 
       // Finish up a contract
@@ -65,17 +69,17 @@ export class CosmosPlugin extends Plugin {
       case HandlerType.COSMOS_CALL:
         return this.processTransaction(request)
       default:
-        throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
+        throw new ConnectError('No handle type registered ' + request.handlerType, Code.InvalidArgument)
     }
   }
 
   async start(request: StartRequest) {}
 
   async processTransaction(binding: DataBinding): Promise<ProcessResult> {
-    if (!binding.data?.cosmosCall?.transaction) {
-      throw new ServerError(Status.INVALID_ARGUMENT, "transaction can't be null")
+    if (binding.data?.value.case !== 'cosmosCall' || !binding.data.value.value.transaction) {
+      throw new ConnectError("transaction can't be null", Code.InvalidArgument)
     }
-    const call = binding.data.cosmosCall
+    const call = binding.data.value.value
 
     const promises: Promise<ProcessResult>[] = []
 
@@ -86,9 +90,9 @@ export class CosmosPlugin extends Plugin {
           handlerId
         )(call)
         .catch((e) => {
-          throw new ServerError(
-            Status.INTERNAL,
-            'error processing transaction: ' + JSON.stringify(call.transaction) + '\n' + errorString(e)
+          throw new ConnectError(
+            'error processing transaction: ' + JSON.stringify(call.transaction) + '\n' + errorString(e),
+            Code.Internal
           )
         })
       if (GLOBAL_CONFIG.execution.sequential) {

package/src/cosmos/cosmos-processor.ts

@@ -27,7 +27,7 @@ export class CosmosProcessor {
     const callHandler = {
       handlerName: getHandlerName(),
       handler: async (call: Data_CosmosCall) => {
-        const transaction = call.transaction as CosmosTransaction
+        const transaction = call.transaction as unknown as CosmosTransaction
 
         const ctx = new CosmosContext(this.config.chainId, this.config.address, transaction)
 
@@ -46,7 +46,7 @@ export class CosmosProcessor {
         const p = handlerOptions?.partitionKey
         if (!p) return undefined
         if (typeof p === 'function') {
-          const transaction = call.transaction as CosmosTransaction
+          const transaction = call.transaction as unknown as CosmosTransaction
           return p(transaction)
         }
         return p

package/src/eth/abi-decoder/decode-worker.ts

@@ -1,6 +1,6 @@
 import { Interface, LogDescription, LogParams, ParamType, Result } from 'ethers'
 import { Piscina } from 'piscina'
-import { ServerError, Status } from 'nice-grpc'
+import { ConnectError, Code } from '@connectrpc/connect'
 import { FormattedLog } from '../eth.js'
 
 export interface IResult {
@@ -41,7 +41,7 @@ export interface ILogDescription {
 
 export function parseLogInline(contractViewInterface: any, log: LogParams): LogDescription | null {
   if (!log) {
-    throw new ServerError(Status.INVALID_ARGUMENT, 'Log is empty')
+    throw new ConnectError('Log is empty', Code.InvalidArgument)
   }
   const topics = log.topics
   const data = log.data

package/src/eth/account-processor.ts

@@ -1,5 +1,15 @@
 import { ERC20__factory, ERC721__factory } from './builtin/internal/index.js'
-import { AddressType, EthFetchConfig, PreprocessResult, ProcessResult } from '@sentio/protos'
+import {
+  AddressType,
+  type EthFetchConfig,
+  EthFetchConfigSchema,
+  type PreprocessResult,
+  PreprocessResultSchema,
+  ProcessResultSchema,
+  timestampDate
+} from '@sentio/protos'
+import { create } from '@bufbuild/protobuf'
+import { ConnectError, Code } from '@connectrpc/connect'
 
 import { PartiallyOptional, PromiseOrVoid } from '../core/index.js'
 
@@ -12,7 +22,6 @@ import { Block } from 'ethers'
 import { AccountProcessorState } from './account-processor-state.js'
 import { fixEmptyKey, formatEthData, TypedEvent, validateAndNormalizeAddress } from './eth.js'
 import { EthChainId } from '@sentio/chain'
-import { ServerError, Status } from 'nice-grpc'
 import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
 
 const ERC20_INTERFACE = ERC20__factory.createInterface()
@@ -258,7 +267,7 @@ export class AccountProcessor {
   protected onEvent(
     handler: (event: TypedEvent, ctx: AccountContext) => PromiseOrVoid,
     filter: AddressOrTypeEventFilter | AddressOrTypeEventFilter[],
-    fetchConfig?: Partial<EthFetchConfig>,
+    fetchConfig?: Omit<Partial<EthFetchConfig>, '$typeName' | '$unknown'>,
     preprocessHandler: (
       event: TypedEvent,
       ctx: AccountContext,
@@ -295,19 +304,19 @@ export class AccountProcessor {
 
     this.eventHandlers.push({
       filters: _filters,
-      fetchConfig: EthFetchConfig.fromPartial(fetchConfig || {}),
+      fetchConfig: create(EthFetchConfigSchema, fetchConfig || {}),
       handlerName: getHandlerName(),
       handler: async function (data) {
         const { log, block, transaction, transactionReceipt } = formatEthData(data)
         if (!log) {
-          throw new ServerError(Status.INVALID_ARGUMENT, 'Log is empty')
+          throw new ConnectError('Log is empty', Code.InvalidArgument)
         }
         // const log = data.log as { topics: Array<string>; data: string }
         const ctx = new AccountContext(
           chainId,
           config.address,
-          data.timestamp,
-          data.block as Block,
+          data.timestamp ? timestampDate(data.timestamp) : undefined,
+          block as Block,
           log,
           undefined,
           transaction,
@@ -321,19 +330,19 @@ export class AccountProcessor {
           await handler(event, ctx)
           return ctx.stopAndGetResult()
         }
-        return ProcessResult.fromPartial({})
+        return create(ProcessResultSchema)
       },
       preprocessHandler: async function (data, preprocessStore: { [k: string]: any }) {
         const { log, block, transaction, transactionReceipt } = formatEthData(data)
         if (!log) {
-          throw new ServerError(Status.INVALID_ARGUMENT, 'Log is empty')
+          throw new ConnectError('Log is empty', Code.InvalidArgument)
         }
         // const log = data.log as { topics: Array<string>; data: string }
         const ctx = new AccountContext(
           chainId,
           config.address,
-          data.timestamp,
-          data.block as Block,
+          data.timestamp ? timestampDate(data.timestamp) : undefined,
+          block as Block,
           log,
           undefined,
           transaction,
@@ -346,7 +355,7 @@ export class AccountProcessor {
           const event: TypedEvent = new TypedEvent(log, parsed.name, fixEmptyKey(parsed))
           return preprocessHandler(event, ctx, preprocessStore)
         }
-        return PreprocessResult.fromPartial({})
+        return create(PreprocessResultSchema)
       }
     })
 

package/src/eth/base-processor-template.ts

@@ -2,7 +2,16 @@ import { BoundContractView, ContractContext, ContractView, EthContext } from './
 import { BaseContract } from 'ethers'
 import { BaseProcessor, defaultPreprocessHandler } from './base-processor.js'
 import { BindOptions, getOptionsSignature } from './bind-options.js'
-import { EthFetchConfig, HandleInterval, TemplateInstance, PreprocessResult } from '@sentio/protos'
+import {
+  type EthFetchConfig,
+  EthFetchConfigSchema,
+  type HandleInterval,
+  HandleIntervalSchema,
+  type TemplateInstance,
+  TemplateInstanceSchema,
+  type PreprocessResult
+} from '@sentio/protos'
+import { create } from '@bufbuild/protobuf'
 import { PromiseOrVoid } from '../core/promises.js'
 import { ListStateStorage, processMetrics } from '@sentio/runtime'
 import { BlockParams } from 'ethers/providers'
@@ -62,7 +71,11 @@ export abstract class BaseProcessorTemplate<
 
   constructor() {
     this.id = ProcessorTemplateProcessorState.INSTANCE.getValues().length
-    ProcessorTemplateProcessorState.INSTANCE.addValue(this)
+    // Stored type-erased as the base instantiation; the concrete type parameters only appear in
+    // handler parameter positions, which `strictFunctionTypes` checks contravariantly.
+    ProcessorTemplateProcessorState.INSTANCE.addValue(
+      this as unknown as BaseProcessorTemplate<BaseContract, BoundContractView<BaseContract, any>>
+    )
     return proxyProcessor(this)
   }
 
@@ -74,7 +87,7 @@ export abstract class BaseProcessorTemplate<
   public bind(options: Omit<BindOptions, 'network'>, ctx: EthContext): void {
     options = { ...options, address: validateAndNormalizeAddress(options.address) }
 
-    const instance: TemplateInstance = {
+    const instance: TemplateInstance = create(TemplateInstanceSchema, {
       templateId: this.id,
       contract: {
         address: options.address,
@@ -85,7 +98,7 @@ export abstract class BaseProcessorTemplate<
       startBlock: BigInt(options.startBlock || 0),
       endBlock: BigInt(options.endBlock || 0),
       baseLabels: options.baseLabels
-    }
+    })
 
     ctx.sendTemplateInstance(instance)
 
@@ -137,7 +150,7 @@ export abstract class BaseProcessorTemplate<
   protected onEthEvent(
     handler: (event: TypedEvent, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
     filter: DeferredTopicFilter | DeferredTopicFilter[],
-    fetchConfig?: Partial<EthFetchConfig>,
+    fetchConfig?: Omit<Partial<EthFetchConfig>, '$typeName' | '$unknown'>,
     preprocessHandler: (
       event: TypedEvent,
       ctx: ContractContext<TContract, TBoundContractView>,
@@ -149,7 +162,7 @@ export abstract class BaseProcessorTemplate<
       handler: handler,
       preprocessHandler,
       filter: filter,
-      fetchConfig: EthFetchConfig.fromPartial(fetchConfig || {})
+      fetchConfig: create(EthFetchConfigSchema, fetchConfig || {})
     })
     return this
   }
@@ -168,10 +181,10 @@ export abstract class BaseProcessorTemplate<
     return this.onInterval(
       handler,
       undefined,
-      {
+      create(HandleIntervalSchema, {
         recentInterval: blockInterval,
         backfillInterval: backfillBlockInterval
-      },
+      }),
       fetchConfig,
       preprocessHandler
     )
@@ -190,7 +203,10 @@ export abstract class BaseProcessorTemplate<
   ) {
     return this.onInterval(
       handler,
-      { recentInterval: timeIntervalInMinutes, backfillInterval: backfillTimeIntervalInMinutes },
+      create(HandleIntervalSchema, {
+        recentInterval: timeIntervalInMinutes,
+        backfillInterval: backfillTimeIntervalInMinutes
+      }),
       undefined,
       fetchConfig,
       preprocessHandler
@@ -222,7 +238,7 @@ export abstract class BaseProcessorTemplate<
   public onTrace(
     signature: string,
     handler: (trace: TypedCallTrace, ctx: ContractContext<TContract, TBoundContractView>) => PromiseOrVoid,
-    fetchConfig?: Partial<EthFetchConfig>,
+    fetchConfig?: Omit<Partial<EthFetchConfig>, '$typeName' | '$unknown'>,
     preprocessHandler: (
       trace: TypedCallTrace,
       ctx: ContractContext<TContract, TBoundContractView>,
@@ -234,7 +250,7 @@ export abstract class BaseProcessorTemplate<
       handlerName: getHandlerName(),
       handler,
       preprocessHandler,
-      fetchConfig: EthFetchConfig.fromPartial(fetchConfig || {})
+      fetchConfig: create(EthFetchConfigSchema, fetchConfig || {})
     })
     return this
   }