@sentio/sdk 2.59.0-rc.4 → 2.59.0-rc.40

package/src/core/meter.ts

@@ -1,7 +1,13 @@
 import { BaseContext } from './base-context.js'
-import { Numberish, toMetricValue } from './numberish.js'
+import { Numberish, toMetricValue, toTimeSeriesData } from './numberish.js'
 import { NamedResultDescriptor } from './metadata.js'
-import { AggregationConfig, AggregationType, MetricConfig, MetricType } from '@sentio/protos'
+import {
+  AggregationConfig,
+  AggregationType,
+  MetricConfig,
+  MetricType,
+  TimeseriesResult_TimeseriesType
+} from '@sentio/protos'
 import { MapStateStorage, processMetrics } from '@sentio/runtime'
 
 export type Labels = { [key: string]: string }
@@ -30,6 +36,7 @@ export class CounterOptions {
 
 export class Metric extends NamedResultDescriptor {
   config: MetricConfig
+
   constructor(type: MetricType, name: string, option?: MetricConfig) {
     super(name)
     this.config = MetricConfig.fromPartial({ ...option, name: this.name, type })
@@ -67,6 +74,28 @@ export class MetricState extends MapStateStorage<Metric> {
   }
 }
 
+export class MetricStateNew extends MapStateStorage<Metric> {
+  static INSTANCE = new MetricStateNew()
+
+  getOrRegisterMetric(type: MetricType, name: string, option?: CounterOptions | MetricOptions): Metric {
+    const metricMap = this.getOrRegister()
+    let metric = metricMap.get(name)
+    if (metric && metric.config.type !== type) {
+      throw Error(`redefine ${name} of metric type ${type} that is previously ${metric.config.type}`)
+    }
+
+    if (!metric) {
+      if (type === MetricType.COUNTER) {
+        metric = CounterNew._create(name, option)
+      } else {
+        metric = GaugeNew._create(name, option)
+      }
+    }
+    metricMap.set(name, metric)
+    return metric
+  }
+}
+
 export class Counter extends Metric {
   static register(name: string, option?: CounterOptions): Counter {
     return MetricState.INSTANCE.getOrRegisterMetric(MetricType.COUNTER, name, option) as Counter
@@ -79,7 +108,7 @@ export class Counter extends Metric {
     return new Counter(name, option)
   }
 
-  private constructor(name: string, option?: CounterOptions) {
+  protected constructor(name: string, option?: CounterOptions) {
     super(
       MetricType.COUNTER,
       name,
@@ -145,7 +174,7 @@ export class Gauge extends Metric {
     return new Gauge(name, option)
   }
 
-  private constructor(name: string, option?: MetricOptions) {
+  protected constructor(name: string, option?: MetricOptions) {
     super(MetricType.GAUGE, name, MetricConfig.fromPartial({ ...option }))
   }
 
@@ -192,3 +221,129 @@ export class Meter {
     return new GaugeBinding(name, this.ctx)
   }
 }
+
+export class MeterNew {
+  private readonly ctx: BaseContext
+
+  constructor(ctx: BaseContext) {
+    this.ctx = ctx
+  }
+
+  Counter(name: string) {
+    return new CounterNewBinding(name, this.ctx)
+  }
+
+  Gauge(name: string) {
+    return new GaugeNewBinding(name, this.ctx)
+  }
+}
+
+export class CounterNew extends Counter {
+  static register(name: string, option?: CounterOptions): CounterNew {
+    return MetricStateNew.INSTANCE.getOrRegisterMetric(MetricType.COUNTER, name, option) as CounterNew
+  }
+
+  /**
+   * internal use only, to create a metric use {@link register} instead
+   */
+  static _create(name: string, option?: CounterOptions): CounterNew {
+    return new CounterNew(name, option)
+  }
+
+  private constructor(name: string, option?: CounterOptions) {
+    super(
+      name,
+      MetricConfig.fromPartial({
+        ...option,
+        aggregationConfig: {
+          intervalInMinutes: option?.resolutionConfig ? [option?.resolutionConfig?.intervalInMinutes] : []
+        }
+      })
+    )
+  }
+
+  add(ctx: BaseContext, value: Numberish, labels: Labels = {}) {
+    this.recordNew(ctx, value, labels, true)
+  }
+
+  sub(ctx: BaseContext, value: Numberish, labels: Labels = {}) {
+    this.recordNew(ctx, value, labels, false)
+  }
+
+  private recordNew(ctx: BaseContext, value: Numberish, labels: Labels, add: boolean) {
+    processMetrics.process_metricrecord_count.add(1)
+    ctx.update({
+      timeseriesResult: [
+        {
+          metadata: ctx.getMetaData(this.name, labels),
+          type: TimeseriesResult_TimeseriesType.COUNTER,
+          data: toTimeSeriesData(value, labels, !add),
+          runtimeInfo: undefined
+        }
+      ]
+    })
+  }
+}
+
+export class GaugeNewBinding {
+  private readonly gauge: GaugeNew
+  private readonly ctx: BaseContext
+
+  constructor(name: string, ctx: BaseContext) {
+    this.gauge = GaugeNew._create(name)
+    this.ctx = ctx
+  }
+
+  record(value: Numberish, labels: Labels = {}) {
+    this.gauge.record(this.ctx, value, labels)
+  }
+}
+
+export class CounterNewBinding {
+  private readonly counter: CounterNew
+  private readonly ctx: BaseContext
+
+  constructor(name: string, ctx: BaseContext) {
+    this.counter = CounterNew._create(name)
+    this.ctx = ctx
+  }
+
+  add(value: Numberish, labels: Labels = {}) {
+    this.counter.add(this.ctx, value, labels)
+  }
+
+  sub(value: Numberish, labels: Labels = {}) {
+    this.counter.sub(this.ctx, value, labels)
+  }
+}
+
+export class GaugeNew extends Gauge {
+  static register(name: string, option?: MetricOptions): Gauge {
+    return MetricStateNew.INSTANCE.getOrRegisterMetric(MetricType.GAUGE, name, option) as Gauge
+  }
+
+  /**
+   * internal use only, to create a metric use {@link register} instead
+   */
+  static _create(name: string, option?: MetricOptions): GaugeNew {
+    return new GaugeNew(name, option)
+  }
+
+  private constructor(name: string, option?: MetricOptions) {
+    super(name, MetricConfig.fromPartial({ ...option }))
+  }
+
+  record(ctx: BaseContext, value: Numberish, labels: Labels = {}) {
+    processMetrics.process_metricrecord_count.add(1)
+    ctx.update({
+      timeseriesResult: [
+        {
+          metadata: ctx.getMetaData(this.name, labels),
+          type: TimeseriesResult_TimeseriesType.GAUGE,
+          data: toTimeSeriesData(value, labels, false),
+          runtimeInfo: undefined
+        }
+      ]
+    })
+  }
+}

package/src/core/numberish.ts

@@ -1,4 +1,4 @@
-import { BigDecimalRichValue, BigInteger, MetricValue } from '@sentio/protos'
+import { BigDecimalRichValue, BigInteger, MetricValue, RichStruct, RichValue_NullValue } from '@sentio/protos'
 import { BigDecimal } from './big-decimal.js'
 
 export type Numberish = number | bigint | BigDecimal | string
@@ -120,3 +120,36 @@ export function toBigDecimal(value: BigDecimal): BigDecimalRichValue {
     exp: exp
   }
 }
+
+export function toTimeSeriesData(value: Numberish, labels: Record<string, string>, neg: boolean) {
+  const mv = toMetricValue(value)
+  const data: RichStruct = {
+    fields: {
+      value: {}
+    }
+  }
+
+  for (const key in labels) {
+    if (labels[key] == null) {
+      data.fields[key] = { nullValue: RichValue_NullValue.NULL_VALUE }
+    } else {
+      data.fields[key] = { stringValue: 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 (neg) {
+      v = v.negated()
+    }
+    data.fields.value.bigdecimalValue = toBigDecimal(v)
+  } else if (mv.doubleValue != null) {
+    data.fields.value.floatValue = neg ? -mv.doubleValue : mv.doubleValue
+  } else {
+    data.fields.value.nullValue = RichValue_NullValue.NULL_VALUE
+  }
+  return data
+}

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

@@ -0,0 +1,94 @@
+import {
+  HandlerType,
+  ProcessStreamResponse_Partitions_Partition,
+  ProcessStreamResponse_Partitions_Partition_SysValue
+} from '@sentio/protos'
+import { ServerError, Status } from 'nice-grpc'
+
+/**
+ * Type for partition handler functions that can process any data type
+ */
+export type PartitionHandler = (request: any) => Promise<string | undefined>
+
+/**
+ * Generic manager for handling partition logic across all chain plugins.
+ * Provides a unified interface for registering, storing, and processing partition handlers.
+ * Chain-specific logic should remain in individual plugins.
+ */
+export class PartitionHandlerManager {
+  private partitionHandlers: Map<HandlerType, Record<number, PartitionHandler>> = new Map()
+
+  /**
+   * Register a partition handler for a specific handler type and ID
+   * @param handlerType The type of handler (e.g., HandlerType.ETH_LOG, HandlerType.APT_EVENT)
+   * @param handlerId The unique ID for this handler instance
+   * @param partitionHandler The partition handler function (optional)
+   */
+  registerPartitionHandler(handlerType: HandlerType, handlerId: number, partitionHandler?: PartitionHandler): void {
+    if (partitionHandler) {
+      const existingHandlers = this.partitionHandlers.get(handlerType) || {}
+      existingHandlers[handlerId] = partitionHandler
+      this.partitionHandlers.set(handlerType, existingHandlers)
+    }
+  }
+
+  /**
+   * Process partition logic for a specific handler type
+   * @param handlerType The type of handler being processed
+   * @param handlerIds Array of handler IDs to process
+   * @param data The data to pass to partition handlers
+   * @returns Record mapping handler IDs to partition results
+   */
+  async processPartitionForHandlerType(
+    handlerType: HandlerType,
+    handlerIds: number[],
+    data: any
+  ): Promise<Record<number, ProcessStreamResponse_Partitions_Partition>> {
+    const result: Record<number, ProcessStreamResponse_Partitions_Partition> = {}
+
+    for (const handlerId of handlerIds) {
+      const partitionHandler = this.partitionHandlers.get(handlerType)?.[handlerId]
+      if (partitionHandler && data) {
+        try {
+          const partitionValue = await partitionHandler(data)
+          result[handlerId] = {
+            userValue: partitionValue
+          }
+        } catch (error) {
+          // If partition handler fails, fall back to unrecognized
+          throw new ServerError(Status.INVALID_ARGUMENT, 'compute partition key failed, error:' + error.message)
+        }
+      } else {
+        result[handlerId] = {
+          sysValue: ProcessStreamResponse_Partitions_Partition_SysValue.UNRECOGNIZED
+        }
+      }
+    }
+
+    return result
+  }
+
+  /**
+   * Clear all partition handlers (useful for testing or reinitialization)
+   */
+  clear(): void {
+    this.partitionHandlers.clear()
+  }
+
+  /**
+   * Get all registered handler types
+   * @returns Array of handler types that have registered partition handlers
+   */
+  getRegisteredHandlerTypes(): HandlerType[] {
+    return Array.from(this.partitionHandlers.keys())
+  }
+
+  /**
+   * Get the number of registered handlers for a specific handler type
+   * @param handlerType The handler type to check
+   * @returns Number of registered handlers for this type
+   */
+  getHandlerCount(handlerType: HandlerType): number {
+    return Object.keys(this.partitionHandlers.get(handlerType) || {}).length
+  }
+}

package/src/cosmos/cosmos-processor.ts

@@ -3,6 +3,7 @@ import { Data_CosmosCall } from '@sentio/protos'
 import { CosmosContext } from './context.js'
 import { CosmosEvent, CosmosTransaction, CosmosTxLog } from './transaction.js'
 import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
+import { HandlerOptions } from '../core/handler-options.js'
 
 export class CosmosProcessor {
   callHandlers: CallHandler<Data_CosmosCall>[] = []
@@ -19,7 +20,8 @@ export class CosmosProcessor {
 
   public onLogEvent(
     logFilters: string[] | string,
-    handler: (log: CosmosTxLog, event: CosmosEvent, context: CosmosContext) => void | Promise<void>
+    handler: (log: CosmosTxLog, event: CosmosEvent, context: CosmosContext) => void | Promise<void>,
+    handlerOptions?: HandlerOptions<object, CosmosTransaction>
   ) {
     const filter = Array.isArray(logFilters) ? logFilters : [logFilters]
     const callHandler = {
@@ -39,6 +41,15 @@ export class CosmosProcessor {
       },
       logConfig: {
         logFilters: filter
+      },
+      partitionHandler: async (call: Data_CosmosCall): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const transaction = call.transaction as CosmosTransaction
+          return p(transaction)
+        }
+        return p
       }
     }
     this.callHandlers.push(callHandler)

package/src/cosmos/types.ts

@@ -13,6 +13,7 @@ export type CallHandler<T> = {
   logConfig?: {
     logFilters: string[]
   }
+  partitionHandler?: (call: T) => Promise<string | undefined>
 }
 
 export type CosmosProcessorConfig = {