@sentio/sdk 1.20.2 → 1.21.1

package/src/core/context.ts

@@ -1,4 +1,4 @@
-import { CounterResult, GaugeResult, LogResult, MetricDescriptor, RecordMetaData } from '../gen'
+import { CounterResult, GaugeResult, LogResult, DataDescriptor, RecordMetaData } from '../gen'
 import { BaseContract, EventFilter } from 'ethers'
 import { Block, Log } from '@ethersproject/abstract-provider'
 import { Meter, normalizeLabels } from './meter'
@@ -20,18 +20,19 @@ export abstract class BaseContext {
     this.logger = new Logger(this)
   }
 
-  abstract getMetaData(descriptor: MetricDescriptor | undefined, labels: Labels): RecordMetaData
+  abstract getMetaData(descriptor: DataDescriptor | undefined, labels: Labels): RecordMetaData
 }
 
 export abstract class EthContext extends BaseContext {
   chainId: number
+  address: string
   log?: Log
   block?: Block
   trace?: Trace
   blockNumber: Long
   transactionHash?: string
 
-  protected constructor(chainId: number, block?: Block, log?: Log, trace?: Trace) {
+  protected constructor(chainId: number, address: string, block?: Block, log?: Log, trace?: Trace) {
     super()
     this.chainId = chainId
     this.log = log
@@ -49,54 +50,64 @@ export abstract class EthContext extends BaseContext {
   }
 }
 
-export class Context<
+export class ContractContext<
   TContract extends BaseContract,
   TContractBoundView extends BoundContractView<TContract, ContractView<TContract>>
 > extends EthContext {
   contract: TContractBoundView
-  address: string
-
-  constructor(view: TContractBoundView, chainId: number, block?: Block, log?: Log, trace?: Trace) {
-    super(chainId, block, log, trace)
+  contractName: string
+
+  constructor(
+    contractName: string,
+    view: TContractBoundView,
+    chainId: number,
+    block?: Block,
+    log?: Log,
+    trace?: Trace
+  ) {
+    super(chainId, view.rawContract.address, block, log, trace)
     view.context = this
+    this.contractName = contractName
     this.contract = view
-    this.address = view.rawContract.address
   }
 
-  getMetaData(descriptor: MetricDescriptor | undefined, labels: Labels): RecordMetaData {
+  getMetaData(descriptor: DataDescriptor | undefined, labels: Labels): RecordMetaData {
     if (this.log) {
       return {
-        contractAddress: this.contract.rawContract.address,
+        address: this.contract.rawContract.address,
+        contractName: this.contractName,
         blockNumber: this.blockNumber,
         transactionIndex: this.log.transactionIndex,
         transactionHash: this.transactionHash || '',
         logIndex: this.log.logIndex,
         chainId: this.chainId.toString(),
-        descriptor: descriptor,
+        dataDescriptor: descriptor,
         labels: normalizeLabels(labels),
       }
     }
     if (this.block) {
       return {
-        contractAddress: this.contract.rawContract.address,
+        address: this.contract.rawContract.address,
+        contractName: this.contractName,
         blockNumber: this.blockNumber,
         transactionIndex: -1,
         transactionHash: '',
         logIndex: -1,
         chainId: this.chainId.toString(),
-        descriptor: descriptor,
+        dataDescriptor: descriptor,
         labels: normalizeLabels(labels),
       }
     }
     if (this.trace) {
       return {
-        contractAddress: this.contract.rawContract.address,
+        address: this.contract.rawContract.address,
+        contractName: this.contractName,
         blockNumber: this.blockNumber,
         transactionIndex: this.trace.transactionPosition,
         transactionHash: this.transactionHash || '',
         logIndex: -1,
         chainId: this.chainId.toString(),
-        descriptor: descriptor,
+        dataDescriptor: descriptor,
         labels: normalizeLabels(labels),
       }
     }
@@ -125,7 +136,7 @@ export class ContractView<TContract extends BaseContract> {
 export class BoundContractView<TContract extends BaseContract, TContractView extends ContractView<TContract>> {
   protected view: TContractView
   // context will be set right after context creation (in context's constructor)
-  context: Context<TContract, BoundContractView<TContract, TContractView>>
+  context: ContractContext<TContract, BoundContractView<TContract, TContractView>>
 
   constructor(view: TContractView) {
     this.view = view
@@ -146,23 +157,26 @@ export class BoundContractView<TContract extends BaseContract, TContractView ext
 
 export class SolanaContext extends BaseContext {
   address: string
+  programName: string
   blockNumber: Long
 
-  constructor(address: string, slot: Long) {
+  constructor(programName: string, address: string, slot: Long) {
     super()
+    this.programName = programName
     this.address = address
     this.blockNumber = slot
   }
 
-  getMetaData(descriptor: MetricDescriptor | undefined, labels: Labels): RecordMetaData {
+  getMetaData(descriptor: DataDescriptor | undefined, labels: Labels): RecordMetaData {
     return {
-      contractAddress: this.address,
+      address: this.address,
+      contractName: this.programName,
       blockNumber: this.blockNumber,
       transactionIndex: 0,
       transactionHash: '', // TODO add
       logIndex: 0,
       chainId: SOL_MAINMET_ID, // TODO set in context
-      descriptor: descriptor,
+      dataDescriptor: descriptor,
       labels: normalizeLabels(labels),
     }
   }
@@ -170,6 +184,7 @@ export class SolanaContext extends BaseContext {
 
 export class SuiContext extends BaseContext {
   address: string
+  moduleName: string
   blockNumber: Long
 
   constructor(address: string, slot: Long) {
@@ -178,15 +193,16 @@ export class SuiContext extends BaseContext {
     this.blockNumber = slot
   }
 
-  getMetaData(descriptor: MetricDescriptor | undefined, labels: Labels): RecordMetaData {
+  getMetaData(descriptor: DataDescriptor | undefined, labels: Labels): RecordMetaData {
     return {
-      contractAddress: this.address,
+      address: this.address,
+      contractName: this.moduleName,
       blockNumber: this.blockNumber,
       transactionIndex: 0,
       transactionHash: '', // TODO
       logIndex: 0,
       chainId: SUI_DEVNET_ID, // TODO set in context
-      descriptor: descriptor,
+      dataDescriptor: descriptor,
       labels: normalizeLabels(labels),
     }
   }

package/src/core/generic-processor.ts

@@ -3,7 +3,7 @@ import { BoundContractView, ContractView } from './context'
 import { BindOptions } from './bind-options'
 import { BaseProcessor } from './base-processor'
 import { getProvider } from '../provider'
-import { addProcessor, getContractName } from '../binds'
+import { addProcessor } from '../binds'
 
 export class GenericProcessor extends BaseProcessor<
   BaseContract,
@@ -21,15 +21,14 @@ export class GenericProcessor extends BaseProcessor<
   }
 
   public static bind(eventABI: string[] | string, options: BindOptions): GenericProcessor {
-    const AbiName = 'Generic'
     if (!Array.isArray(eventABI)) {
       eventABI = [eventABI]
     }
-
-    const finalOptions = Object.assign({}, options)
-    finalOptions.name = getContractName(AbiName, options.name, options.address, options.network)
-    const processor = new GenericProcessor(eventABI, finalOptions)
-    addProcessor(AbiName, options, processor)
+    if (!options.name) {
+      options.name = 'Generic'
+    }
+    const processor = new GenericProcessor(eventABI, options)
+    addProcessor(options, processor)
     return processor
   }
 }

package/src/core/index.ts

@@ -1,15 +1,15 @@
-export { BigNumber as BigDecimal } from 'bignumber.js'
-export { Context, ContractView, BoundContractView, SolanaContext } from './context'
-export { CounterBinding, Meter, GaugeBinding, Counter, Gauge, MetricDescriptorOption } from './meter'
+export { BigDecimal } from './big-decimal'
+export { ContractContext, ContractView, BoundContractView, SolanaContext } from './context'
+export { CounterBinding, Meter, GaugeBinding, Counter, Gauge, MetricDescriptorOptions } from './meter'
 export { type Numberish, toBigInteger, toMetricValue } from './numberish'
 
-export { BindOptions, SolanaBindOptions, SuiBindOptions } from './bind-options'
+export { BindOptions, SolanaBindOptions } from './bind-options'
 
 export { BaseProcessor } from './base-processor'
 export { GenericProcessor } from './generic-processor'
 export { BaseProcessorTemplate } from './base-processor-template'
 export { SolanaBaseProcessor } from './solana-processor'
-export { SuiBaseProcessor } from './sui-processor'
+export { SuiBaseProcessor, SuiBindOptions } from './sui-processor'
 // export * from '../aptos'
 
 export type { TypedCallTrace, Trace } from './trace'

package/src/core/logger.ts

@@ -1,16 +1,15 @@
 import { BaseContext } from './context'
-import { Labels, GetRecordMetaData } from './metadata'
-import { LogLevel } from '../gen'
+import { DataDescriptor, LogLevel } from '../gen'
+import { DescriptorWithUsage, Labels } from './metadata'
 
 export type Attributes = Record<string, any>
 
-export class Logger {
+export class Logger extends DescriptorWithUsage {
   private readonly ctx: BaseContext
-  private readonly name: string
 
   constructor(ctx: BaseContext, name = '') {
+    super(DataDescriptor.fromPartial({ name }))
     this.ctx = ctx
-    this.name = name
   }
 
   withName(name: string) {
@@ -22,9 +21,10 @@ export class Logger {
       message = message.toString()
     }
 
+    this.usage++
     this.ctx.logs.push({
-      name: this.name,
-      metadata: GetRecordMetaData(this.ctx, undefined, {}),
+      // name: this.name,
+      metadata: this.ctx.getMetaData(this.getShortDescriptor(), {}), // GetRecordMetaData(this.ctx, this, {}),
       level,
       message,
       attributes: JSON.stringify(attributes),

package/src/core/metadata.ts

@@ -1,20 +1,22 @@
-import { BaseContext } from './context'
-import { MetricDescriptor, RecordMetaData } from '../gen'
-import { Metric, normalizeName } from './meter'
+import { DataDescriptor } from '../gen'
+import { normalizeName } from './meter'
 
 export type Labels = { [key: string]: string }
 
-export function GetRecordMetaData(ctx: BaseContext, metric: Metric | undefined, labels: Labels): RecordMetaData {
-  let descriptor = undefined
-  if (metric) {
-    descriptor = metric.descriptor
-    if (metric.usage > 0) {
+export class DescriptorWithUsage {
+  descriptor: DataDescriptor
+  usage = 0
+  constructor(descriptor: DataDescriptor) {
+    this.descriptor = descriptor
+    this.descriptor.name = normalizeName(descriptor.name)
+  }
+
+  getShortDescriptor(): DataDescriptor {
+    if (this.usage > 0) {
       // Other setting don't need to be write multiple times
-      descriptor = MetricDescriptor.fromPartial({ name: descriptor.name })
+      return DataDescriptor.fromPartial({ name: this.descriptor.name })
     }
 
-    descriptor.name = normalizeName(descriptor.name)
+    return this.descriptor
   }
-
-  return ctx.getMetaData(descriptor, labels)
 }

package/src/core/meter.ts

@@ -1,7 +1,7 @@
-import { MetricDescriptor } from '../gen'
 import { BaseContext } from './context'
 import { toMetricValue, Numberish } from './numberish'
-import { GetRecordMetaData, Labels } from './metadata'
+import { DescriptorWithUsage, Labels } from './metadata'
+import { DataDescriptor } from '../gen'
 
 export function normalizeName(name: string): string {
   const regex = new RegExp('![_.a-zA-Z0-9]')
@@ -27,29 +27,27 @@ export function normalizeLabels(labels: Labels): Labels {
   return normLabels
 }
 
-export class MetricDescriptorOption {
+export class MetricDescriptorOptions {
   unit?: string
   description?: string
   sparse?: boolean
 }
 
-export class Metric {
-  descriptor: MetricDescriptor = MetricDescriptor.fromPartial({})
-  usage = 0
-
-  constructor(name: string, option?: MetricDescriptorOption) {
-    this.descriptor.name = name
+export class Metric extends DescriptorWithUsage {
+  constructor(name: string, option?: MetricDescriptorOptions) {
+    const descriptor = DataDescriptor.fromPartial({ name })
     if (option) {
       if (option.unit) {
-        this.descriptor.unit = option.unit
+        descriptor.unit = option.unit
       }
       if (option.description) {
-        this.descriptor.description = option.description
+        descriptor.description = option.description
       }
       if (option.sparse) {
-        this.descriptor.sparse = option.sparse
+        descriptor.sparse = option.sparse
       }
     }
+    super(descriptor)
   }
 }
 
@@ -64,7 +62,7 @@ export class Counter extends Metric {
 
   private record(ctx: BaseContext, value: Numberish, labels: Labels, add: boolean) {
     ctx.counters.push({
-      metadata: GetRecordMetaData(ctx, this, labels),
+      metadata: ctx.getMetaData(this.getShortDescriptor(), labels),
       metricValue: toMetricValue(value),
       add: add,
       runtimeInfo: undefined,
@@ -94,7 +92,7 @@ export class CounterBinding {
 export class Gauge extends Metric {
   record(ctx: BaseContext, value: Numberish, labels: Labels = {}) {
     ctx.gauges.push({
-      metadata: GetRecordMetaData(ctx, this, labels),
+      metadata: ctx.getMetaData(this.getShortDescriptor(), labels),
       metricValue: toMetricValue(value),
       runtimeInfo: undefined,
     })

package/src/core/solana-processor.ts

@@ -9,8 +9,10 @@ type IndexConfigure = {
   endSlot?: Long
 }
 
+export type SolanaInstructionHandler = (instruction: Instruction, ctx: SolanaContext, accounts?: string[]) => void
+
 export class SolanaBaseProcessor {
-  public instructionHanlderMap: Map<string, (instruction: Instruction, ctx: SolanaContext) => void> = new Map()
+  public instructionHandlerMap: Map<string, SolanaInstructionHandler> = new Map()
   address: string
   endpoint: string
   contractName: string
@@ -44,39 +46,40 @@ export class SolanaBaseProcessor {
     return this
   }
 
-  public onInstruction(instructionName: string, handler: (instruction: Instruction, ctx: SolanaContext) => void) {
+  public onInstruction(instructionName: string, handler: SolanaInstructionHandler) {
     if (!this.isBind()) {
       throw new Error("Processor doesn't bind to an address")
     }
 
-    this.instructionHanlderMap.set(instructionName, handler)
+    this.instructionHandlerMap.set(instructionName, handler)
 
     return this
   }
 
-  public handleInstruction(ins: string | { type: string; info: any }, slot: Long): ProcessResult | null {
-    const ctx = new SolanaContext(this.address, slot)
-    let parsedInstruction: Instruction | null = null
-
+  public getParsedInstruction(ins: string | { type: string; info: any }): Instruction | null {
     if (ins) {
       if ((ins as { type: string; info: any }).info) {
-        if (this.fromParsedInstruction == null) {
-          return null
-        }
-        parsedInstruction = this.fromParsedInstruction(ins as { type: string; info: any })
-      } else {
-        if (this.decodeInstruction == null) {
-          return null
-        }
-        parsedInstruction = this.decodeInstruction(ins as string)
+        return this.fromParsedInstruction ? this.fromParsedInstruction(ins as { type: string; info: any }) : null
       }
-      if (parsedInstruction) {
-        const handler = this.instructionHanlderMap.get(parsedInstruction.name)
-        if (handler) {
-          handler(parsedInstruction, ctx)
-        }
+      if (this.decodeInstruction != null) {
+        return this.decodeInstruction(ins as string)
       }
     }
+    return null
+  }
+
+  public getInstructionHandler(parsedInstruction: Instruction): SolanaInstructionHandler | undefined {
+    return this.instructionHandlerMap.get(parsedInstruction.name)
+  }
+
+  public handleInstruction(
+    parsedInstruction: Instruction,
+    accounts: string[],
+    handler: SolanaInstructionHandler,
+    slot: Long
+  ): ProcessResult {
+    const ctx = new SolanaContext(this.contractName, this.address, slot)
+    handler(parsedInstruction, ctx, accounts)
     return {
       gauges: ctx.gauges,
       counters: ctx.counters,

package/src/core/sui-processor.ts

@@ -1,4 +1,3 @@
-import { SuiBindOptions } from './bind-options'
 import { SuiContext } from './context'
 import { ProcessResult } from '../gen'
 import Long from 'long'
@@ -8,35 +7,29 @@ type IndexConfigure = {
   endSeqNumber?: Long
 }
 
+export class SuiBindOptions {
+  address: string
+  // network?: Networkish = 1
+  // name?: string
+  startBlock?: Long | number
+  // endBlock?: Long | number
+}
+
 export class SuiBaseProcessor {
   public transactionHanlder: (transaction: any, ctx: SuiContext) => void
   address: string
   config: IndexConfigure = { startSeqNumber: new Long(0) }
 
-  constructor(options: SuiBindOptions) {
-    if (options) {
-      this.bind(options)
-    }
-    global.PROCESSOR_STATE.suiProcessors.push(this)
-  }
-
-  bind(options: SuiBindOptions) {
+  constructor(name: string, options: SuiBindOptions) {
     this.address = options.address
     if (options.startBlock) {
       this.startSlot(options.startBlock)
     }
-    if (options.endBlock) {
-      this.endBlock(options.endBlock)
-    }
+    global.PROCESSOR_STATE.suiProcessors.push(this)
   }
 
   public onTransaction(handler: (transaction: any, ctx: SuiContext) => void) {
-    if (!this.isBind()) {
-      throw new Error("Processor doesn't bind to an address")
-    }
-
     this.transactionHanlder = handler
-
     return this
   }
 
@@ -53,10 +46,6 @@ export class SuiBaseProcessor {
     }
   }
 
-  public isBind() {
-    return this.address !== null
-  }
-
   public startSlot(startSlot: Long | number) {
     if (typeof startSlot === 'number') {
       startSlot = Long.fromNumber(startSlot)

package/src/error.ts

@@ -1,5 +1,5 @@
 // Transform error in more readable format
-import { Context } from './core/context'
+import { ContractContext } from './core/context'
 import { errors } from 'ethers'
 
 export class EthersError extends Error {
@@ -15,7 +15,7 @@ export class EthersError extends Error {
   }
 }
 
-export function transformEtherError(e: Error, ctx: Context<any, any> | undefined): Error {
+export function transformEtherError(e: Error, ctx: ContractContext<any, any> | undefined): Error {
   let msg = ''
   // @ts-ignore expected error fields
   if (e.code === errors.CALL_EXCEPTION) {