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

package/src/btc/types.ts

@@ -1,134 +0,0 @@
-import { BaseContext, Labels, normalizeLabels } from '../core/index.js'
-import { Data_BTCBlock, HandleInterval, ProcessResult, RecordMetaData } from '@sentio/protos'
-import { ChainId } from '@sentio/chain'
-
-export type Transaction = {
-  txid: string
-  hash: string
-  txindex: number
-  blockhash: string
-  blockheight: number
-  blocktime: number
-  size: number
-  vsize: number
-  version: number
-  locktime: number
-  vin: Vin[]
-  vout: Vout[]
-}
-
-export type Vin = {
-  vin_index: number
-  coinbase?: string
-  txid?: string
-  vout?: number
-  sequence: number
-  witness?: string[]
-  scriptSig: {
-    asm: string
-    hex: string
-  }
-  pre_vout?: Vout
-  pre_transaction?: Transaction
-}
-
-export type Vout = {
-  value: number
-  n: number
-  scriptPubKey: {
-    asm: string
-    hex: string
-    reqSigs: number
-    type: string
-    address: string
-  }
-}
-
-export type BTCBlock = {
-  hash: string
-  confirmations: number
-  strippedsize: number
-  size: number
-  weight: number
-  height: number
-  version: number
-  merkleroot: string
-  tx?: Transaction[]
-  time: number
-  nonce: number
-  bits: string
-  difficulty: number
-  previousblockhash: string
-  nextblockhash: string
-}
-
-export class BTCContext extends BaseContext {
-  constructor(
-    readonly chainId: string,
-    readonly name: string,
-    readonly tx: Transaction,
-    readonly address: string
-  ) {
-    super({})
-  }
-
-  protected getMetaDataInternal(name: string, labels: Labels): RecordMetaData {
-    return {
-      address: this.address,
-      contractName: this.name,
-      blockNumber: BigInt(this.tx.blockheight ?? 0),
-      transactionIndex: 0,
-      transactionHash: this.tx.txid,
-      chainId: this.getChainId(),
-      name: name,
-      logIndex: 0,
-      labels: normalizeLabels(labels)
-    }
-  }
-
-  getChainId(): ChainId {
-    return this.chainId as ChainId
-  }
-}
-
-export class BTCBlockContext extends BaseContext {
-  constructor(
-    readonly chainId: string,
-    readonly name: string,
-    readonly block: BTCBlock,
-    readonly address?: string
-  ) {
-    super({})
-  }
-
-  protected getMetaDataInternal(name: string, labels: Labels): RecordMetaData {
-    return {
-      address: this.address ?? '',
-      contractName: this.name,
-      blockNumber: BigInt(this.block.height ?? 0),
-      transactionIndex: 0,
-      transactionHash: '',
-      chainId: this.getChainId(),
-      name: name,
-      logIndex: 0,
-      labels: normalizeLabels(labels)
-    }
-  }
-
-  getChainId(): ChainId {
-    return this.chainId as ChainId
-  }
-}
-
-export type BlockHandler = {
-  blockInterval?: HandleInterval
-  timeIntervalInMinutes?: HandleInterval
-  handler: (block: Data_BTCBlock) => Promise<ProcessResult>
-  handlerName: string
-  fetchConfig?: BTCOnIntervalFetchConfig
-  partitionHandler?: (block: Data_BTCBlock) => Promise<string | undefined>
-}
-
-export type BTCOnIntervalFetchConfig = {
-  getTransactions?: boolean
-}

package/src/stark/codegen/codegen.ts

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

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

package/src/stark/codegen/run.ts

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

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

package/src/stark/context.ts

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

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

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

package/src/stark/index.ts

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

@@ -1,116 +0,0 @@
-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())