@sentio/sdk 1.8.0 → 1.8.2

package/src/meter.ts

@@ -1,5 +1,5 @@
 import { RecordMetaData } from './gen/processor/protos/processor'
-import { Context, EthContext, SolanaContext } from './context'
+import { BaseContext, Context, SolanaContext } from './context'
 import { toMetricValue, Numberish } from './numberish'
 import Long from 'long'
 
@@ -8,7 +8,7 @@ export function normalizeName(name: string) {
   return name.slice(0, 100).replace(regex, '_')
 }
 
-function GetRecordMetaData(ctx: EthContext | SolanaContext, name: string, labels: Labels): RecordMetaData {
+function GetRecordMetaData(ctx: BaseContext, name: string, labels: Labels): RecordMetaData {
   name = normalizeName(name)
 
   if (ctx instanceof Context) {
@@ -34,6 +34,17 @@ function GetRecordMetaData(ctx: EthContext | SolanaContext, name: string, labels
         labels: labels,
       }
     }
+    if (ctx.trace) {
+      return {
+        contractAddress: ctx.contract.rawContract.address,
+        blockNumber: Long.fromNumber(ctx.trace.blockNumber, true),
+        transactionIndex: ctx.trace.transactionPosition, // TODO make sure if this is the right value to set
+        logIndex: -1,
+        chainId: ctx.chainId.toString(),
+        name: name,
+        labels: labels,
+      }
+    }
   } else if (ctx instanceof SolanaContext) {
     return {
       contractAddress: ctx.address,
@@ -51,10 +62,10 @@ function GetRecordMetaData(ctx: EthContext | SolanaContext, name: string, labels
 export type Labels = { [key: string]: string }
 
 export class Counter {
-  private readonly ctx: EthContext | SolanaContext
+  private readonly ctx: BaseContext
   private readonly name: string
 
-  constructor(name: string, ctx: EthContext | SolanaContext) {
+  constructor(name: string, ctx: BaseContext) {
     this.name = name
     this.ctx = ctx
   }
@@ -79,9 +90,9 @@ export class Counter {
 
 export class Gauge {
   private readonly name: string
-  private readonly ctx: EthContext | SolanaContext
+  private readonly ctx: BaseContext
 
-  constructor(name: string, ctx: EthContext | SolanaContext) {
+  constructor(name: string, ctx: BaseContext) {
     this.name = name
     this.ctx = ctx
   }
@@ -96,13 +107,13 @@ export class Gauge {
 }
 
 export class Meter {
-  private readonly ctx: EthContext | SolanaContext
+  private readonly ctx: BaseContext
 
   // TODO is map necessary since we are sending request remotely?
   // counterMap = new Map<string, Counter>()
   // gaugeMap = new Map<string, Gauge>()
 
-  constructor(ctx: EthContext | SolanaContext) {
+  constructor(ctx: BaseContext) {
     this.ctx = ctx
   }
 

package/src/service.ts

@@ -7,7 +7,7 @@ import {
   HandlerType,
   LogFilter,
   LogHandlerConfig,
-  O11yResult,
+  ProcessResult,
   ProcessBlocksRequest,
   ProcessBlocksResponse,
   ProcessConfigRequest,
@@ -23,20 +23,23 @@ import {
   ProcessTransactionsResponse,
   StartRequest,
   TemplateInstance,
+  TraceBinding,
 } from './gen/processor/protos/processor'
 
 import { Empty } from './gen/google/protobuf/empty'
 import Long from 'long'
 import { TextDecoder } from 'util'
+import { Trace } from './trace'
 
 const DEFAULT_MAX_BLOCK = Long.ZERO
 
 export class ProcessorServiceImpl implements ProcessorServiceImplementation {
-  private eventHandlers: ((event: Log) => Promise<O11yResult>)[] = []
-  private blockHandlers: ((block: Block) => Promise<O11yResult>)[] = []
+  private eventHandlers: ((event: Log) => Promise<ProcessResult>)[] = []
+  private traceHandlers: ((trace: Trace) => Promise<ProcessResult>)[] = []
+  private blockHandlers: ((block: Block) => Promise<ProcessResult>)[] = []
 
   // map from chain id to list of processors
-  // private blockHandlers = new Map<string, ((block: Block) => Promise<O11yResult>)[]>()
+  // private blockHandlers = new Map<string, ((block: Block) => Promise<ProcessResult>)[]>()
   // private processorsByChainId = new Map<string, BaseProcessor<BaseContract, BoundContractView<BaseContract, any>>>()
 
   private started = false
@@ -88,6 +91,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
         },
         blockConfigs: [],
         logConfigs: [],
+        traceConfigs: [],
         startBlock: processor.config.startBlock,
         endBlock: DEFAULT_MAX_BLOCK,
         instructionConfig: undefined,
@@ -104,7 +108,16 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
         })
       }
 
-      // Step 2. Prepare all the event handlers
+      // Step 2. Prepare all trace handlers
+      for (const traceHandler of processor.traceHandlers) {
+        const handlerId = this.traceHandlers.push(traceHandler.handler) - 1
+        contractConfig.traceConfigs.push({
+          signature: traceHandler.signature,
+          handlerId: handlerId,
+        })
+      }
+
+      // Step 3. Prepare all the event handlers
       for (const eventsHandler of processor.eventHandlers) {
         // associate id with filter
         const handlerId = this.eventHandlers.push(eventsHandler.handler) - 1
@@ -151,6 +164,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
         },
         blockConfigs: [],
         logConfigs: [],
+        traceConfigs: [],
         startBlock: solanaProcessor.config.startSlot,
         endBlock: DEFAULT_MAX_BLOCK,
         instructionConfig: {
@@ -204,12 +218,13 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
       throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')
     }
 
-    const resp: O11yResult = {
+    const resp: ProcessResult = {
       gauges: [],
       counters: [],
+      logs: [],
     }
 
-    const promises: Promise<O11yResult>[] = []
+    const promises: Promise<ProcessResult>[] = []
     for (const l of request.logBindings) {
       if (!l.log) {
         throw new ServerError(Status.INVALID_ARGUMENT, "Log can't be null")
@@ -272,9 +287,10 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
       throw new ServerError(Status.UNAVAILABLE, 'Service not started.')
     }
 
-    const result: O11yResult = {
+    const result: ProcessResult = {
       gauges: [],
       counters: [],
+      logs: [],
     }
 
     // Only have instruction handlers for solana processors
@@ -289,7 +305,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
           new Promise((resolve, _) => {
             for (const processor of global.PROCESSOR_STATE.solanaProcessors) {
               if (processor.address === instruction.programAccountId) {
-                let res: O11yResult | null
+                let res: ProcessResult | null
                 if (instruction.parsed) {
                   res = processor.handleInstruction(JSON.parse(new TextDecoder().decode(instruction.parsed)))
                 } else if (instruction.instructionData) {
@@ -343,7 +359,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     const promises = request.blockBindings.map((binding) => this.processBlock(binding))
     const results = await Promise.all(promises)
 
-    const res = O11yResult.fromPartial({})
+    const res = ProcessResult.fromPartial({})
 
     for (const r of results) {
       res.counters = res.counters.concat(r.counters)
@@ -356,7 +372,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     }
   }
 
-  async processBlock(binding: BlockBinding): Promise<O11yResult> {
+  async processBlock(binding: BlockBinding): Promise<ProcessResult> {
     if (!binding.block) {
       throw new ServerError(Status.INVALID_ARGUMENT, "Block can't be empty")
     }
@@ -364,12 +380,13 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
 
     const block: Block = JSON.parse(jsonString)
 
-    const resp: O11yResult = {
+    const resp: ProcessResult = {
       gauges: [],
       counters: [],
+      logs: [],
     }
 
-    const promises: Promise<O11yResult>[] = []
+    const promises: Promise<ProcessResult>[] = []
     for (const handlerId of binding.handlerIds) {
       const promise = this.blockHandlers[handlerId](block).catch((e) => {
         throw new ServerError(Status.INTERNAL, 'error processing block: ' + block.number + '\n' + e.toString())
@@ -385,10 +402,37 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
   }
 
   async processTraces(request: ProcessTracesRequest, context: CallContext): Promise<ProcessTracesResponse> {
+    if (!this.started) {
+      throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')
+    }
+
+    const promises = request.traceBindings.map((binding) => this.processTrace(binding))
+    const results = await Promise.all(promises)
+
+    const res = ProcessResult.fromPartial({})
+
+    for (const r of results) {
+      res.counters = res.counters.concat(r.counters)
+      res.gauges = res.gauges.concat(r.gauges)
+    }
+
+    recordRuntimeInfo(res, HandlerType.TRACE)
     return {
-      result: undefined,
+      result: res,
     }
   }
+
+  async processTrace(binding: TraceBinding): Promise<ProcessResult> {
+    if (!binding.trace) {
+      throw new ServerError(Status.INVALID_ARGUMENT, "Trace can't be empty")
+    }
+    const jsonString = Utf8ArrayToStr(binding.trace.raw)
+    const trace: Trace = JSON.parse(jsonString)
+
+    return this.traceHandlers[binding.handlerId](trace).catch((e) => {
+      throw new ServerError(Status.INTERNAL, 'error processing trace: ' + jsonString + '\n' + e.toString())
+    })
+  }
 }
 
 // https://ourcodeworld.com/articles/read/164/how-to-convert-an-uint8array-to-string-in-javascript
@@ -432,7 +476,7 @@ function Utf8ArrayToStr(array: Uint8Array) {
   return out
 }
 
-function recordRuntimeInfo(results: O11yResult, handlerType: HandlerType) {
+function recordRuntimeInfo(results: ProcessResult, handlerType: HandlerType) {
   results.gauges.forEach((e) => {
     e.runtimeInfo = {
       from: handlerType,

package/src/solana-processor.ts

@@ -1,4 +1,4 @@
-import { O11yResult } from './gen/processor/protos/processor'
+import { ProcessResult } from './gen/processor/protos/processor'
 import { SolanaContext } from './context'
 import Long from 'long'
 import { Instruction } from '@project-serum/anchor'
@@ -54,7 +54,7 @@ export class SolanaBaseProcessor {
     return this
   }
 
-  public handleInstruction(ins: string | { type: string; info: any }): O11yResult | null {
+  public handleInstruction(ins: string | { type: string; info: any }): ProcessResult | null {
     const ctx = new SolanaContext(this.address)
     let parsedInstruction: Instruction | null = null
 
@@ -80,6 +80,7 @@ export class SolanaBaseProcessor {
     return {
       gauges: ctx.gauges,
       counters: ctx.counters,
+      logs: [],
     }
   }
 

package/src/test/erc20.test.ts

@@ -28,21 +28,19 @@ describe('Test Basic Examples', () => {
   })
 
   test('Check block dispatch', async () => {
-    const res = await service.testBlock(blockData)
-    const o11yRes = res.result
-    expect(o11yRes?.counters).length(0)
-    expect(o11yRes?.gauges).length(1)
-    expect(firstGaugeValue(o11yRes, 'g1')).equals(10n)
+    const res = (await service.testBlock(blockData)).result
+    expect(res?.counters).length(0)
+    expect(res?.gauges).length(1)
+    expect(firstGaugeValue(res, 'g1')).equals(10n)
 
-    const gauge = o11yRes?.gauges?.[0]
+    const gauge = res?.gauges?.[0]
     expect(gauge?.metadata?.blockNumber?.toString()).equals('14373295')
     expect(gauge?.runtimeInfo?.from).equals(HandlerType.BLOCK)
 
-    const res2 = await service.testBlock(blockData, 56)
-    const o11yRes2 = res2.result
-    expect(o11yRes2?.counters).length(0)
-    expect(o11yRes2?.gauges).length(1)
-    expect(firstGaugeValue(o11yRes2, 'g2')).equals(20n)
+    const res2 = (await service.testBlock(blockData, 56)).result
+    expect(res2?.counters).length(0)
+    expect(res2?.gauges).length(1)
+    expect(firstGaugeValue(res2, 'g2')).equals(20n)
   })
 
   test('Check log dispatch', async () => {

package/src/test/metric-utils.ts

@@ -1,5 +1,5 @@
 import { DeepPartial } from '../gen/builtin'
-import { BigDecimal, MetricValue, O11yResult } from '@sentio/sdk'
+import { BigDecimal, MetricValue, ProcessResult } from '@sentio/sdk'
 import { Numberish } from '../numberish'
 import { BigNumber } from 'ethers'
 
@@ -24,7 +24,7 @@ export function MetricValueToNumber(v: DeepPartial<MetricValue> | undefined): Nu
   return undefined
 }
 
-export function firstCounterValue(result: O11yResult | undefined, name: string): Numberish | undefined {
+export function firstCounterValue(result: ProcessResult | undefined, name: string): Numberish | undefined {
   if (!result) {
     return undefined
   }
@@ -36,7 +36,7 @@ export function firstCounterValue(result: O11yResult | undefined, name: string):
   return undefined
 }
 
-export function firstGaugeValue(result: O11yResult | undefined, name: string): Numberish | undefined {
+export function firstGaugeValue(result: ProcessResult | undefined, name: string): Numberish | undefined {
   if (!result) {
     return undefined
   }

package/src/trace.ts

@@ -0,0 +1,64 @@
+// https://github.com/openethereum/parity-ethereum/blob/55c90d4016505317034e3e98f699af07f5404b63/rpc/src/v1/types/trace.rs#L482
+import { Result } from '@ethersproject/abi'
+
+export interface TypedTrace<TArgsArray extends Array<any> = any, TArgsObject = any> extends Trace {
+  args: TArgsArray & TArgsObject
+}
+
+export interface Trace {
+  args?: Result
+
+  action: TraceAction
+  blockHash: string
+  blockNumber: number
+  result: TraceResult
+  subtraces: number
+  traceAddress: number[]
+  transactionHash: string
+  transactionPosition: number
+  type: string
+  error?: string
+}
+// export type CallType = "call" | "callcode" |  "delegatecall" | "staticcall"
+
+export interface TraceAction {
+  from: string
+  to: string
+  value: number
+  gas: number
+  input: string
+  callType: string
+
+  init?: string
+  address?: string
+  balance?: string
+  refundAddress?: string
+}
+
+// TODO are more field missing for FailedCall, FailedCreate
+export interface TraceResult {
+  gasUsed: number
+  output: string
+  address?: string
+  code?: string
+}
+
+// const TRACE: Trace = {
+//   action: {
+//     from: '0xd771111cbfa2bbdafbf9f0e58b49b3f827da31f5',
+//     callType: 'call',
+//     gas: 0x12154,
+//     input:
+//       '0xb1a417f4000000000000000000000000d771111cbfa2bbdafbf9f0e58b49b3f827da31f5000000000000000000000000d771111cbfa2bbdafbf9f0e58b49b3f827da31f500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000131888b5aaf000000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000',
+//     to: '0x0baba1ad5be3a5c0a66e7ac838a129bf948f1ea4',
+//     value: 0x131888b5aaf0000,
+//   },
+//   blockHash: '0x5451711bc530a7c04128fedbe149eb359c10eccd44a83909d448c5244c7eea26',
+//   blockNumber: 15533908,
+//   result: { gasUsed: 0x114c1, output: '0x' },
+//   subtraces: 1,
+//   traceAddress: [],
+//   transactionHash: '0x66dce11d6217042ed709a38e507e7762c93b1bde4a0447ae7a243493bbdffc0e',
+//   transactionPosition: 73,
+//   type: 'call',
+// }