@sentio/sdk 2.40.0-rc.4 → 2.40.0-rc.41

package/src/stark/context.ts

@@ -0,0 +1,78 @@
+import { ChainId } from '@sentio/chain'
+import { RecordMetaData } from '@sentio/protos'
+import { BaseContext, Labels, normalizeLabels } from '../core/index.js'
+import { Provider, RpcProvider } from 'starknet'
+import { StarknetProcessorConfig } from './types.js'
+import { Abi } from '@sentio/abi-wan-kanabi'
+import { StarknetContractView } from './contract.js'
+
+class AbstractContext extends BaseContext {
+  constructor(
+    readonly provider: Provider,
+    readonly contractAddress: string,
+    readonly chainId: ChainId | string,
+    readonly blockNumber: number,
+    readonly blockHash: string,
+    readonly transactionHash: string,
+    readonly logIndex: number = -1,
+    readonly contractName: string = '',
+    readonly abi?: Abi
+  ) {
+    super({})
+  }
+
+  protected getMetaDataInternal(name: string, labels: Labels): RecordMetaData {
+    return {
+      address: this.contractAddress,
+      contractName: '',
+      blockNumber: BigInt(this.blockNumber),
+      transactionIndex: 0,
+      transactionHash: this.transactionHash,
+      chainId: this.getChainId(),
+      name: name,
+      logIndex: this.logIndex,
+      labels: normalizeLabels(labels)
+    }
+  }
+
+  getChainId(): ChainId {
+    return this.chainId as ChainId
+  }
+}
+
+export class StarknetContext<CT> extends AbstractContext {
+  private _contract: any
+
+  constructor(
+    config: StarknetProcessorConfig,
+    provider: RpcProvider,
+    blockNumber: number,
+    blockHash: string,
+    transaction_hash: string,
+    logIndex: number,
+    readonly classHash: string
+  ) {
+    super(
+      provider,
+      config.address,
+      config.chainId,
+      blockNumber,
+      blockHash,
+      transaction_hash,
+      logIndex,
+      config.name ?? classHash.slice(0, 8),
+      config.abi
+    )
+  }
+
+  getContract(): CT {
+    if (!this.abi) {
+      throw new Error('abi not found')
+    }
+
+    if (!this._contract) {
+      this._contract = new StarknetContractView(this.abi, this.contractAddress, this.provider, this.blockNumber)
+    }
+    return this._contract as CT
+  }
+}

package/src/stark/contract.ts

@@ -0,0 +1,55 @@
+import {
+  ArgsOrCalldata,
+  ArgsOrCalldataWithOptions,
+  AsyncContractFunction,
+  CallOptions,
+  Contract,
+  Result,
+  RpcProvider,
+  CallData,
+  splitArgsAndOptions
+} from 'starknet'
+import { Abi } from '@sentio/abi-wan-kanabi'
+
+export class StarknetContractView {
+  private _contract: Contract
+
+  constructor(
+    readonly abi: Abi,
+    readonly address: string,
+    readonly provider: RpcProvider,
+    readonly blockNumber: number
+  ) {
+    this._contract = new Contract(abi, address, provider)
+    const callData = new CallData(abi)
+
+    for (const fn of callData.abi) {
+      if (fn.type == 'function' && fn.state_mutability == 'view') {
+        const signature = fn.name
+        Object.defineProperty(this, signature, {
+          enumerable: true,
+          writable: false,
+          value: buildCall(this, signature)
+        })
+      }
+    }
+  }
+
+  call(method: string, args?: ArgsOrCalldata, callOptions?: CallOptions): Promise<Result> {
+    return this._contract.call(method, args, {
+      ...callOptions,
+      blockIdentifier: this.blockNumber
+    })
+  }
+}
+
+function buildCall(contract: StarknetContractView, name: string): AsyncContractFunction {
+  return async function (...args: ArgsOrCalldataWithOptions): Promise<any> {
+    const params = splitArgsAndOptions(args)
+    return contract.call(name, params.args, {
+      parseRequest: true,
+      parseResponse: true,
+      ...params.options
+    })
+  }
+}

