@sentio/sdk 2.59.0-rc.2 → 2.59.0-rc.20

package/src/aptos/codegen/codegen.ts

@@ -26,9 +26,9 @@ class AptosNetworkCodegen extends BaseAptosCodegen {
   moduleGenerator: SharedNetworkCodegen<AptosNetwork, MoveModuleBytecode, Event | MoveResource>
   SYSTEM_PACKAGE = '@sentio/sdk/aptos'
 
-  constructor(network: AptosNetwork) {
+  constructor(network: AptosNetwork, useViewJson = false) {
     const endpoint = getRpcEndpoint(network)
-    super(endpoint)
+    super(endpoint, useViewJson)
     const generator = this
 
     this.moduleGenerator = new (class extends SharedNetworkCodegen<
@@ -54,6 +54,7 @@ class AptosNetworkCodegen extends BaseAptosCodegen {
   protected getGetDefaultCoder() {
     return `defaultMoveCoderForClient(client)`
   }
+
   generateModule(module: InternalMoveModule, allEventStructs: Map<string, InternalMoveStruct>) {
     return this.moduleGenerator.generateModule(module, allEventStructs)
   }
@@ -67,9 +68,10 @@ class AptosNetworkCodegen extends BaseAptosCodegen {
         MoveCoder, TypedEventInstance } from "@typemove/${this.PREFIX.toLowerCase()}"
 
       import { defaultMoveCoder, defaultMoveCoderForClient } from "${this.defaultCoderPackage()}"
-      import { Aptos, Account as AptosAccount, MoveAddressType, PendingTransactionResponse, InputGenerateTransactionOptions, MoveStructId, InputViewFunctionData } from '@aptos-labs/ts-sdk'`
+      import { Aptos, Account as AptosAccount, MoveAddressType, PendingTransactionResponse, InputGenerateTransactionOptions, MoveStructId, InputViewFunctionData, InputViewFunctionJsonData } from '@aptos-labs/ts-sdk'`
     )
   }
+
   generateLoadAll(isSystem: boolean): string {
     return this.moduleGenerator.generateLoadAll(isSystem)
   }
@@ -79,13 +81,13 @@ const ADDRESS_LENGTH = 64
 
 class InitiaAptosNetworkCodegen extends AptosNetworkCodegen {
   constructor(network: AptosNetwork) {
-    super(network)
+    super(network, true)
 
-    const oldFetchModules = this.chainAdapter.fetchModules
+    const oldFetchModules = this.chainAdapter.fetchModules.bind(this.chainAdapter)
     this.chainAdapter.fetchModules = async (address: string) => {
       return oldFetchModules(this.padZero(address))
     }
-    const oldFetchModule = this.chainAdapter.fetchModule
+    const oldFetchModule = this.chainAdapter.fetchModule.bind(this.chainAdapter)
     this.chainAdapter.fetchModule = async (address: string, moduleName: string) => {
       return oldFetchModule(this.padZero(address), moduleName)
     }
@@ -117,7 +119,7 @@ class AptosCodegen {
     ]
 
     for (const [network, gen] of generators) {
-      const exclude = network ? [] : ['testnet', 'movement-mainnet', 'movement-testnet']
+      const exclude = network ? [] : ['testnet', 'movement-mainnet', 'movement-testnet', 'initia-echelon']
       numFiles += await recursiveCodegen(
         path.join(srcDir, network),
         path.join(outputDir, network),

package/src/aptos/move-coder.ts

@@ -1,6 +1,7 @@
 import { AptosNetwork, getClient } from './network.js'
-import { MoveCoder } from '@typemove/aptos'
-import { Aptos } from '@aptos-labs/ts-sdk'
+import { MoveCoder, TypedFunctionPayload } from '@typemove/aptos'
+import { Aptos, EntryFunctionPayloadResponse } from '@aptos-labs/ts-sdk'
+import { TypeDescriptor, VECTOR_STR } from '@typemove/move'
 
 const CODERS = new Map<AptosNetwork, MoveCoder>()
 const URL_CODERS = new Map<string, MoveCoder>()
@@ -9,7 +10,8 @@ export function defaultMoveCoder(network: AptosNetwork = AptosNetwork.MAIN_NET):
   let coder = CODERS.get(network)
   if (!coder) {
     const client = getClient(network)
-    coder = new MoveCoder(getClient(network))
+
+    coder = network == AptosNetwork.INITIA_ECHELON ? new InitiaMoveCoder(client) : new MoveCoder(client)
     CODERS.set(network, coder)
     URL_CODERS.set(client.config.fullnode || '', coder)
   }
@@ -29,3 +31,94 @@ export function defaultMoveCoderForClient(client: Aptos): MoveCoder {
   }
   return coder
 }
+
+export class InitiaMoveCoder extends MoveCoder {
+  constructor(client: Aptos) {
+    super(client, true)
+  }
+
+  async decodeFunctionPayload<T extends Array<any>>(
+    payload: EntryFunctionPayloadResponse
+  ): Promise<TypedFunctionPayload<T>> {
+    const func = await this.getMoveFunction(payload.function)
+    const paramsTypes = this.adapter.getMeaningfulFunctionParams(func.params)
+    const argumentsDecoded = []
+
+    for (let i = 0; i < paramsTypes.length; i++) {
+      const arg = payload.arguments[i]
+      const paramType = paramsTypes[i]
+      if (arg == null) {
+        argumentsDecoded.push(null)
+      } else {
+        argumentsDecoded.push(await this.decodeBase64(Buffer.from(arg, 'base64'), paramType))
+      }
+    }
+
+    return {
+      ...payload,
+      arguments_decoded: argumentsDecoded
+    } as TypedFunctionPayload<T>
+  }
+
+  protected async decodeBase64(b: Buffer, type: TypeDescriptor): Promise<any> {
+    switch (type.qname.toLowerCase()) {
+      case 'signer': // TODO check this, aptos only
+      case 'address':
+      case '0x1::string::String':
+        return b.toString()
+      case 'bool':
+        return b.readUInt8() !== 0 // Convert first byte to boolean
+      case 'u8':
+        return b.readUInt8()
+      case 'u16':
+        return b.readUInt16LE()
+      case 'u32':
+        return b.readUInt32LE()
+      case 'u64':
+        return b.readBigUInt64LE()
+      case 'u128':
+      case 'u256':
+        const hex = b.toString('hex')
+        const reversedHex = hex.match(/.{2}/g)?.reverse().join('') || ''
+        return BigInt('0x' + reversedHex)
+      case '0x1::object::object':
+        return b.toString('hex')
+      case VECTOR_STR:
+        // vector<u8> as hex string
+        if (type.typeArgs[0].qname === 'u8' || type.typeArgs[0].qname === 'U8') {
+          return b.toString('hex')
+        }
+
+        console.warn(`can't decode vector type: ${type.qname}, data: ${b.toString('base64')}`)
+        return b.toString('base64')
+      default:
+        // try enum type first
+        const enumType = await this.maybeGetMoveEnum(type.qname)
+        if (enumType) {
+          return b.toString('utf-8')
+        }
+
+        // Process complex type
+        /*const struct = await this.getMoveStruct(type.qname)
+
+        const typeCtx = new Map<string, TypeDescriptor>()
+        for (const [idx, typeArg] of type.typeArgs.entries()) {
+          typeCtx.set('T' + idx, typeArg)
+        }
+
+        const typedData: any = {}
+
+        for (const field of struct.fields) {
+          let filedType = field.type
+          filedType = filedType.applyTypeArgs(typeCtx)
+          const fieldValue = this.adapter.getData(data)[field.name]
+          const value = await this.decode(fieldValue, filedType)
+          typedData[field.name] = value
+        }*/
+
+        // todo: how to decode complex type?
+        console.warn(`can't decode type:${type.qname}, data: ${b.toString('base64')}`)
+        return b.toString('hex')
+    }
+  }
+}

package/src/aptos/network.ts

@@ -25,6 +25,7 @@ export class AptosBindOptions {
   network?: AptosNetwork = AptosNetwork.MAIN_NET
   client?: Aptos
   startVersion?: bigint | number
+  endVersion?: bigint | number
   baseLabels?: Labels
 }
 

package/src/core/base-context.ts

@@ -1,5 +1,5 @@
 import { ProcessResult, RecordMetaData } from '@sentio/protos'
-import { EventLoggerBinding } from './event-logger.js'
+import { EventLoggerBinding, EventLoggerBindingNew } from './event-logger.js'
 import { Meter, Labels } from './meter.js'
 import { ChainId } from '@sentio/chain'
 import { mergeProcessResults, PluginManager } from '@sentio/runtime'
@@ -10,6 +10,7 @@ import { Store } from '../store/store.js'
 export abstract class BaseContext {
   meter: Meter
   eventLogger: EventLoggerBinding
+  eventLoggerNew: EventLoggerBindingNew
   private _store: Store
   baseLabels: Labels
   private active: boolean
@@ -21,7 +22,8 @@ export abstract class BaseContext {
     gauges: [],
     states: {
       configUpdated: false
-    }
+    },
+    timeseriesResult: []
   }
 
   public update(res: Partial<ProcessResult>) {
@@ -35,6 +37,7 @@ export abstract class BaseContext {
   protected constructor(baseLabels: Labels | undefined) {
     this.meter = new Meter(this)
     this.eventLogger = new EventLoggerBinding(this)
+    this.eventLoggerNew = new EventLoggerBindingNew(this)
     this.baseLabels = baseLabels || {}
     this.active = true
     this.initStore()

package/src/core/event-logger.ts

@@ -6,7 +6,10 @@ import {
   EventLogConfig_Field,
   EventLogConfig_StructFieldType,
   EventTrackingResult,
-  LogLevel
+  LogLevel,
+  RichStruct,
+  TimeseriesResult,
+  TimeseriesResult_TimeseriesType
 } from '@sentio/protos'
 import { normalizeAttribute, normalizeLabels, normalizeToRichStruct } from './normalization.js'
 import { MapStateStorage, processMetrics } from '@sentio/runtime'
@@ -141,3 +144,44 @@ function checkEventName(eventName: string) {
     throw new Error(`Event name ${eventName} is already used in the database schema`)
   }
 }
+
+function emitNew<T>(ctx: BaseContext, eventName: string, event: Event<T>) {
+  const { distinctId, severity, message, ...payload } = event
+
+  const data: RichStruct = {
+    fields: {
+      severity: {
+        stringValue: (severity || LogLevel.INFO).toString()
+      },
+      message: {
+        stringValue: message || ''
+      },
+      distinctEntityId: {
+        stringValue: distinctId || ''
+      },
+      ...normalizeToRichStruct(ctx.baseLabels, payload).fields
+    }
+  }
+  const res: TimeseriesResult = {
+    metadata: ctx.getMetaData(eventName, {}),
+    type: TimeseriesResult_TimeseriesType.EVENT,
+    data,
+    runtimeInfo: undefined
+  }
+
+  processMetrics.process_eventemit_count.add(1)
+  ctx.update({ timeseriesResult: [res] })
+}
+
+export class EventLoggerBindingNew {
+  private readonly ctx: BaseContext
+
+  constructor(ctx: BaseContext) {
+    this.ctx = ctx
+  }
+
+  emit<T>(eventName: string, event: Event<T>) {
+    checkEventName(eventName)
+    emitNew(this.ctx, eventName, event)
+  }
+}

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 MetricState()
+
+  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,
@@ -100,7 +129,7 @@ export class Counter extends Metric {
     this.record(ctx, value, labels, false)
   }
 
-  private record(ctx: BaseContext, value: Numberish, labels: Labels, add: boolean) {
+  protected record(ctx: BaseContext, value: Numberish, labels: Labels, add: boolean) {
     processMetrics.process_metricrecord_count.add(1)
     ctx.update({
       counters: [
@@ -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,89 @@ 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, option?: CounterOptions): CounterNew {
+    return CounterNew.register(name, option)
+  }
+
+  Gauge(name: string, option?: MetricOptions): GaugeNew {
+    return GaugeNew.register(name, option)
+  }
+}
+
+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] : []
+        }
+      })
+    )
+  }
+
+  protected record(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 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/eth/base-processor.ts

@@ -13,7 +13,7 @@ import {
   PreprocessResult,
   ProcessResult
 } from '@sentio/protos'
-import { BindOptions } from './bind-options.js'
+import { BindOptions, TimeOrBlock } from './bind-options.js'
 import { PromiseOrVoid } from '../core/promises.js'
 import { ServerError, Status } from 'nice-grpc'
 import {
@@ -75,8 +75,8 @@ class BindInternalOptions {
   address: string
   network: EthChainId
   name: string
-  startBlock: bigint
-  endBlock?: bigint
+  start: TimeOrBlock
+  end?: TimeOrBlock
   baseLabels?: { [key: string]: string }
 }
 
@@ -101,13 +101,20 @@ export class GlobalProcessor {
       address: ALL_ADDRESS,
       name: config.name || 'Global',
       network: config.network || EthChainId.ETHEREUM,
-      startBlock: 0n
+      start: config.start || {
+        block: 0
+      },
+      end: config.end
     }
     if (config.startBlock) {
-      this.config.startBlock = BigInt(config.startBlock)
+      this.config.start = {
+        block: config.startBlock
+      }
     }
     if (config.endBlock) {
-      this.config.endBlock = BigInt(config.endBlock)
+      this.config.end = {
+        block: config.endBlock
+      }
     }
 
     return proxyProcessor(this)
@@ -390,14 +397,21 @@ export abstract class BaseProcessor<
       address: validateAndNormalizeAddress(config.address),
       name: config.name || '',
       network: config.network || EthChainId.ETHEREUM,
-      startBlock: 0n,
+      start: config.start || {
+        block: 0
+      },
+      end: config.end,
       baseLabels: config.baseLabels
     }
     if (config.startBlock) {
-      this.config.startBlock = BigInt(config.startBlock)
+      this.config.start = {
+        block: config.startBlock
+      }
     }
     if (config.endBlock) {
-      this.config.endBlock = BigInt(config.endBlock)
+      this.config.end = {
+        block: config.endBlock
+      }
     }
 
     return proxyProcessor(this)

package/src/eth/bind-options.ts

@@ -7,11 +7,18 @@ export class BindOptions {
   network?: EthChainId = EthChainId.ETHEREUM
   // Optional, override default contract name
   name?: string
+  start?: TimeOrBlock
+  end?: TimeOrBlock
   startBlock?: bigint | number
   endBlock?: bigint | number
   baseLabels?: { [key: string]: string }
 }
 
+export interface TimeOrBlock {
+  block?: bigint | number
+  time?: Date
+}
+
 export function getOptionsSignature(opts: BindOptions): string {
   const sig = [opts.address]
   if (opts.network) {

package/src/eth/eth-plugin.ts

@@ -1,4 +1,12 @@
-import { errorString, mergeProcessResults, Plugin, PluginManager, USER_PROCESSOR, GLOBAL_CONFIG } from '@sentio/runtime'
+import {
+  errorString,
+  mergeProcessResults,
+  Plugin,
+  PluginManager,
+  USER_PROCESSOR,
+  GLOBAL_CONFIG,
+  getProvider
+} from '@sentio/runtime'
 import {
   AccountConfig,
   ContractConfig,
@@ -26,6 +34,7 @@ import { validateAndNormalizeAddress } from './eth.js'
 import { EthChainId } from '@sentio/chain'
 import { EthContext } from './context.js'
 import { TemplateInstanceState } from '../core/template.js'
+import { timeOrBlockToBlockNumber } from '@sentio/sdk/utils'
 
 interface Handlers {
   eventHandlers: ((event: Data_EthLog, preparedData?: PreparedData) => Promise<ProcessResult>)[]
@@ -79,6 +88,10 @@ export class EthPlugin extends Plugin {
       const chainId = processor.getChainId()
       // this.processorsByChainId.set(chainId, processor)
 
+      const provider = getProvider(chainId)
+      const startBlock = await timeOrBlockToBlockNumber(provider, processor.config.start)
+      const endBlock = processor.config.end ? await timeOrBlockToBlockNumber(provider, processor.config.end) : undefined
+
       const contractConfig = ContractConfig.fromPartial({
         processorType: USER_PROCESSOR,
         contract: {
@@ -87,8 +100,8 @@ export class EthPlugin extends Plugin {
           address: validateAndNormalizeAddress(processor.config.address),
           abi: ''
         },
-        startBlock: processor.config.startBlock,
-        endBlock: processor.config.endBlock
+        startBlock,
+        endBlock
       })
 
       // Step 1. Prepare all the block handlers
@@ -167,6 +180,10 @@ export class EthPlugin extends Plugin {
     for (const processor of GlobalProcessorState.INSTANCE.getValues()) {
       const chainId = processor.getChainId()
 
+      const provider = getProvider(chainId)
+      const startBlock = await timeOrBlockToBlockNumber(provider, processor.config.start)
+      const endBlock = processor.config.end ? await timeOrBlockToBlockNumber(provider, processor.config.end) : undefined
+
       const contractConfig = ContractConfig.fromPartial({
         processorType: USER_PROCESSOR,
         contract: {
@@ -175,8 +192,8 @@ export class EthPlugin extends Plugin {
           address: processor.config.address, // can only be *
           abi: ''
         },
-        startBlock: processor.config.startBlock,
-        endBlock: processor.config.endBlock
+        startBlock,
+        endBlock
       })
 
       for (const blockHandler of processor.blockHandlers) {

package/src/fuel/fuel-processor.ts

@@ -184,15 +184,7 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
           return ctx.stopAndGetResult()
         } catch (e) {
           console.error(e)
-          return {
-            gauges: [],
-            counters: [],
-            events: [],
-            exports: [],
-            states: {
-              configUpdated: false
-            }
-          }
+          return ProcessResult.fromPartial({})
         }
       },
       fetchConfig: {

package/src/stark/starknet-processor.ts

@@ -1,6 +1,6 @@
 import { Data_StarknetEvent, ProcessResult } from '@sentio/protos'
 import { StarknetChainId } from '@sentio/chain'
-import { CallData, constants, events, ParsedEvent, RpcProvider } from 'starknet'
+import { CallData, events, ParsedEvent, RpcProvider } from 'starknet'
 import { StarknetContext } from './context.js'
 import { StarknetEvent } from './event.js'
 import { ListStateStorage, mergeProcessResults } from '@sentio/runtime'
@@ -83,15 +83,7 @@ export class StarknetProcessor {
           return mergeProcessResults(results)
         } catch (e) {
           console.error(e)
-          return {
-            gauges: [],
-            counters: [],
-            events: [],
-            exports: [],
-            states: {
-              configUpdated: false
-            }
-          }
+          return ProcessResult.fromPartial({})
         }
       },
       eventFilter
@@ -110,9 +102,9 @@ export type CallHandler<T> = {
 function getRpcEndpoint(chainId: StarknetChainId | string) {
   switch (chainId) {
     case StarknetChainId.STARKNET_MAINNET:
-      return constants.NetworkName.SN_MAIN
+      return 'https://starknet-mainnet.g.alchemy.com/starknet/version/rpc/v0_8/8sD5yitBslIYCPFzSq_Q1ObJHqPlZxFw'
     default:
-      return constants.NetworkName.SN_SEPOLIA
+      return 'https://starknet-sepolia.g.alchemy.com/starknet/version/rpc/v0_8/8sD5yitBslIYCPFzSq_Q1ObJHqPlZxFw'
   }
 }