@sentio/sdk 3.0.0-rc-next.1 → 3.0.0-rc-next.3

package/src/core/meter.ts

@@ -74,28 +74,6 @@ export class MetricState extends MapStateStorage<Metric> {
   }
 }
 
-export class MetricStateNew extends MapStateStorage<Metric> {
-  static INSTANCE = new MetricStateNew()
-
-  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
@@ -132,6 +110,7 @@ export class Counter extends Metric {
   private record(ctx: BaseContext, value: Numberish, labels: Labels, add: boolean) {
     processMetrics.process_metricrecord_count.add(1)
     ctx.update({
+      // legacy support, deprecating
       counters: [
         {
           metadata: ctx.getMetaData(this.name, labels),
@@ -139,6 +118,14 @@ export class Counter extends Metric {
           add: add,
           runtimeInfo: undefined
         }
+      ],
+      timeseriesResult: [
+        {
+          metadata: ctx.getMetaData(this.name, labels),
+          type: TimeseriesResult_TimeseriesType.COUNTER,
+          data: toTimeSeriesData(value, labels, !add),
+          runtimeInfo: undefined
+        }
       ]
     })
   }
@@ -181,12 +168,21 @@ export class Gauge extends Metric {
   record(ctx: BaseContext, value: Numberish, labels: Labels = {}) {
     processMetrics.process_metricrecord_count.add(1)
     ctx.update({
+      // legacy support, deprecating
       gauges: [
         {
           metadata: ctx.getMetaData(this.config.name, labels),
           metricValue: toMetricValue(value),
           runtimeInfo: undefined
         }
+      ],
+      timeseriesResult: [
+        {
+          metadata: ctx.getMetaData(this.name, labels),
+          type: TimeseriesResult_TimeseriesType.GAUGE,
+          data: toTimeSeriesData(value, labels, false),
+          runtimeInfo: undefined
+        }
       ]
     })
   }
@@ -221,129 +217,3 @@ 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) {
-    return new CounterNewBinding(name, this.ctx)
-  }
-
-  Gauge(name: string) {
-    return new GaugeNewBinding(name, this.ctx)
-  }
-}
-
-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] : []
-        }
-      })
-    )
-  }
-
-  add(ctx: BaseContext, value: Numberish, labels: Labels = {}) {
-    this.recordNew(ctx, value, labels, true)
-  }
-
-  sub(ctx: BaseContext, value: Numberish, labels: Labels = {}) {
-    this.recordNew(ctx, value, labels, false)
-  }
-
-  private recordNew(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 GaugeNewBinding {
-  private readonly gauge: GaugeNew
-  private readonly ctx: BaseContext
-
-  constructor(name: string, ctx: BaseContext) {
-    this.gauge = GaugeNew._create(name)
-    this.ctx = ctx
-  }
-
-  record(value: Numberish, labels: Labels = {}) {
-    this.gauge.record(this.ctx, value, labels)
-  }
-}
-
-export class CounterNewBinding {
-  private readonly counter: CounterNew
-  private readonly ctx: BaseContext
-
-  constructor(name: string, ctx: BaseContext) {
-    this.counter = CounterNew._create(name)
-    this.ctx = ctx
-  }
-
-  add(value: Numberish, labels: Labels = {}) {
-    this.counter.add(this.ctx, value, labels)
-  }
-
-  sub(value: Numberish, labels: Labels = {}) {
-    this.counter.sub(this.ctx, value, labels)
-  }
-}
-
-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/fuel/asset-processor.ts

@@ -61,6 +61,7 @@ export class FuelAssetProcessor implements FuelBaseProcessor<FuelAssetProcessorC
           from: [],
           to: []
         }
+        let assetId = ''
         for (const input of tx.transaction.inputs || []) {
           if (input.type == InputType.Coin) {
             transfer.from.push({
@@ -68,6 +69,7 @@ export class FuelAssetProcessor implements FuelBaseProcessor<FuelAssetProcessorC
               assetId: input.assetId,
               amount: BigInt(input.amount.toString(10))
             })
+            assetId = input.assetId
           }
         }
 