package/src/stark/event.ts

@@ -0,0 +1,7 @@
+export class StarknetEvent<T> {
+  constructor(
+    readonly caller: string,
+    readonly transactionHash: string,
+    readonly data: T
+  ) {}
+}

package/src/stark/index.ts

@@ -0,0 +1,9 @@
+export { StarknetPlugin } from './starknet-plugin.js'
+
+export * from './starknet-processor.js'
+
+export { StarknetChainId } from '@sentio/chain'
+
+export * from './context.js'
+export * from './event.js'
+export * from './types.js'

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/store/cache.ts

@@ -0,0 +1,46 @@
+import { ID } from './types.js'
+import type { Entity as EntityStruct } from '@sentio/protos'
+
+export interface Entity {
+  id: ID
+}
+
+export class LocalCache {
+  private cache: Map<string, EntityStruct> = new Map()
+
+  getKey(entity: string, id: ID) {
+    return `${entity}-${id}`
+  }
+
+  has(entity: string, id: ID): boolean {
+    return this.cache.has(this.getKey(entity, id))
+  }
+
+  get(entity: string, id: ID): EntityStruct | undefined {
+    return this.cache.get(this.getKey(entity, id))
+  }
+
+  set(entity: EntityStruct) {
+    const id = entity.data?.fields['id'].stringValue
+    if (id) {
+      const key = this.getKey(entity.entity, id)
+      let fields = entity.data?.fields || {}
+      if (this.cache.has(key)) {
+        const existFields = this.cache.get(key)?.data?.fields || {}
+        fields = Object.assign(existFields, fields)
+      }
+      this.cache.set(key, {
+        ...entity,
+        data: {
+          fields
+        }
+      })
+    }
+  }
+
+  delete(entityName: string, id: string | undefined) {
+    if (id) {
+      this.cache.delete(this.getKey(entityName, id))
+    }
+  }
+}

package/src/store/store.ts

@@ -2,17 +2,12 @@ import { StoreContext } from './context.js'
 import { DatabaseSchema } from '../core/index.js'
 import { BigDecimal } from '@sentio/bigdecimal'
 import { Bytes, Float, ID, Int, Timestamp } from './types.js'
-import type { Entity as EntityStruct, RichValue } from '@sentio/protos'
+import type { DBRequest, Entity as EntityStruct, RichValue } from '@sentio/protos'
 import { DBRequest_DBOperator, DBResponse } from '@sentio/protos'
 import { toBigInteger } from './convert.js'
 import { PluginManager } from '@sentio/runtime'
 import { Cursor } from './cursor.js'
