@sentio/sdk 1.29.1 → 1.30.0

package/src/core/meter.ts

@@ -1,7 +1,7 @@
 import { BaseContext } from './base-context'
 import { toMetricValue, Numberish } from './numberish'
-import { DescriptorWithUsage, Labels } from './metadata'
-import { DataDescriptor } from '../gen'
+import { Labels, NamedResultDescriptor } from './metadata'
+import { AggregationConfig, MetricConfig } from '../gen'
 
 export function normalizeName(name: string): string {
   const regex = new RegExp('![_.a-zA-Z0-9]')
@@ -27,36 +27,29 @@ export function normalizeLabels(labels: Labels): Labels {
   return normLabels
 }
 
-export class MetricDescriptorOptions {
+export class MetricOptions {
   unit?: string
   description?: string
   sparse?: boolean
-  resolutionInSeconds?: number
+  aggregationConfig?: Partial<AggregationConfig>
 }
 
-export class Metric extends DescriptorWithUsage {
-  constructor(name: string, option?: MetricDescriptorOptions) {
-    const descriptor = DataDescriptor.fromPartial({ name })
-    if (option) {
-      if (option.unit) {
-        descriptor.unit = option.unit
-      }
-      if (option.description) {
-        descriptor.description = option.description
-      }
-      if (option.sparse) {
-        descriptor.sparse = option.sparse
-      }
-      if (option.resolutionInSeconds) {
-        descriptor.resolutionInSeconds = option.resolutionInSeconds
-      }
-    }
-    super(descriptor)
+export class CounterOptions {
+  unit?: string
+  description?: string
+  sparse?: boolean
+}
+
+export class Metric extends NamedResultDescriptor {
+  descriptor: MetricConfig
+  constructor(name: string, option?: MetricOptions) {
+    super(name)
+    this.descriptor = MetricConfig.fromPartial({ name: this.name, ...option })
   }
 }
 
 export class Counter extends Metric {
-  static register(name: string, option?: MetricDescriptorOptions): Counter {
+  static register(name: string, option?: CounterOptions): Counter {
     // TODO also dedup
     const metric = new Counter(name, option)
     global.PROCESSOR_STATE.metrics.push(metric)
@@ -73,12 +66,11 @@ export class Counter extends Metric {
 
   private record(ctx: BaseContext, value: Numberish, labels: Labels, add: boolean) {
     ctx.res.counters.push({
-      metadata: ctx.getMetaData(this.getShortDescriptor(), labels),
+      metadata: ctx.getMetaData(this.name, labels),
       metricValue: toMetricValue(value),
       add: add,
       runtimeInfo: undefined,
     })
-    this.usage++
   }
 }
 
@@ -101,7 +93,7 @@ export class CounterBinding {
 }
 
 export class Gauge extends Metric {
-  static register(name: string, option?: MetricDescriptorOptions): Gauge {
+  static register(name: string, option?: MetricOptions): Gauge {
     // TODO also dedup
     const metric = new Gauge(name, option)
     global.PROCESSOR_STATE.metrics.push(metric)
@@ -110,11 +102,10 @@ export class Gauge extends Metric {
 
   record(ctx: BaseContext, value: Numberish, labels: Labels = {}) {
     ctx.res.gauges.push({
-      metadata: ctx.getMetaData(this.getShortDescriptor(), labels),
+      metadata: ctx.getMetaData(this.descriptor.name, labels),
       metricValue: toMetricValue(value),
       runtimeInfo: undefined,
     })
-    this.usage++
   }
 }
 

package/src/gen/chainquery/protos/chainquery.ts

@@ -40,7 +40,7 @@ export interface QueryExecutionSummary {
 
 export interface AptosGetTxnsResponse {
   documents: string[];
-  executionSummary: QueryExecutionSummary | undefined;
+  executionSummary?: QueryExecutionSummary | undefined;
 }
 
 export interface AptosRefreshRequest {}
@@ -728,6 +728,14 @@ export const AptosQueryDefinition = {
       responseStream: false,
       options: {},
     },
+    aptosGetTxnsByFunctionStream: {
+      name: "AptosGetTxnsByFunctionStream",
+      requestType: AptosGetTxnsByFunctionRequest,
+      requestStream: false,
+      responseType: AptosGetTxnsResponse,
+      responseStream: true,
+      options: {},
+    },
     aptosGetTxnsByVersion: {
       name: "AptosGetTxnsByVersion",
       requestType: AptosGetTxnsByVersionRequest,
@@ -744,6 +752,14 @@ export const AptosQueryDefinition = {
       responseStream: false,
       options: {},
     },
+    aptosGetTxnsByEventStream: {
+      name: "AptosGetTxnsByEventStream",
+      requestType: AptosGetTxnsByEventRequest,
+      requestStream: false,
+      responseType: AptosGetTxnsResponse,
+      responseStream: true,
+      options: {},
+    },
     aptosRefresh: {
       name: "AptosRefresh",
       requestType: AptosRefreshRequest,
@@ -768,6 +784,10 @@ export interface AptosQueryServiceImplementation<CallContextExt = {}> {
     request: AptosGetTxnsByFunctionRequest,
     context: CallContext & CallContextExt
   ): Promise<DeepPartial<AptosGetTxnsResponse>>;
+  aptosGetTxnsByFunctionStream(
+    request: AptosGetTxnsByFunctionRequest,
+    context: CallContext & CallContextExt
+  ): ServerStreamingMethodResult<DeepPartial<AptosGetTxnsResponse>>;
   aptosGetTxnsByVersion(
     request: AptosGetTxnsByVersionRequest,
     context: CallContext & CallContextExt
@@ -776,6 +796,10 @@ export interface AptosQueryServiceImplementation<CallContextExt = {}> {
     request: AptosGetTxnsByEventRequest,
     context: CallContext & CallContextExt
   ): Promise<DeepPartial<AptosGetTxnsResponse>>;
+  aptosGetTxnsByEventStream(
+    request: AptosGetTxnsByEventRequest,
+    context: CallContext & CallContextExt
+  ): ServerStreamingMethodResult<DeepPartial<AptosGetTxnsResponse>>;
   aptosRefresh(
     request: AptosRefreshRequest,
     context: CallContext & CallContextExt
@@ -791,6 +815,10 @@ export interface AptosQueryClient<CallOptionsExt = {}> {
     request: DeepPartial<AptosGetTxnsByFunctionRequest>,
     options?: CallOptions & CallOptionsExt
   ): Promise<AptosGetTxnsResponse>;
+  aptosGetTxnsByFunctionStream(
+    request: DeepPartial<AptosGetTxnsByFunctionRequest>,
+    options?: CallOptions & CallOptionsExt
+  ): AsyncIterable<AptosGetTxnsResponse>;
   aptosGetTxnsByVersion(
     request: DeepPartial<AptosGetTxnsByVersionRequest>,
     options?: CallOptions & CallOptionsExt
@@ -799,6 +827,10 @@ export interface AptosQueryClient<CallOptionsExt = {}> {
     request: DeepPartial<AptosGetTxnsByEventRequest>,
     options?: CallOptions & CallOptionsExt
   ): Promise<AptosGetTxnsResponse>;
+  aptosGetTxnsByEventStream(
+    request: DeepPartial<AptosGetTxnsByEventRequest>,
+    options?: CallOptions & CallOptionsExt
+  ): AsyncIterable<AptosGetTxnsResponse>;
   aptosRefresh(
     request: DeepPartial<AptosRefreshRequest>,
     options?: CallOptions & CallOptionsExt
@@ -838,3 +870,7 @@ if (_m0.util.Long !== Long) {
 function isSet(value: any): boolean {
   return value !== null && value !== undefined;
 }
+
+export type ServerStreamingMethodResult<Response> = {
+  [Symbol.asyncIterator](): AsyncIterator<Response, void>;
+};

package/src/gen/processor/protos/processor.ts

@@ -4,6 +4,39 @@ import Long from "long";
 import { Empty } from "../../google/protobuf/empty";
 import _m0 from "protobufjs/minimal";
 
+export enum AggregationType {
+  COUNT = 0,
+  SUM = 1,
+  UNRECOGNIZED = -1,
+}
+
+export function aggregationTypeFromJSON(object: any): AggregationType {
+  switch (object) {
+    case 0:
+    case "COUNT":
+      return AggregationType.COUNT;
+    case 1:
+    case "SUM":
+      return AggregationType.SUM;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return AggregationType.UNRECOGNIZED;
+  }
+}
+
+export function aggregationTypeToJSON(object: AggregationType): string {
+  switch (object) {
+    case AggregationType.COUNT:
+      return "COUNT";
+    case AggregationType.SUM:
+      return "SUM";
+    case AggregationType.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
 export enum HandlerType {
   UNKNOWN = 0,
   ETH_LOG = 1,
@@ -225,6 +258,13 @@ export interface MetricConfig {
   unit: string;
   sparse: boolean;
   resolutionInSeconds: number;
+  aggregationConfig: AggregationConfig | undefined;
+}
+
+export interface AggregationConfig {
+  intervalInMinutes: number;
+  types: AggregationType[];
+  discardOrigin: boolean;
 }
 
 export interface AccountConfig {
@@ -1353,6 +1393,7 @@ function createBaseMetricConfig(): MetricConfig {
     unit: "",
     sparse: false,
     resolutionInSeconds: 0,
+    aggregationConfig: undefined,
   };
 }
 
@@ -1376,6 +1417,12 @@ export const MetricConfig = {
     if (message.resolutionInSeconds !== 0) {
       writer.uint32(40).int32(message.resolutionInSeconds);
     }
+    if (message.aggregationConfig !== undefined) {
+      AggregationConfig.encode(
+        message.aggregationConfig,
+        writer.uint32(50).fork()
+      ).ldelim();
+    }
     return writer;
   },
 
@@ -1401,6 +1448,12 @@ export const MetricConfig = {
         case 5:
           message.resolutionInSeconds = reader.int32();
           break;
+        case 6:
+          message.aggregationConfig = AggregationConfig.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -1418,6 +1471,9 @@ export const MetricConfig = {
       resolutionInSeconds: isSet(object.resolutionInSeconds)
         ? Number(object.resolutionInSeconds)
         : 0,
+      aggregationConfig: isSet(object.aggregationConfig)
+        ? AggregationConfig.fromJSON(object.aggregationConfig)
+        : undefined,
     };
   },
 
@@ -1430,6 +1486,10 @@ export const MetricConfig = {
     message.sparse !== undefined && (obj.sparse = message.sparse);
     message.resolutionInSeconds !== undefined &&
       (obj.resolutionInSeconds = Math.round(message.resolutionInSeconds));
+    message.aggregationConfig !== undefined &&
+      (obj.aggregationConfig = message.aggregationConfig
+        ? AggregationConfig.toJSON(message.aggregationConfig)
+        : undefined);
     return obj;
   },
 
@@ -1440,6 +1500,102 @@ export const MetricConfig = {
     message.unit = object.unit ?? "";
     message.sparse = object.sparse ?? false;
     message.resolutionInSeconds = object.resolutionInSeconds ?? 0;
+    message.aggregationConfig =
+      object.aggregationConfig !== undefined &&
+      object.aggregationConfig !== null
+        ? AggregationConfig.fromPartial(object.aggregationConfig)
+        : undefined;
+    return message;
+  },
+};
+
+function createBaseAggregationConfig(): AggregationConfig {
+  return { intervalInMinutes: 0, types: [], discardOrigin: false };
+}
+
+export const AggregationConfig = {
+  encode(
+    message: AggregationConfig,
+    writer: _m0.Writer = _m0.Writer.create()
+  ): _m0.Writer {
+    if (message.intervalInMinutes !== 0) {
+      writer.uint32(8).int32(message.intervalInMinutes);
+    }
+    writer.uint32(18).fork();
+    for (const v of message.types) {
+      writer.int32(v);
+    }
+    writer.ldelim();
+    if (message.discardOrigin === true) {
+      writer.uint32(24).bool(message.discardOrigin);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): AggregationConfig {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAggregationConfig();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.intervalInMinutes = reader.int32();
+          break;
+        case 2:
+          if ((tag & 7) === 2) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.types.push(reader.int32() as any);
+            }
+          } else {
+            message.types.push(reader.int32() as any);
+          }
+          break;
+        case 3:
+          message.discardOrigin = reader.bool();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): AggregationConfig {
+    return {
+      intervalInMinutes: isSet(object.intervalInMinutes)
+        ? Number(object.intervalInMinutes)
+        : 0,
+      types: Array.isArray(object?.types)
+        ? object.types.map((e: any) => aggregationTypeFromJSON(e))
+        : [],
+      discardOrigin: isSet(object.discardOrigin)
+        ? Boolean(object.discardOrigin)
+        : false,
+    };
+  },
+
+  toJSON(message: AggregationConfig): unknown {
+    const obj: any = {};
+    message.intervalInMinutes !== undefined &&
+      (obj.intervalInMinutes = Math.round(message.intervalInMinutes));
+    if (message.types) {
+      obj.types = message.types.map((e) => aggregationTypeToJSON(e));
+    } else {
+      obj.types = [];
+    }
+    message.discardOrigin !== undefined &&
+      (obj.discardOrigin = message.discardOrigin);
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<AggregationConfig>): AggregationConfig {
+    const message = createBaseAggregationConfig();
+    message.intervalInMinutes = object.intervalInMinutes ?? 0;
+    message.types = object.types?.map((e) => e) || [];
+    message.discardOrigin = object.discardOrigin ?? false;
     return message;
   },
 };

package/src/service.ts

@@ -34,7 +34,6 @@ import { TextDecoder } from 'util'
 import { Trace } from './core'
 import { Instruction } from '@project-serum/anchor'
 import { MoveResourcesWithVersionPayload } from './aptos/aptos-processor'
-
 ;(BigInt.prototype as any).toJSON = function () {
   return this.toString()
 }
@@ -110,7 +109,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     for (const eventTracker of global.PROCESSOR_STATE.eventTrackers) {
       this.eventTrackingConfigs.push({
         distinctAggregationByDays: eventTracker.options.distinctByDays || [],
-        eventName: eventTracker.eventName,
+        eventName: eventTracker.name,
         retentionConfig: undefined,
         totalByDay: eventTracker.options.totalByDay || false,
         totalPerEntity: undefined,

package/src/testing/metric-utils.ts

@@ -1,9 +1,8 @@
-import { DeepPartial } from '../gen/builtin'
 import { MetricValue, ProcessResult } from '../gen'
 import { Numberish, BigDecimal } from '../core'
 import { BigNumber } from 'ethers'
 
-export function MetricValueToNumber(v: DeepPartial<MetricValue> | undefined): Numberish | undefined {
+export function MetricValueToNumber(v: Partial<MetricValue> | undefined): Numberish | undefined {
   if (v === undefined) {
     return undefined
   }
@@ -29,7 +28,7 @@ export function firstCounterValue(result: ProcessResult | undefined, name: strin
     return undefined
   }
   for (const counter of result.counters) {
-    if (counter.metadata?.dataDescriptor?.name === name) {
+    if (counter.metadata?.name === name) {
       return MetricValueToNumber(counter.metricValue)
     }
   }
@@ -41,7 +40,7 @@ export function firstGaugeValue(result: ProcessResult | undefined, name: string)
     return undefined
   }
   for (const gauge of result.gauges) {
-    if (gauge.metadata?.dataDescriptor?.name === name) {
+    if (gauge.metadata?.name === name) {
       return MetricValueToNumber(gauge.metricValue)
     }
   }

package/templates/evm/src/processor.ts

@@ -3,7 +3,7 @@ import { token } from '@sentio/sdk/lib/utils'
 import { ERC20Processor } from '@sentio/sdk/lib/builtin/erc20'
 import { X2y2Processor } from './types/x2y2'
 
-const rewardPerBlock = new Gauge('reward_per_block', {
+const rewardPerBlock = Gauge.register('reward_per_block', {
   description: 'rewards for each block grouped by phase',
   unit: 'x2y2',
 })