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

package/src/btc/btc-plugin.ts

@@ -1,209 +0,0 @@
-import { errorString, GLOBAL_CONFIG, mergeProcessResults, Plugin, PluginManager, USER_PROCESSOR } from '@sentio/runtime'
-import {
-  ContractConfig,
-  DataBinding,
-  HandlerType,
-  InitResponse,
-  ProcessConfigResponse,
-  ProcessResult,
-  ProcessStreamResponse_Partitions,
-  StartRequest
-} from '@sentio/protos'
-
-import { ServerError, Status } from 'nice-grpc'
-import { PartitionHandlerManager } from '../core/index.js'
-import { HandlerRegister } from '../core/handler-register.js'
-import { TemplateInstanceState } from '../core/template.js'
-import { BTCProcessorState } from './btc-processor.js'
-import { filters2Proto, TransactionFilter } from './filter.js'
-
-export class BTCPlugin extends Plugin {
-  name: string = 'BTCPlugin'
-  handlerRegister = new HandlerRegister()
-  partitionManager = new PartitionHandlerManager()
-
-  async init(config: InitResponse) {
-    for (const aptosProcessor of BTCProcessorState.INSTANCE.getValues()) {
-      const chainId = aptosProcessor.config.chainId
-      config.chainIds.push(chainId)
-    }
-  }
-
-  async configure(config: ProcessConfigResponse, forChainId?: string) {
-    this.handlerRegister.clear(forChainId as any)
-
-    for (const processor of BTCProcessorState.INSTANCE.getValues()) {
-      const chainId = processor.config.chainId
-      if (forChainId !== undefined && forChainId !== chainId.toString()) {
-        continue
-      }
-      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)
-        this.partitionManager.registerPartitionHandler(
-          HandlerType.BTC_TRANSACTION,
-          handlerId,
-          callHandler.partitionHandler
-        )
-        const handlerName = callHandler.handlerName
-
-        if (callHandler.filter) {
-          contractConfig.btcTransactionConfigs.push({
-            filters: filters2Proto(callHandler.filter),
-            handlerId,
-            handlerName
-          })
-        } else if (contractConfig.contract?.address != '*') {
-          contractConfig.btcTransactionConfigs.push({
-            filters: filters2Proto({
-              outputFilter: {
-                script_address: processor.config.address
-              }
-            } as TransactionFilter),
-            handlerId,
-            handlerName
-          })
-        }
-      }
-
-      for (const blockHandler of processor.blockHandlers) {
-        const handlerId = this.handlerRegister.register(blockHandler.handler, chainId)
-        this.partitionManager.registerPartitionHandler(HandlerType.BTC_BLOCK, handlerId, blockHandler.partitionHandler)
-        contractConfig.intervalConfigs.push({
-          slot: 0,
-          slotInterval: blockHandler.blockInterval,
-          minutes: 0,
-          minutesInterval: blockHandler.timeIntervalInMinutes,
-          handlerId,
-          handlerName: blockHandler.handlerName,
-          fetchConfig: {
-            transaction: blockHandler.fetchConfig?.getTransactions ?? false,
-            trace: false,
-            block: true,
-            transactionReceipt: false,
-            transactionReceiptLogs: false
-          }
-        })
-      }
-
-      // Finish up a contract
-      config.contractConfigs.push(contractConfig)
-    }
-  }
-
-  supportedHandlers = [HandlerType.BTC_TRANSACTION, HandlerType.BTC_BLOCK]
-
-  processBinding(request: DataBinding): Promise<ProcessResult> {
-    switch (request.handlerType) {
-      case HandlerType.BTC_TRANSACTION:
-        return this.processTransaction(request)
-      case HandlerType.BTC_BLOCK:
-        return this.processBlock(request)
-      default:
-        throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
-    }
-  }
-
-  async partition(request: DataBinding): Promise<ProcessStreamResponse_Partitions> {
-    let data: any
-    switch (request.handlerType) {
-      case HandlerType.BTC_TRANSACTION:
-        if (!request.data?.btcTransaction) {
-          throw new ServerError(Status.INVALID_ARGUMENT, "btcTransaction can't be empty")
-        }
-        data = request.data.btcTransaction
-        break
-      case HandlerType.BTC_BLOCK:
-        if (!request.data?.btcBlock) {
-          throw new ServerError(Status.INVALID_ARGUMENT, "btcBlock can't be empty")
-        }
-        data = request.data.btcBlock
-        break
-      default:
-        throw new ServerError(Status.INVALID_ARGUMENT, 'No handle type registered ' + request.handlerType)
-    }
-    const partitions = await this.partitionManager.processPartitionForHandlerType(
-      request.handlerType,
-      request.handlerIds,
-      data
-    )
-    return {
-      partitions
-    }
-  }
-
-  async start(request: StartRequest) {}
-
-  stateDiff(config: ProcessConfigResponse): boolean {
-    return TemplateInstanceState.INSTANCE.getValues().length !== config.templateInstances.length
-  }
-
-  async processTransaction(binding: DataBinding): Promise<ProcessResult> {
-    if (!binding.data?.btcTransaction) {
-      throw new ServerError(Status.INVALID_ARGUMENT, "BTCEvents can't be null")
-    }
-
-    const promises: Promise<ProcessResult>[] = []
-
-    const result = binding.data?.btcTransaction
-
-    for (const handlerId of binding.handlerIds) {
-      const promise = this.handlerRegister
-        .getHandlerById(
-          binding.chainId,
-          handlerId
-        )(binding.data?.btcTransaction)
-        .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))
-  }
-
-  private async processBlock(request: DataBinding) {
-    if (!request.data?.btcBlock) {
-      throw new ServerError(Status.INVALID_ARGUMENT, "Block can't be empty")
-    }
-
-    const block = request.data.btcBlock
-
-    const promises: Promise<ProcessResult>[] = []
-    for (const handlerId of request.handlerIds) {
-      const promise = this.handlerRegister
-        .getHandlerById(
-          request.chainId,
-          handlerId
-        )(block)
-        .catch((e: any) => {
-          throw new ServerError(
-            Status.INTERNAL,
-            'error processing block: ' + JSON.stringify(block) + '\n' + errorString(e)
-          )
-        })
-      if (GLOBAL_CONFIG.execution.sequential) {
-        await promise
-      }
-      promises.push(promise)
-    }
-    return mergeProcessResults(await Promise.all(promises))
-  }
-}
-
-PluginManager.INSTANCE.register(new BTCPlugin())

