@sentio/sdk 2.62.0-rc.15 → 2.62.0-rc.17

package/src/stark/starknet-processor.ts

@@ -1,164 +0,0 @@
-import { Data_StarknetEvent, ProcessResult } from '@sentio/protos'
-import { StarknetChainId } from '@sentio/chain'
-import { CallData, events, ParsedEvent, RpcProvider } from 'starknet'
-import { StarknetContext } from './context.js'
-import { StarknetEvent } from './event.js'
-import { ListStateStorage, mergeProcessResults } from '@sentio/runtime'
-import { StarknetProcessorConfig } from './types.js'
-import { StarknetContractView } from './contract.js'
-import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
-import { HandlerOptions } from '../core/handler-options.js'
-
-export class StarknetProcessor {
-  callHandlers: CallHandler<Data_StarknetEvent>[] = []
-
-  private provider: RpcProvider
-
-  static bind(config: StarknetProcessorConfig): StarknetProcessor {
-    const processor = new StarknetProcessor(config)
-    StarknetProcessorState.INSTANCE.addValue(processor)
-    return processor
-  }
-
-  classHash: string
-
-  constructor(readonly config: StarknetProcessorConfig) {
-    return proxyProcessor(this)
-  }
-
-  async configure() {
-    this.provider = new RpcProvider({
-      nodeUrl: getRpcEndpoint(this.config.chainId)
-    })
-    const classHash = await this.provider.getClassHashAt(this.config.address)
-    if (!classHash) {
-      throw new Error("can't find the class hash defined at " + this.config.address)
-    }
-    this.classHash = classHash
-    if (!this.config.abi) {
-      const clazz = await this.provider.getClass(classHash, 'latest')
-      this.config.abi = clazz.abi
-    }
-  }
-
-  public onEvent(
-    event: string | string[],
-    handler: (events: StarknetEvent<ParsedEvent>, ctx: StarknetContext<StarknetContractView>) => void | Promise<void>,
-    handlerOptions?: HandlerOptions<object, StarknetEvent<ParsedEvent>>
-  ) {
-    const eventFilter = Array.isArray(event) ? event : [event]
-    if (!this.config.abi) {
-      throw new Error('abi not found')
-    }
-    const abi = this.config.abi
-    const callHandler = {
-      handlerName: getHandlerName(),
-      handler: async (call: Data_StarknetEvent) => {
-        try {
-          const eventData = [call.result] as any[]
-          const abiEvents = events.getAbiEvents(abi)
-
-          const abiStructs = CallData.getAbiStruct(abi)
-          const abiEnums = CallData.getAbiEnum(abi)
-
-          const parsedEvents = events.parseEvents(eventData, abiEvents, abiStructs, abiEnums)
-          const results: ProcessResult[] = []
-          const { block_hash, block_number, transaction_hash, from_address } = call.result!
-          for (let i = 0; i < parsedEvents.length; i++) {
-            const ctx = new StarknetContext<StarknetContractView>(
-              this.config,
-              this.provider,
-              block_number,
-              block_hash,
-              transaction_hash,
-              i,
-              this.classHash
-            )
-            const e = new StarknetEvent(from_address, transaction_hash, parsedEvents[i])
-            try {
-              await handler(e, ctx)
-            } catch (e) {
-              console.error(e)
-            }
-            results.push(ctx.stopAndGetResult())
-          }
-          return mergeProcessResults(results)
-        } catch (e) {
-          console.error(e)
-          return ProcessResult.fromPartial({})
-        }
-      },
-      eventFilter,
-      partitionHandler: async (call: Data_StarknetEvent): Promise<string | undefined> => {
-        const p = handlerOptions?.partitionKey
-        if (!p) return undefined
-        if (typeof p === 'function') {
-          try {
-            const eventData = [call.result] as any[]
-            const abiEvents = events.getAbiEvents(abi)
-            const abiStructs = CallData.getAbiStruct(abi)
-            const abiEnums = CallData.getAbiEnum(abi)
-            const parsedEvents = events.parseEvents(eventData, abiEvents, abiStructs, abiEnums)
-            if (parsedEvents.length > 0) {
-              const { from_address, transaction_hash } = call.result!
-              const e = new StarknetEvent(from_address, transaction_hash, parsedEvents[0])
-              return p(e)
-            }
-            return undefined
-          } catch (e) {
-            console.error(e)
-            return undefined
-          }
-        }
-        return p
-      }
-    }
-    this.callHandlers.push(callHandler)
-    return this
-  }
-}
-
-export type CallHandler<T> = {
-  handlerName: string
-  handler: (call: T) => Promise<ProcessResult>
-  eventFilter?: string[]
-  partitionHandler?: (call: T) => Promise<string | undefined>
-}
-
-function getRpcEndpoint(chainId: StarknetChainId | string) {
-  switch (chainId) {
-    case StarknetChainId.STARKNET_MAINNET:
-      return 'https://starknet-mainnet.g.alchemy.com/starknet/version/rpc/v0_8/8sD5yitBslIYCPFzSq_Q1ObJHqPlZxFw'
-    default:
-      return 'https://starknet-sepolia.g.alchemy.com/starknet/version/rpc/v0_8/8sD5yitBslIYCPFzSq_Q1ObJHqPlZxFw'
-  }
-}
-
-export class StarknetProcessorState extends ListStateStorage<StarknetProcessor> {
-  static INSTANCE = new StarknetProcessorState()
-}
-
-export abstract class AbstractStarknetProcessor {
-  private readonly processor: StarknetProcessor
-  protected constructor(
-    readonly abi: any,
-    readonly config: StarknetProcessorConfig
-  ) {
-    this.processor = new StarknetProcessor(config)
-    StarknetProcessorState.INSTANCE.addValue(this.processor)
-    return proxyProcessor(this)
-  }
-
-  onEvent<T, C>(
-    eventName: string,
-    structName: string,
-    handler: (event: StarknetEvent<T>, ctx: StarknetContext<C>) => Promise<void>
-  ) {
-    this.processor.onEvent(eventName, async (events, ctx) => {
-      const eventData = events.data[structName] as T
-      const e = new StarknetEvent<T>(events.caller, events.transactionHash, eventData)
-      await handler(e, ctx as StarknetContext<C>)
-    })
-    return this
-  }
-}

