@sentio/sdk 2.40.0-rc.39 → 2.40.0-rc.40

package/src/stark/starknet-plugin.ts

@@ -0,0 +1,108 @@
+import { errorString, GLOBAL_CONFIG, mergeProcessResults, Plugin, PluginManager, USER_PROCESSOR } from '@sentio/runtime'
+import {
+  ContractConfig,
+  Data_StarknetEvent,
+  DataBinding,
+  HandlerType,
+  ProcessConfigResponse,
+  ProcessResult,
+  StartRequest
+} from '@sentio/protos'
+
+import { ServerError, Status } from 'nice-grpc'
+import { TemplateInstanceState } from '../core/template.js'
+import { StarknetProcessorState } from './starknet-processor.js'
+import { hash } from 'starknet'
+
+interface Handlers {
+  callHandlers: ((trace: Data_StarknetEvent) => Promise<ProcessResult>)[]
+}
+
+export class StarknetPlugin extends Plugin {
+  name: string = 'StarknetPlugin'
+  handlers: Handlers = {
+    callHandlers: []
+  }
+
+  async configure(config: ProcessConfigResponse) {
+    const handlers: Handlers = {
+      callHandlers: []
+    }
+
+    for (const processor of StarknetProcessorState.INSTANCE.getValues()) {
+      await processor.configure()
+      const contractConfig = ContractConfig.fromPartial({
+        processorType: USER_PROCESSOR,
+        contract: {
+          name: processor.config.name,
+          chainId: processor.config.chainId.toString(),
+          address: processor.config.address || '*',
+          abi: ''
+        },
+        startBlock: processor.config.startBlock,
+        endBlock: processor.config.endBlock
+      })
+      for (const callHandler of processor.callHandlers) {
+        const handlerId = handlers.callHandlers.push(callHandler.handler) - 1
+
+        if (callHandler.eventFilter) {
+          contractConfig.starknetEventConfigs.push({
+            filters: callHandler.eventFilter.map((e) => ({
+              address: processor.config.address,
+              keys: [hash.getSelectorFromName(e)]
+            })),
+            handlerId
+          })
+        }
+      }
+
+      // Finish up a contract
+      config.contractConfigs.push(contractConfig)
+    }
+
+    this.handlers = handlers
+  }
+
+  supportedHandlers = [HandlerType.STARKNET_EVENT]
+
+  processBinding(request: DataBinding): Promise<ProcessResult> {
+    switch (request.handlerType) {
+      case HandlerType.STARKNET_EVENT:
+        return this.processEvent(request)
+      default:
+        throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
+    }
+  }
+
+  async start(request: StartRequest) {}
+
+  stateDiff(config: ProcessConfigResponse): boolean {
+    return TemplateInstanceState.INSTANCE.getValues().length !== config.templateInstances.length
+  }
+
+  async processEvent(binding: DataBinding): Promise<ProcessResult> {
+    if (!binding.data?.starknetEvents?.result) {
+      throw new ServerError(Status.INVALID_ARGUMENT, "starknetEvents can't be null")
+    }
+
+    const promises: Promise<ProcessResult>[] = []
+
+    const result = binding.data?.starknetEvents?.result
+
+    for (const handlerId of binding.handlerIds) {
+      const promise = this.handlers.callHandlers[handlerId](binding.data?.starknetEvents).catch((e) => {
+        throw new ServerError(
+          Status.INTERNAL,
+          'error processing transaction: ' + JSON.stringify(result) + '\n' + errorString(e)
+        )
+      })
+      if (GLOBAL_CONFIG.execution.sequential) {
+        await promise
+      }
+      promises.push(promise)
+    }
+    return mergeProcessResults(await Promise.all(promises))
+  }
+}
+
+PluginManager.INSTANCE.register(new StarknetPlugin())

package/src/stark/starknet-processor.ts

@@ -0,0 +1,140 @@
+import { Data_StarknetEvent, ProcessResult } from '@sentio/protos'
+import { StarknetChainId } from '@sentio/chain'
+import { CallData, constants, 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'
+
+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) {}
+
+  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>
+  ) {
+    const eventFilter = Array.isArray(event) ? event : [event]
+    if (!this.config.abi) {
+      throw new Error('abi not found')
+    }
+    const abi = this.config.abi
+    const callHandler = {
+      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 {
+            gauges: [],
+            counters: [],
+            events: [],
+            exports: [],
+            states: {
+              configUpdated: false
+            }
+          }
+        }
+      },
+      eventFilter
+    }
+    this.callHandlers.push(callHandler)
+    return this
+  }
+}
+
+export type CallHandler<T> = {
+  handler: (call: T) => Promise<ProcessResult>
+  eventFilter?: string[]
+}
+
+function getRpcEndpoint(chainId: StarknetChainId | string) {
+  switch (chainId) {
+    case StarknetChainId.STARKNET_MAINNET:
+      return constants.NetworkName.SN_MAIN
+    default:
+      return constants.NetworkName.SN_SEPOLIA
+  }
+}
+
+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)
+  }
+
+  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

@@ -0,0 +1,11 @@
+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/starknet-facet.ts

@@ -0,0 +1,61 @@
+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
+          }
+
+          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
+  }
+}

package/src/testing/test-processor-server.ts

@@ -26,6 +26,7 @@ import { EthFacet } from './eth-facet.js'
 import { SuiFacet } from './sui-facet.js'
 import { FuelFacet } from './fuel-facet.js'
 import { CosmosFacet } from './cosmos-facet.js'
+import { StarknetFacet } from './starknet-facet.js'
 
 export const TEST_CONTEXT: CallContext = <CallContext>{}
 
@@ -44,6 +45,7 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
   sui: SuiFacet
   fuel: FuelFacet
   cosmos: CosmosFacet
+  starknet: StarknetFacet
 
   constructor(loader: () => Promise<any>, httpEndpoints: Record<string, string> = {}) {
     cleanTest()
@@ -55,6 +57,7 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
     this.sui = new SuiFacet(this)
     this.fuel = new FuelFacet(this)
     this.cosmos = new CosmosFacet(this)
+    this.starknet = new StarknetFacet(this)
 
     for (const k in CHAIN_MAP) {
       const http = httpEndpoints[k] || ''