@sentio/sdk 2.62.0-rc.9 → 2.62.1-rc.1

package/src/btc/filter.ts

@@ -1,206 +0,0 @@
-import {
-  BTCTransactionFilter,
-  BTCTransactionFilter_Condition,
-  BTCTransactionFilter_Filter,
-  BTCTransactionFilter_Filters,
-  BTCTransactionFilter_VinFilter,
-  BTCTransactionFilter_VOutFilter
-} from '@sentio/protos'
-import { serializeRichValue } from '../store/util.js'
-import { BigDecimal } from '@sentio/bigdecimal'
-import { Transaction, Vin, Vout } from './types.js'
-
-export type TransactionFields = keyof Omit<Transaction, 'vin' | 'vout'>
-
-export type VinFields = keyof Omit<Vin, 'pre_vout' | 'pre_transaction' | 'scriptSig'> | 'script_asm' | 'script_hex'
-
-export type VOutFields =
-  | keyof Omit<Vout, 'scriptPubKey'>
-  | 'script_asm'
-  | 'script_hex'
-  | 'script_type'
-  | 'script_address'
-
-export type Filter<F extends string> = {
-  [K in F]?: Condition | Comparable
-}
-
-export type Condition = {
-  eq?: Comparable
-  gt?: Comparable
-  gte?: Comparable
-  lt?: Comparable
-  lte?: Comparable
-  ne?: Comparable
-  // string has the prefix
-  prefix?: string
-  // string contains
-  contains?: string
-  notContains?: string
-  length?: number
-  lengthGt?: number
-  lengthLt?: number
-  // array contains any of the values
-  hasAny?: Array<Comparable>
-  // array contains all the values
-  hasAll?: Array<Comparable>
-  in?: Array<Comparable>
-}
-
-export type Filters<T extends string> = Filter<T> | Filter<T>[]
-
-export type VinFilter = Filter<VinFields> & {
-  preVOut?: Filter<VOutFields>
-  preTransaction?: {
-    filter?: Array<Filter<TransactionFields>>
-    outputFilter?: Filters<VOutFields>
-    // can't have inputFilter here, we can only support one level of nesting
-  }
-}
-
-export type VOutFilter = Filter<VOutFields>
-
-export type TransactionFilter = {
-  inputFilter?: VinFilter | VinFilter[]
-  outputFilter?: VOutFilter | VOutFilter[]
-  filter?: Array<Filter<TransactionFields>>
-}
-
-export type Comparable = number | BigDecimal | bigint | Date | string | boolean
-
-export type TransactionFilters = TransactionFilter | TransactionFilter[]
-
-function toVinFilter(inputFilter?: VinFilter | VinFilter[]): BTCTransactionFilter_VinFilter | undefined {
-  if (inputFilter) {
-    const ret = BTCTransactionFilter_VinFilter.create()
-    const filters = []
-    const vouts: Filter<VOutFields>[] = []
-    const txs: TransactionFilters = []
-
-    for (const f of Array.isArray(inputFilter) ? inputFilter : [inputFilter]) {
-      const { preVOut, preTransaction, ...rest } = f
-      filters.push(rest)
-      if (preVOut) {
-        vouts.push(preVOut)
-      }
-      if (preTransaction) {
-        txs.push(preTransaction)
-      }
-    }
-    ret.filters = BTCTransactionFilter_Filters.create({
-      filters: convertFilters(filters)
-    })
-
-    if (vouts.length > 0) {
-      const voutFilters = convertFilters(vouts)
-      if (voutFilters && voutFilters.length > 0) {
-        ret.preVOut = voutFilters[0]
-      }
-    }
-    if (txs.length > 0) {
-      ret.preTransaction = filters2Proto(txs)?.[0]
-    }
-
-    return ret
-  }
-
-  return undefined
-}
-
-function toVOutFilter(outputFilter?: VOutFilter | VOutFilter[]): BTCTransactionFilter_VOutFilter | undefined {
-  if (outputFilter) {
-    const ret = BTCTransactionFilter_VOutFilter.create()
-    const filters = Array.isArray(outputFilter) ? outputFilter : ([outputFilter] as Filter<VOutFields>[])
-    ret.filters = BTCTransactionFilter_Filters.create({
-      filters: convertFilters(filters)
-    })
-
-    return ret
-  }
-  return undefined
-}
-
-export function filters2Proto(filter: TransactionFilters): BTCTransactionFilter[] {
-  const filters = Array.isArray(filter) ? filter : [filter]
-  return filters.map((f) => {
-    return {
-      filter: convertFilters(f.filter),
-      inputFilter: toVinFilter(f.inputFilter),
-      outputFilter: toVOutFilter(f.outputFilter)
-    } as BTCTransactionFilter
-  })
-}
-
-function toCondition(value: Condition | Comparable): BTCTransactionFilter_Condition {
-  const ret: BTCTransactionFilter_Condition = BTCTransactionFilter_Condition.create()
-  if (value instanceof Date) {
-    ret.eq = serializeRichValue(value)
-  }
-  if (typeof value === 'number') {
-    ret.eq = serializeRichValue(value)
-  }
-  if (typeof value === 'string') {
-    ret.eq = serializeRichValue(value)
-  }
-  if (value instanceof BigDecimal) {
-    ret.eq = serializeRichValue(value)
-  }
-  if (typeof value === 'bigint') {
-    ret.eq = serializeRichValue(value)
-  }
-  if (typeof value === 'boolean') {
-    ret.eq = serializeRichValue(value)
-  }
-  if (Array.isArray(value)) {
-    ret.in = { values: value.map((v) => serializeRichValue(v)) }
-  }
-
-  for (const [k, v] of Object.entries(value)) {
-    switch (k) {
-      case 'prefix':
-      case 'contains':
-      case 'notContains':
-        ret[k] = v.toString()
-        break
-      case 'length':
-        ret['lengthEq'] = v
-        break
-      case 'lengthGt':
-      case 'lengthLt':
-        ret[k] = v
-        break
-      case 'hasAny':
-      case 'hasAll':
-      case 'in':
-        ret[k] = { values: v.map((v: any) => serializeRichValue(v)) }
-        break
-      case 'eq':
-      case 'gt':
-      case 'gte':
-      case 'lt':
-      case 'lte':
-      case 'ne':
-        ret[k] = serializeRichValue(v)
-        break
-      default:
-        throw new Error('Unknown condition op: ' + k)
-    }
-  }
-
-  return ret
-}
-
-function convertFilters<T extends string>(filters?: Array<Filter<T>>): BTCTransactionFilter_Filter[] | undefined {
-  if (filters && filters.length > 0) {
-    const ret: BTCTransactionFilter_Filter[] = []
-    for (const filter of filters) {
-      const f: BTCTransactionFilter_Filter = BTCTransactionFilter_Filter.create()
-      for (const [key, value] of Object.entries(filter)) {
-        f.conditions[key] = toCondition(value as any)
-      }
-      ret.push(f)
-    }
-    return ret
-  }
-  return []
-}

package/src/btc/index.ts

@@ -1,4 +0,0 @@
-export { BTCPlugin } from './btc-plugin.js'
-export * from './types.js'
-export * from './btc-processor.js'
-export * from './filter.js'

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'