@sentio/sdk 1.8.1 → 1.9.0

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

@@ -123,6 +123,7 @@ export interface ContractConfig {
   contract: ContractInfo | undefined;
   blockConfigs: BlockHandlerConfig[];
   logConfigs: LogHandlerConfig[];
+  traceConfigs: TraceHandlerConfig[];
   startBlock: Long;
   endBlock: Long;
   instructionConfig: InstructionHandlerConfig | undefined;
@@ -151,6 +152,11 @@ export interface BlockHandlerConfig {
   handlerId: number;
 }
 
+export interface TraceHandlerConfig {
+  signature: string;
+  handlerId: number;
+}
+
 export interface LogHandlerConfig {
   filters: LogFilter[];
   handlerId: number;
@@ -180,7 +186,7 @@ export interface ProcessLogsResponse {
 }
 
 export interface ProcessTracesRequest {
-  logBindings: LogBinding[];
+  traceBindings: TraceBinding[];
 }
 
 export interface ProcessTracesResponse {
@@ -524,6 +530,7 @@ function createBaseContractConfig(): ContractConfig {
     contract: undefined,
     blockConfigs: [],
     logConfigs: [],
+    traceConfigs: [],
     startBlock: Long.UZERO,
     endBlock: Long.UZERO,
     instructionConfig: undefined,
@@ -545,6 +552,9 @@ export const ContractConfig = {
     for (const v of message.logConfigs) {
       LogHandlerConfig.encode(v!, writer.uint32(26).fork()).ldelim();
     }
+    for (const v of message.traceConfigs) {
+      TraceHandlerConfig.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
     if (!message.startBlock.isZero()) {
       writer.uint32(32).uint64(message.startBlock);
     }
@@ -583,6 +593,11 @@ export const ContractConfig = {
             LogHandlerConfig.decode(reader, reader.uint32())
           );
           break;
+        case 2:
+          message.traceConfigs.push(
+            TraceHandlerConfig.decode(reader, reader.uint32())
+          );
+          break;
         case 4:
           message.startBlock = reader.uint64() as Long;
           break;
@@ -617,6 +632,9 @@ export const ContractConfig = {
       logConfigs: Array.isArray(object?.logConfigs)
         ? object.logConfigs.map((e: any) => LogHandlerConfig.fromJSON(e))
         : [],
+      traceConfigs: Array.isArray(object?.traceConfigs)
+        ? object.traceConfigs.map((e: any) => TraceHandlerConfig.fromJSON(e))
+        : [],
       startBlock: isSet(object.startBlock)
         ? Long.fromValue(object.startBlock)
         : Long.UZERO,
@@ -652,6 +670,13 @@ export const ContractConfig = {
     } else {
       obj.logConfigs = [];
     }
+    if (message.traceConfigs) {
+      obj.traceConfigs = message.traceConfigs.map((e) =>
+        e ? TraceHandlerConfig.toJSON(e) : undefined
+      );
+    } else {
+      obj.traceConfigs = [];
+    }
     message.startBlock !== undefined &&
       (obj.startBlock = (message.startBlock || Long.UZERO).toString());
     message.endBlock !== undefined &&
@@ -675,6 +700,8 @@ export const ContractConfig = {
       object.blockConfigs?.map((e) => BlockHandlerConfig.fromPartial(e)) || [];
     message.logConfigs =
       object.logConfigs?.map((e) => LogHandlerConfig.fromPartial(e)) || [];
+    message.traceConfigs =
+      object.traceConfigs?.map((e) => TraceHandlerConfig.fromPartial(e)) || [];
     message.startBlock =
       object.startBlock !== undefined && object.startBlock !== null
         ? Long.fromValue(object.startBlock)
@@ -994,6 +1021,68 @@ export const BlockHandlerConfig = {
   },
 };
 
+function createBaseTraceHandlerConfig(): TraceHandlerConfig {
+  return { signature: "", handlerId: 0 };
+}
+
+export const TraceHandlerConfig = {
+  encode(
+    message: TraceHandlerConfig,
+    writer: _m0.Writer = _m0.Writer.create()
+  ): _m0.Writer {
+    if (message.signature !== "") {
+      writer.uint32(10).string(message.signature);
+    }
+    if (message.handlerId !== 0) {
+      writer.uint32(16).int32(message.handlerId);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): TraceHandlerConfig {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTraceHandlerConfig();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.signature = reader.string();
+          break;
+        case 2:
+          message.handlerId = reader.int32();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TraceHandlerConfig {
+    return {
+      signature: isSet(object.signature) ? String(object.signature) : "",
+      handlerId: isSet(object.handlerId) ? Number(object.handlerId) : 0,
+    };
+  },
+
+  toJSON(message: TraceHandlerConfig): unknown {
+    const obj: any = {};
+    message.signature !== undefined && (obj.signature = message.signature);
+    message.handlerId !== undefined &&
+      (obj.handlerId = Math.round(message.handlerId));
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<TraceHandlerConfig>): TraceHandlerConfig {
+    const message = createBaseTraceHandlerConfig();
+    message.signature = object.signature ?? "";
+    message.handlerId = object.handlerId ?? 0;
+    return message;
+  },
+};
+
 function createBaseLogHandlerConfig(): LogHandlerConfig {
   return { filters: [], handlerId: 0 };
 }
@@ -1400,7 +1489,7 @@ export const ProcessLogsResponse = {
 };
 
 function createBaseProcessTracesRequest(): ProcessTracesRequest {
-  return { logBindings: [] };
+  return { traceBindings: [] };
 }
 
 export const ProcessTracesRequest = {
@@ -1408,8 +1497,8 @@ export const ProcessTracesRequest = {
     message: ProcessTracesRequest,
     writer: _m0.Writer = _m0.Writer.create()
   ): _m0.Writer {
-    for (const v of message.logBindings) {
-      LogBinding.encode(v!, writer.uint32(10).fork()).ldelim();
+    for (const v of message.traceBindings) {
+      TraceBinding.encode(v!, writer.uint32(10).fork()).ldelim();
     }
     return writer;
   },
@@ -1425,7 +1514,9 @@ export const ProcessTracesRequest = {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.logBindings.push(LogBinding.decode(reader, reader.uint32()));
+          message.traceBindings.push(
+            TraceBinding.decode(reader, reader.uint32())
+          );
           break;
         default:
           reader.skipType(tag & 7);
@@ -1437,28 +1528,28 @@ export const ProcessTracesRequest = {
 
   fromJSON(object: any): ProcessTracesRequest {
     return {
-      logBindings: Array.isArray(object?.logBindings)
-        ? object.logBindings.map((e: any) => LogBinding.fromJSON(e))
+      traceBindings: Array.isArray(object?.traceBindings)
+        ? object.traceBindings.map((e: any) => TraceBinding.fromJSON(e))
         : [],
     };
   },
 
   toJSON(message: ProcessTracesRequest): unknown {
     const obj: any = {};
-    if (message.logBindings) {
-      obj.logBindings = message.logBindings.map((e) =>
-        e ? LogBinding.toJSON(e) : undefined
+    if (message.traceBindings) {
+      obj.traceBindings = message.traceBindings.map((e) =>
+        e ? TraceBinding.toJSON(e) : undefined
       );
     } else {
-      obj.logBindings = [];
+      obj.traceBindings = [];
     }
     return obj;
   },
 
   fromPartial(object: DeepPartial<ProcessTracesRequest>): ProcessTracesRequest {
     const message = createBaseProcessTracesRequest();
-    message.logBindings =
-      object.logBindings?.map((e) => LogBinding.fromPartial(e)) || [];
+    message.traceBindings =
+      object.traceBindings?.map((e) => TraceBinding.fromPartial(e)) || [];
     return message;
   },
 };

package/src/index.ts

@@ -12,6 +12,7 @@ export { transformEtherError } from './error'
 export { ProcessorState } from './processor-state'
 export { BigNumber as BigDecimal } from 'bignumber.js'
 export { EthersError } from './error'
+export type { TypedTrace } from './trace'
 
 export { getProcessor, addProcessor, getContractByABI, addContractByABI, getContractName } from './binds'
 

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

@@ -23,16 +23,19 @@ 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<ProcessResult>)[] = []
+  private traceHandlers: ((trace: Trace) => Promise<ProcessResult>)[] = []
   private blockHandlers: ((block: Block) => Promise<ProcessResult>)[] = []
 
   // map from chain id to list of processors
@@ -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: {
@@ -388,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

package/src/target-ethers-sentio/codegen.ts

@@ -9,6 +9,7 @@ import {
 import { reservedKeywords } from '@typechain/ethers-v5/dist/codegen/reserved-keywords'
 import { generateInputTypes } from '@typechain/ethers-v5/dist/codegen/types'
 import { getFullSignatureForEvent } from 'typechain/dist/utils/signatures'
+import { codegenCallTraceTypes, codegenFunctions } from './functions'
 
 export function codeGenIndex(contract: Contract): string {
   return ` 
@@ -72,6 +73,8 @@ export function codeGenSentioFile(contract: Contract): string {
       .join('\n')}
     }
 
+    ${Object.values(contract.functions).map(codegenCallTraceTypes).join('\n')}
+
     export class ${contract.name}Processor extends BaseProcessor<${contract.name}, ${contract.name}BoundContractView> {
       ${Object.values(contract.events)
         .map((events) => {
@@ -83,6 +86,10 @@ export function codeGenSentioFile(contract: Contract): string {
         })
         .join('\n')}
 
+      ${Object.values(contract.functions)
+        .map((f) => codegenFunctions(f, contract.name))
+        .join('\n')}
+
     public static filters = templateContract.filters
     
     protected CreateBoundContractView(): ${contract.name}BoundContractView {
@@ -134,6 +141,7 @@ export function codeGenSentioFile(contract: Contract): string {
         'ContractView',
         'DummyProvider',
         'getContractName',
+        'TypedTrace',
       ],
       './common': ['PromiseOrValue'],
       './index': [`${contract.name}`, `${contract.name}__factory`],

package/src/target-ethers-sentio/functions.ts

@@ -0,0 +1,55 @@
+import { generateInputTypes } from '@typechain/ethers-v5/dist/codegen/types'
+import { FunctionDeclaration, getSignatureForFn } from 'typechain'
+
+export function codegenFunctions(fns: FunctionDeclaration[], contractName: string): string {
+  if (fns.length === 1) {
+    return generateFunction(fns[0], contractName)
+  }
+
+  return fns.map((fn) => generateFunction(fn, contractName, getFullSignatureAsSymbolForFunction(fn))).join('\n')
+}
+
+export function codegenCallTraceTypes(fns: FunctionDeclaration[]): string {
+  if (fns.length === 1) {
+    return codegenCallTraceType(fns[0])
+  }
+
+  return fns.map((fn) => codegenCallTraceType(fn, getFullSignatureAsSymbolForFunction(fn))).join('\n')
+}
+
+function codegenCallTraceType(fn: FunctionDeclaration, overloadedName?: string): string {
+  return `
+  export interface ${capitalizeFirstChar(overloadedName ?? fn.name)}CallTrace extends TypedTrace {
+    args: [${generateInputTypes(fn.inputs, { useStructs: true })}]
+  }
+  `
+}
+
+function generateFunction(fn: FunctionDeclaration, contractName: string, overloadedName?: string): string {
+  return `
+  on${capitalizeFirstChar(overloadedName ?? fn.name)}Call(
+    handler: (trace: ${capitalizeFirstChar(overloadedName ?? fn.name)}CallTrace, ctx: ${contractName}Context) => void
+  ) {
+    return super.onTrace("${getSignatureForFn(fn)}", handler);
+  }
+`
+}
+
+function getFullSignatureAsSymbolForFunction(fn: FunctionDeclaration): string {
+  return `${fn.name}_${fn.inputs
+    .map((e) => {
+      if (e.type.type === 'array') {
+        return e.type.itemType.originalType + '_array'
+      } else {
+        return e.type.originalType
+      }
+    })
+    .join('_')}`
+}
+
+function capitalizeFirstChar(input: string): string {
+  if (!input) {
+    return input
+  }
+  return input[0].toUpperCase() + (input.length > 1 ? input.substring(1) : '')
+}

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',
+// }