-
-type Value = ID | string | Int | Float | boolean | Timestamp | Bytes | BigDecimal | bigint
-
-interface Entity {
-  id: ID
-}
+import { Entity, LocalCache } from './cache.js'
 
 export interface EntityClass<T> {
   new (data: Partial<T>): T
@@ -35,12 +30,20 @@ function getEntityName<T>(entity: EntityClass<T> | T | string): string {
 }
 
 export class Store {
+  private cache = new LocalCache()
+
   constructor(private readonly context: StoreContext) {}
 
   async get<T extends Entity>(entity: EntityClass<T> | string, id: ID): Promise<T | undefined> {
+    const entityName = getEntityName(entity)
+    const cachedData = this.cache.get(entityName, id)
+    if (cachedData) {
+      return Promise.resolve(this.newEntity(entity, cachedData))
+    }
+
     const promise = this.context.sendRequest({
       get: {
-        entity: getEntityName(entity),
+        entity: entityName,
         id: id.toString()
       }
     })
@@ -59,21 +62,25 @@ export class Store {
       entity: [] as string[],
       id: [] as string[]
     }
+    const entityName = getEntityName(entity)
     if (id) {
       if (Array.isArray(id)) {
         for (const i of id) {
-          request.entity.push(getEntityName(entity))
+          request.entity.push(entityName)
           request.id.push(i.toString())
+          this.cache.delete(entityName, i.toString())
         }
       } else {
-        request.entity.push(getEntityName(entity))
+        request.entity.push(entityName)
         request.id.push(id)
+        this.cache.delete(entityName, id)
       }
     } else {
       const entities = Array.isArray(entity) ? entity : [entity]
       for (const e of entities) {
-        request.entity.push(getEntityName(entity))
+        request.entity.push(entityName)
         request.id.push((e as Entity).id.toString())
+        this.cache.delete(entityName, id)
       }
     }
 
@@ -84,16 +91,27 @@ export class Store {
 
   async upsert<T extends Entity>(entity: T | T[]): Promise<void> {
     const entities = Array.isArray(entity) ? entity : [entity]
-    const promise = this.context.sendRequest({
+    const request = {
       upsert: {
         entity: entities.map((e) => getEntityName(e)),
         // data: entities.map((e) => serialize(e.data)),
         id: entities.map((e) => e.id.toString()),
         entityData: entities.map((e: any) => e._data)
       }
+    } as DBRequest
+    const promise = this.context.sendRequest(request)
+
+    return promise.then((_data) => {
+      request.upsert?.entity.forEach((entity, i) => {
+        this.cache.set({
+          entity: entity,
+          data: request.upsert?.entityData[i],
+          genBlockChain: '',
+          genBlockTime: undefined,
+          genBlockNumber: 0n
+        })
+      })
     })
-
-    await promise
   }
 
   async *listIterator<T extends Entity, P extends keyof T, O extends Operators<T[P]>>(
@@ -107,12 +125,6 @@ export class Store {
       for (const data of response.entityList?.entities || []) {
         yield this.newEntity(entity, data)
       }
-      console.debug(
-        'list returned ',
-        response.entityList?.entities?.length,
-        ' entities, next cursor',
-        response?.nextCursor
-      )
       if (!response.nextCursor) {
         break
       }
@@ -144,7 +156,7 @@ export class Store {
     cursor: string | undefined,
     pageSize?: number
   ): Promise<DBResponse> {
-    return (await this.context.sendRequest(
+    const response = (await this.context.sendRequest(
       {
         list: {
           entity: getEntityName(entity),
@@ -158,8 +170,14 @@ export class Store {
             })) || []
         }
       },
-      60
+      3600
     )) as DBResponse
+
+    response.entityList?.entities?.forEach((entity) => {
+      this.cache.set(entity)
+    })
+
+    return response
   }
 
   async list<T extends Entity, P extends keyof T, O extends Operators<T[P]>>(

package/src/sui/context.ts

@@ -8,7 +8,7 @@ import {
   SuiMoveObject,
   SuiClient
 } from '@mysten/sui.js/client'
-import { MoveCoder } from '@sentio/sdk/sui'
+import { MoveCoder } from './index.js'
 import { defaultMoveCoder } from './move-coder.js'
 import { MoveAccountContext, MoveContext } from '../move/index.js'
 

package/src/sui/sui-processor.ts

@@ -16,7 +16,7 @@ import {
   TransactionFilter
 } from '../move/index.js'
 import { getMoveCalls } from './utils.js'
-import { defaultMoveCoder, MoveCoder } from '@sentio/sdk/sui'
+import { defaultMoveCoder, MoveCoder } from './index.js'
 import { Labels } from '../core/index.js'
 import { Required } from 'utility-types'
 

package/src/testing/aptos-facet.ts

@@ -1,8 +1,8 @@
 import { UserTransactionResponse, EntryFunctionPayloadResponse } from '@aptos-labs/ts-sdk'
 import { DataBinding, HandlerType } from '@sentio/protos'
 import { TestProcessorServer } from './test-processor-server.js'
-import { AptosNetwork } from '@sentio/sdk/aptos'
-import { parseMoveType, accountTypeString } from '@sentio/sdk/move'
+import { AptosNetwork } from '../aptos/index.js'
+import { parseMoveType, accountTypeString } from '../move/index.js'
 
 export class AptosFacet {
   server: TestProcessorServer

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
+  }
+}