@@ -82,11 +84,12 @@ export class FuelAssetProcessor implements FuelBaseProcessor<FuelAssetProcessorC
                 amount: BigInt(value),
                 assetId: output.assetId
               })
+              if (assetId == '') {
+                assetId = output.assetId
+              }
           }
         }
 
-        const assetId = transfer.from[0].assetId || ''
-
         const ctx = new FuelContext(
           this.config.chainId,
           assetId,

package/src/stark/codegen/codegen.ts

@@ -0,0 +1,125 @@
+import fs, { readFileSync, writeFileSync } from 'fs'
+import chalk from 'chalk'
+import path from 'path'
+import { mkdirpSync } from 'mkdirp'
+import { events } from 'starknet'
+import { StarknetChainId } from '@sentio/chain'
+import { Abi } from '@sentio/abi-wan-kanabi'
+import { recursiveCodegen } from '../../core/codegen.js'
+
+export async function codegen(abisDir: string, outDir: string) {
+  if (!fs.existsSync(abisDir)) {
+    return
+  }
+
+  const numFiles = await recursiveCodegen(abisDir, outDir, codegenInternal)
+  console.log(chalk.green(`Generated ${numFiles} files for Starknet`))
+}
+
+async function codegenInternal(abisDir: string, outDir: string): Promise<number> {
+  const allFiles = fs.readdirSync(abisDir, { recursive: true }) as string[]
+
+  const abis: Record<string, any> = {}
+  let fileCount = 0
+
+  function guessNameFromAbi(abi: any, address: string) {
+    if (Array.isArray(abi)) {
+      const arr = abi as any[]
+      for (const a of arr) {
+        if (a.type == 'impl') {
+          return a.name.replace('Impl', '')
+        }
+      }
+    }
+    return 'Contract' + address.replace('0x', '').slice(0, 6)
+  }
+
+  for (const f of allFiles) {
+    if (f.toLowerCase().endsWith('.json')) {
+      let name = f.replace('.json', '')
+      const content = readFileSync(path.join(abisDir, f))
+      const abi = JSON.parse(content.toString())
+      let chain = StarknetChainId.STARKNET_MAINNET
+      if (name.startsWith('sepolia/')) {
+        chain = StarknetChainId.STARKNET_SEPOLIA
+        name = name.slice('sepolia/'.length)
+      }
+      const parts = name.split('-')
+      const address = parts.pop() as string
+      if (parts.length > 0) {
+        name = parts.join('')
+      } else {
+        name = guessNameFromAbi(abi, address)
+      }
+      abis[name] = {
+        name,
+        address,
+        chain,
+        abi
+      }
+    }
+  }
+
+  const tABIContents: string[] = []
+
+  for (const [name, abi] of Object.entries(abis)) {
+    tABIContents.push(`export const ABI_${name} = ${JSON.stringify(abi.abi, null, 2)} as const;`)
+  }
+
+  mkdirpSync(outDir)
+  writeFileSync(path.join(outDir, 'tabi.ts'), tABIContents.join('\n'))
+  fileCount++
+  for (const { name, address, chain, abi: jsonAbi } of Object.values(abis)) {
+    const content: string[] = []
+    content.push(
+      `import { StarknetProcessorConfig, StarknetEvent, AbstractStarknetProcessor, StarknetContext } from '@sentio/sdk/starknet'`
+    )
+    content.push(`import { EventToPrimitiveType, TypedContractView, Abi } from "@sentio/abi-wan-kanabi"`)
+    content.push(`import { ABI_${name} } from "./tabi.js"\n`)
+    content.push(`export type ${name} = TypedContractView<typeof ABI_${name}>`)
+    const abi = jsonAbi as Abi
+    const abiEventsEnums = abi.filter((obj) => obj.type == 'event' && obj.kind === 'enum')
+    const eventMap: Record<string, string> = {}
+    for (const ev of Object.values(events.getAbiEvents(abi))) {
+      const fullName = ev.name as string
+      let eventName = fullName
+      for (const e of abiEventsEnums) {
+        for (const v of e.variants) {
+          if (v.type === fullName) {
+            eventName = v.name
+            break
+          }
+        }
+      }
+
+      eventMap[eventName] = fullName
+      content.push(`export type ${eventName} = EventToPrimitiveType<typeof ABI_${name}, "${fullName}">`)
+    }
+
+    content.push(`\nexport class ${name}Processor extends AbstractStarknetProcessor {
+  constructor(abi: Abi, config: Partial<StarknetProcessorConfig>) {
+    super(abi, {
+      name: "${name}",
+      address: "${address}",
+      chainId: "${chain}",
+      abi,
+      ...config
+    })
+  }`)
+    content.push(`\tstatic bind(config: Partial<StarknetProcessorConfig>) {
+      return new ${name}Processor(ABI_${name}, config)
+  }`)
+
+    for (const [eventName, structName] of Object.entries(eventMap)) {
+      content.push(`\ton${eventName}(handler: (event: StarknetEvent<${eventName}>, ctx: StarknetContext<${name}>) => Promise<void>) {
+    return this.onEvent<${eventName}, ${name}>("${eventName}", "${structName}", handler)
+  }`)
+    }
+
+    content.push(`}`)
+    writeFileSync(path.join(outDir, `${name}-processor.ts`), content.join('\n'))
+    fileCount++
+  }
+
+  return fileCount
+}

package/src/stark/codegen/index.ts

@@ -0,0 +1 @@
+export * from './codegen.js'

package/src/stark/codegen/run.ts

@@ -0,0 +1,10 @@
+import { codegen } from './index.js'
+
+if (process.argv.length > 3) {
+  const abisDir = process.argv[2]
+  const targetDir = process.argv[3]
+  await codegen(abisDir, targetDir)
+} else {
+  console.error('Not enough argument')
+  process.exit(1)
+}

package/src/stark/codegen/utils.ts

@@ -0,0 +1,3 @@
+export function upperFirst(str: string): string {
+  return str.charAt(0).toUpperCase() + str.slice(1)
+}

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,116 @@
+import { errorString, GLOBAL_CONFIG, mergeProcessResults, Plugin, PluginManager, USER_PROCESSOR } from '@sentio/runtime'
+import {
+  ContractConfig,
+  DataBinding,
+  HandlerType,
+  InitResponse,
+  ProcessConfigResponse,
+  ProcessResult,
+  StartRequest
+} from '@sentio/protos'
+
+import { ServerError, Status } from 'nice-grpc'
+import { TemplateInstanceState } from '../core/template.js'
+import { HandlerRegister } from '../core/handler-register.js'
+import { StarknetProcessorState } from './starknet-processor.js'
+import { hash } from 'starknet'
+
+export class StarknetPlugin extends Plugin {
+  name: string = 'StarknetPlugin'
+  handlerRegister = new HandlerRegister()
+
+  async init(config: InitResponse) {
+    for (const solanaProcessor of StarknetProcessorState.INSTANCE.getValues()) {
+      const chainId = solanaProcessor.config.chainId
+      config.chainIds.push(chainId)
+    }
+  }
+
+  async configure(config: ProcessConfigResponse, forChainId?: string) {
+    this.handlerRegister.clear(forChainId as any)
+
+    for (const processor of StarknetProcessorState.INSTANCE.getValues()) {
+      const chainId = processor.config.chainId
+      if (forChainId !== undefined && forChainId !== chainId.toString()) {
+        continue
+      }
+      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 = this.handlerRegister.register(callHandler.handler, chainId)
+
+        if (callHandler.eventFilter) {
+          contractConfig.starknetEventConfigs.push({
+            filters: callHandler.eventFilter.map((e) => ({
+              address: processor.config.address,
+              keys: [hash.getSelectorFromName(e)]
+            })),
+            handlerId,
+            handlerName: callHandler.handlerName
+          })
+        }
+      }
+
+      // Finish up a contract
+      config.contractConfigs.push(contractConfig)
+    }
+  }
+
+  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.handlerRegister
+        .getHandlerById(
+          binding.chainId,
+          handlerId
+        )(binding.data?.starknetEvents)
+        .catch((e: any) => {
+          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())