package/src/btc/btc-processor.ts

@@ -1,165 +0,0 @@
-import { ListStateStorage } from '@sentio/runtime'
-import { BlockHandler, BTCBlock, BTCBlockContext, BTCContext, BTCOnIntervalFetchConfig, Transaction } from './types.js'
-import { Data_BTCBlock, Data_BTCTransaction, HandleInterval, ProcessResult } from '@sentio/protos'
-import { TransactionFilters } from './filter.js'
-import { HandlerOptions, PromiseOrVoid } from '../core/index.js'
-import { ServerError, Status } from 'nice-grpc'
-import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
-
-export class BTCProcessorState extends ListStateStorage<BTCProcessor> {
-  static INSTANCE = new BTCProcessorState()
-}
-
-export class BTCProcessor {
-  callHandlers: CallHandler<Data_BTCTransaction>[] = []
-  blockHandlers: BlockHandler[] = []
-
-  constructor(readonly config: BTCProcessorConfig) {
-    return proxyProcessor(this)
-  }
-
-  static bind(config: BTCProcessorConfig): BTCProcessor {
-    const processor = new BTCProcessor(config)
-    BTCProcessorState.INSTANCE.addValue(processor)
-    return processor
-  }
-
-  public onTransaction(
-    handler: (transaction: Transaction, ctx: BTCContext) => void | Promise<void>,
-    filter?: TransactionFilters,
-    handlerOptions?: HandlerOptions<object, Transaction>
-  ) {
-    const callHandler = {
-      handlerName: getHandlerName(),
-      handler: async (call: Data_BTCTransaction) => {
-        const tx = call.transaction as Transaction
-
-        const ctx = new BTCContext(
-          this.config.chainId,
-          this.config.name ?? this.config.address ?? '',
-          tx,
-          this.config.address ?? tx.vout?.[0]?.scriptPubKey?.address
-        )
-        await handler(tx, ctx)
-        return ctx.stopAndGetResult()
-      },
-      filter,
-      partitionHandler: async (call: Data_BTCTransaction): Promise<string | undefined> => {
-        const p = handlerOptions?.partitionKey
-        if (!p) return undefined
-        if (typeof p === 'function') {
-          const tx = call.transaction as Transaction
-          return p(tx)
-        }
-        return p
-      }
-    }
-    this.callHandlers.push(callHandler)
-    return this
-  }
-
-  public onInterval(
-    handler: (block: BTCBlock, ctx: BTCBlockContext) => PromiseOrVoid,
-    timeInterval: HandleInterval | undefined,
-    blockInterval: HandleInterval | undefined,
-    handlerOptions?: HandlerOptions<BTCOnIntervalFetchConfig, BTCBlock>
-  ): this {
-    if (timeInterval) {
-      if (timeInterval.backfillInterval < timeInterval.recentInterval) {
-        timeInterval.backfillInterval = timeInterval.recentInterval
-      }
-    }
-
-    const processor = this
-
-    this.blockHandlers.push({
-      blockInterval,
-      timeIntervalInMinutes: timeInterval,
-      handlerName: getHandlerName(),
-      handler: async function (data: Data_BTCBlock) {
-        const header = data.block
-        if (!header) {
-          throw new ServerError(Status.INVALID_ARGUMENT, 'Block is empty')
-        }
-
-        const block = {
-          ...header
-        } as BTCBlock
-        if (handlerOptions?.getTransactions) {
-          block.tx = header.rawtx?.map((tx: any) => tx as Transaction)
-        }
-
-        const ctx = new BTCBlockContext(
-          processor.config.chainId,
-          processor.config.name ?? processor.config.address ?? '',
-          block,
-          processor.config.address
-        )
-        await handler(block, ctx)
-        return ctx.stopAndGetResult()
-      },
-      fetchConfig: handlerOptions,
-      partitionHandler: async (data: Data_BTCBlock): Promise<string | undefined> => {
-        const p = handlerOptions?.partitionKey
-        if (!p) return undefined
-        if (typeof p === 'function') {
-          const header = data.block
-          if (!header) return undefined
-          const block = { ...header } as BTCBlock
-          if (handlerOptions?.getTransactions) {
-            block.tx = header.rawtx?.map((tx: any) => tx as Transaction)
-          }
-          return p(block)
-        }
-        return p
-      }
-    })
-    return this
-  }
-
-  public onBlockInterval(
-    handler: (block: BTCBlock, ctx: BTCBlockContext) => PromiseOrVoid,
-    blockInterval = 250,
-    backfillBlockInterval = 1000,
-    handlerOptions?: HandlerOptions<BTCOnIntervalFetchConfig, BTCBlock>
-  ): this {
-    return this.onInterval(
-      handler,
-      undefined,
-      {
-        recentInterval: blockInterval,
-        backfillInterval: backfillBlockInterval
-      },
-      handlerOptions
-    )
-  }
-
-  public onTimeInterval(
-    handler: (block: BTCBlock, ctx: BTCBlockContext) => PromiseOrVoid,
-    timeIntervalInMinutes = 60,
-    backfillTimeIntervalInMinutes = 240,
-    handlerOptions?: HandlerOptions<BTCOnIntervalFetchConfig, BTCBlock>
-  ): this {
-    return this.onInterval(
-      handler,
-      { recentInterval: timeIntervalInMinutes, backfillInterval: backfillTimeIntervalInMinutes },
-      undefined,
-      handlerOptions
-    )
-  }
-}
-
-interface BTCProcessorConfig {
-  chainId: string
-  name?: string
-  address?: string
-  startBlock?: bigint
-  endBlock?: bigint
-}
-
-export type CallHandler<T> = {
-  handlerName: string
-  handler: (call: T) => Promise<ProcessResult>
-  filter?: TransactionFilters
-  partitionHandler?: (call: T) => Promise<string | undefined>
-}

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'