package/src/stark/types.ts

@@ -1,11 +0,0 @@
-import { StarknetChainId } from '@sentio/chain'
-import { Abi } from 'starknet'
-
-export type StarknetProcessorConfig = {
-  address: string
-  name?: string
-  chainId: StarknetChainId | string
-  startBlock?: bigint
-  endBlock?: bigint
-  abi?: Abi
-}

package/src/testing/btc-facet.ts

@@ -1,46 +0,0 @@
-import { TestProcessorServer } from './test-processor-server.js'
-import { DataBinding, HandlerType } from '@sentio/protos'
-import { BTCChainId } from '@sentio/chain'
-import '../btc/btc-plugin.js'
-
-export class BTCFacet {
-  server: TestProcessorServer
-
-  constructor(server: TestProcessorServer) {
-    this.server = server
-  }
-
-  testOnTransactions(events: any, network: BTCChainId = BTCChainId.BTC_TESTNET) {
-    const bindings = this.buildBinding(events, network)
-    if (!bindings) {
-      throw Error('Invalid test : ' + JSON.stringify(events))
-    }
-
-    return this.server.processBindings({
-      bindings
-    })
-  }
-
-  private buildBinding(data: any, network: BTCChainId): DataBinding[] {
-    const res: DataBinding[] = []
-
-    for (const config of this.server.contractConfigs) {
-      if (config.contract?.chainId !== network) {
-        continue
-      }
-
-      for (const txConfig of config.btcTransactionConfigs) {
-        const binding = {
-          data: {
-            btcTransaction: data
-          },
-          handlerIds: [txConfig.handlerId],
-          handlerType: HandlerType.BTC_TRANSACTION,
-          chainId: network
-        } as DataBinding
-        res.push(binding)
-      }
-    }
-    return res
-  }
-}

package/src/testing/starknet-facet.ts

@@ -1,62 +0,0 @@
-import { TestProcessorServer } from './test-processor-server.js'
-import { DataBinding, HandlerType } from '@sentio/protos'
-import { StarknetChainId } from '@sentio/chain'
-
-export class StarknetFacet {
-  server: TestProcessorServer
-
-  constructor(server: TestProcessorServer) {
-    this.server = server
-  }
-
-  testOnEvents(events: any, network: StarknetChainId = StarknetChainId.STARKNET_SEPOLIA) {
-    const bindings = this.buildBinding(events, network)
-    if (!bindings) {
-      throw Error('Invalid test : ' + JSON.stringify(events))
-    }
-
-    return this.server.processBindings({
-      bindings
-    })
-  }
-
-  private buildBinding(events: any, network: StarknetChainId): DataBinding[] {
-    const res: DataBinding[] = []
-    const data = Array.isArray(events) ? events : [events]
-    for (const event of data) {
-      for (const config of this.server.contractConfigs) {
-        if (config.contract?.chainId !== network) {
-          continue
-        }
-
-        for (const logConfig of config.starknetEventConfigs) {
-          const binding = {
-            data: {
-              starknetEvents: {
-                result: event,
-                timestamp: new Date()
-              }
-            },
-            handlerIds: [logConfig.handlerId],
-            handlerType: HandlerType.STARKNET_EVENT,
-            chainId: config.contract.chainId
-          }
-
-          const logFilters = logConfig.filters
-          const keys = event.keys as string[]
-
-          for (const key of keys) {
-            for (const logFilter of logFilters) {
-              if (logFilter.keys.includes(key)) {
-                res.push(binding)
-                return res
-              }
-            }
-          }
-        }
-      }
-    }
-
-    return res
-  }
-}