@sentio/sdk 2.43.3-rc.3 → 2.44.0-rc.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentio/sdk",
-  "version": "2.43.3-rc.3",
+  "version": "2.44.0-rc.10",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
@@ -84,8 +84,8 @@
     "typechain": "^8.3.2",
     "utility-types": "^3.11.0",
     "yaml": "^2.3.4",
-    "@sentio/protos": "2.43.3-rc.3",
-    "@sentio/runtime": "^2.43.3-rc.3"
+    "@sentio/protos": "2.44.0-rc.10",
+    "@sentio/runtime": "^2.44.0-rc.10"
   },
   "peerDependencies": {
     "tsup": "npm:@sentio/tsup@^6.7.5"

package/src/btc/btc-plugin.ts

@@ -1,6 +1,7 @@
 import { errorString, GLOBAL_CONFIG, mergeProcessResults, Plugin, PluginManager, USER_PROCESSOR } from '@sentio/runtime'
 import {
   ContractConfig,
+  Data_BTCBlock,
   Data_BTCTransaction,
   DataBinding,
   HandlerType,
@@ -16,17 +17,20 @@ import { filters2Proto, TransactionFilter } from './filter.js'
 
 interface Handlers {
   txHandlers: ((trace: Data_BTCTransaction) => Promise<ProcessResult>)[]
+  blockHandlers: ((trace: Data_BTCBlock) => Promise<ProcessResult>)[]
 }
 
 export class BTCPlugin extends Plugin {
   name: string = 'BTCPlugin'
   handlers: Handlers = {
-    txHandlers: []
+    txHandlers: [],
+    blockHandlers: []
   }
 
   async configure(config: ProcessConfigResponse) {
     const handlers: Handlers = {
-      txHandlers: []
+      txHandlers: [],
+      blockHandlers: []
     }
 
     for (const processor of BTCProcessorState.INSTANCE.getValues()) {
@@ -61,6 +65,24 @@ export class BTCPlugin extends Plugin {
         }
       }
 
+      for (const blockHandler of processor.blockHandlers) {
+        const handlerId = handlers.blockHandlers.push(blockHandler.handler) - 1
+        contractConfig.intervalConfigs.push({
+          slot: 0,
+          slotInterval: blockHandler.blockInterval,
+          minutes: 0,
+          minutesInterval: blockHandler.timeIntervalInMinutes,
+          handlerId,
+          fetchConfig: {
+            transaction: blockHandler.fetchConfig?.getTransactions ?? false,
+            trace: false,
+            block: true,
+            transactionReceipt: false,
+            transactionReceiptLogs: false
+          }
+        })
+      }
+
       // Finish up a contract
       config.contractConfigs.push(contractConfig)
     }
@@ -68,12 +90,14 @@ export class BTCPlugin extends Plugin {
     this.handlers = handlers
   }
 
-  supportedHandlers = [HandlerType.BTC_TRANSACTION]
+  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)
     }
@@ -108,6 +132,29 @@ export class BTCPlugin extends Plugin {
     }
     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.handlers.blockHandlers[handlerId](block).catch((e) => {
+        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,7 +1,9 @@
 import { ListStateStorage } from '@sentio/runtime'
-import { BTCContext, Transaction } from './types.js'
-import { Data_BTCTransaction, ProcessResult } from '@sentio/protos'
+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 { PromiseOrVoid } from '../core/index.js'
+import { ServerError, Status } from 'nice-grpc'
 
 export class BTCProcessorState extends ListStateStorage<BTCProcessor> {
   static INSTANCE = new BTCProcessorState()
@@ -9,6 +11,7 @@ export class BTCProcessorState extends ListStateStorage<BTCProcessor> {
 
 export class BTCProcessor {
   callHandlers: CallHandler<Data_BTCTransaction>[] = []
+  blockHandlers: BlockHandler[] = []
 
   constructor(readonly config: BTCProcessorConfig) {}
 
@@ -40,6 +43,80 @@ export class BTCProcessor {
     this.callHandlers.push(callHandler)
     return this
   }
+
+  public onInterval(
+    handler: (block: BTCBlock, ctx: BTCBlockContext) => PromiseOrVoid,
+    timeInterval: HandleInterval | undefined,
+    blockInterval: HandleInterval | undefined,
+    fetchConfig?: BTCOnIntervalFetchConfig
+  ): this {
+    if (timeInterval) {
+      if (timeInterval.backfillInterval < timeInterval.recentInterval) {
+        timeInterval.backfillInterval = timeInterval.recentInterval
+      }
+    }
+
+    const processor = this
+
+    this.blockHandlers.push({
+      blockInterval,
+      timeIntervalInMinutes: timeInterval,
+      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 (fetchConfig?.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()
+      }
+    })
+    return this
+  }
+
+  public onBlockInterval(
+    handler: (block: BTCBlock, ctx: BTCBlockContext) => PromiseOrVoid,
+    blockInterval = 250,
+    backfillBlockInterval = 1000,
+    fetchConfig?: BTCOnIntervalFetchConfig
+  ): this {
+    return this.onInterval(
+      handler,
+      undefined,
+      {
+        recentInterval: blockInterval,
+        backfillInterval: backfillBlockInterval
+      },
+      fetchConfig
+    )
+  }
+
+  public onTimeInterval(
+    handler: (block: BTCBlock, ctx: BTCBlockContext) => PromiseOrVoid,
+    timeIntervalInMinutes = 60,
+    backfillTimeIntervalInMinutes = 240,
+    fetchConfig?: BTCOnIntervalFetchConfig
+  ): this {
+    return this.onInterval(
+      handler,
+      { recentInterval: timeIntervalInMinutes, backfillInterval: backfillTimeIntervalInMinutes },
+      undefined,
+      fetchConfig
+    )
+  }
 }
 
 interface BTCProcessorConfig {

package/src/btc/types.ts

@@ -1,5 +1,5 @@
 import { BaseContext, Labels, normalizeLabels } from '../core/index.js'
-import { RecordMetaData } from '@sentio/protos'
+import { Data_BTCBlock, HandleInterval, ProcessResult, RecordMetaData } from '@sentio/protos'
 import { ChainId } from '@sentio/chain'
 
 export type Transaction = {
@@ -44,21 +44,22 @@ export type Vout = {
   }
 }
 
-export type Block = {
-  block_hash: string
-  block_number: number
-  block_timestamp: Date
+export type BTCBlock = {
+  hash: string
+  confirmations: number
+  strippedsize: number
   size: number
-  stripped_size: number
   weight: number
+  height: number
   version: number
-  merkle_root: string
+  merkleroot: string
+  tx?: Transaction[]
+  time: number
   nonce: number
   bits: string
   difficulty: number
-  previous_hash: string
-  next_hash: string
-  transaction_count: number
+  previousblockhash: string
+  nextblockhash: string
 }
 
 export class BTCContext extends BaseContext {
@@ -89,3 +90,43 @@ export class BTCContext extends BaseContext {
     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>
+  fetchConfig?: BTCOnIntervalFetchConfig
+}
+
+export type BTCOnIntervalFetchConfig = {
+  getTransactions: boolean
+}

package/src/fuel/asset-processor.ts

@@ -4,6 +4,7 @@ import { FuelNetwork, getRpcEndpoint } from './network.js'
 import { FuelContext } from './context.js'
 import { decodeFuelTransaction } from './transaction.js'
 import { Provider, InputType, OutputType } from 'fuels'
+import { getOptionsSignature } from './fuel-processor.js'
 
 export class FuelAssetProcessor implements FuelBaseProcessor<FuelAssetProcessorConfig> {
   callHandlers: CallHandler<Data_FuelCall>[] = []
@@ -12,7 +13,13 @@ export class FuelAssetProcessor implements FuelBaseProcessor<FuelAssetProcessorC
 
   static bind(config: FuelAssetProcessorConfig): FuelAssetProcessor {
     const processor = new FuelAssetProcessor(config)
-    FuelProcessorState.INSTANCE.addValue(processor)
+    const sig =
+      'assets_' +
+      getOptionsSignature({
+        ...config,
+        address: '*'
+      })
+    FuelProcessorState.INSTANCE.getOrSetValue(sig, processor)
     return processor
   }
 

package/src/fuel/base-processor.ts

@@ -1,8 +1,8 @@
-import { FuelProcessor, FuelProcessorConfig } from './fuel-processor.js'
+import { addFuelProcessor, FuelProcessor, FuelProcessorConfig } from './fuel-processor.js'
 import { Contract, JsonAbi } from 'fuels'
 // import { FuelCall } from './context.js'
 import { FuelChainId } from '@sentio/chain'
-import { FuelLog, FuelProcessorState } from './types.js'
+import { FuelLog } from './types.js'
 
 export abstract class FuelAbstractProcessor<TContract extends Contract> extends FuelProcessor<TContract> {
   protected constructor(abi: JsonAbi, config?: Omit<FuelProcessorConfig, 'abi'>) {
@@ -16,7 +16,7 @@ export abstract class FuelAbstractProcessor<TContract extends Contract> extends
       ...config,
       abi
     })
-    FuelProcessorState.INSTANCE.addValue(this)
+    addFuelProcessor(config, this)
   }
 }
 

package/src/fuel/codegen/codegen.ts

@@ -115,7 +115,7 @@ async function codegenInternal(abisDir: string, outDir: string): Promise<number>
 /* tslint:disable */
 /* eslint-disable */
     
-import { FuelAbstractProcessor, FuelContractContext, FuelProcessorConfig, TypedCall, FuelFetchConfig, FuelCall, FuelLog} from '@sentio/sdk/fuel'
+import { FuelAbstractProcessor, FuelContractContext, FuelProcessorConfig, TypedCall, FuelFetchConfig, FuelCall, FuelLog, addFuelProcessor, getFuelProcessor, FuelBaseProcessorTemplate } from '@sentio/sdk/fuel'
 import {${abi.commonTypesInUse.join(',')}} from './common.js'
 import {${importedTypes.join(',')}, ${abi.capitalizedName}} from './${abi.capitalizedName}.js'
 
@@ -144,12 +144,23 @@ ${
 }
 }
 
+type LogIdFilter<T> = T | T[]
+${getLogConstants(logByTypes)}
+
 export class ${name}Processor extends FuelAbstractProcessor<${name}> {
-  static bind(config: Omit<FuelProcessorConfig, 'abi'>) {
-    return new ${name}Processor(${abi.capitalizedName}.abi, {
-      name: '${name}',
-      ...config,
-    })
+  static bind(options: Omit<FuelProcessorConfig, 'abi'>) {
+    if (!options.name) {
+      options.name = "${name}"
+    }
+    let processor = getFuelProcessor(options) as ${name}Processor
+    if (!processor) {
+      processor = new ${name}Processor(${abi.capitalizedName}.abi, {
+        name: '${name}',
+        ...options,
+      })
+      addFuelProcessor(options, processor)
+    }
+    return processor
   }
 
 ${
@@ -158,11 +169,22 @@ ${
        abi.functions.map((f) => genOnCallFunction(name, f)).join('\n') */
 }   
 
-${Object.entries(logByTypes)
-  .map((e) => genOnLogFunction(name, e))
-  .join('\n')}
+  ${Object.entries(logByTypes)
+    .map((e) => genOnLogFunction(name, e))
+    .join('\n')}
+
+}
+
+export class ${name}ProcessorTemplate extends FuelBaseProcessorTemplate<${name}> {
+  bindInternal(options: Omit<FuelProcessorConfig, 'abi'>) {
+    return ${name}Processor.bind(options)
+  }
 
+  ${Object.entries(logByTypes)
+    .map((e) => genOnLogFunction(name, e))
+    .join('\n')}
 }
+
 `
     writeFileSync(filePath, content)
     count++
@@ -215,11 +237,33 @@ function collectImportedTypes(types: any[]): string[] {
   return Array.from(ret)
 }
 
+function getLogConstants(logByTypes: Record<string, string[]>) {
+  return Object.entries(logByTypes)
+    .map(([t, ids]) => {
+      const name = getTypeName(t)
+      if (ids.length == 1) {
+        return `const Log${name}Id = "${ids[0]}"`
+      }
+      return ids.map((id, idx) => `const Log${name}Id${idx} = "${id}"`).join('\n')
+    })
+    .join('\n')
+}
+
 function genOnLogFunction(contractName: string, [type, ids]: [string, string[]]) {
   const name = getTypeName(type)
+
+  if (ids.length == 1) {
+    return `
+  onLog${name}(handler: (log: FuelLog<${type}>, ctx: FuelContractContext<${contractName}>) => void | Promise<void>) {
+    return super.onLog<${type}>([Log${name}Id], (log, ctx) => handler(log, ctx))
+  }`
+  }
+  const logIdFilterValues = ids.map((_, idx) => `Log${name}Id${idx}`)
+
   return `
-  onLog${name}(handler: (log: FuelLog<${type}>, ctx: FuelContractContext<${contractName}>) => void | Promise<void>, logIdFilter?: string | string[]) {
-    return super.onLog<${type}>(logIdFilter ?? [${ids.map((id) => `"${id}"`).join(', ')}], (log, ctx) => handler(log, ctx))
+  onLog${name}(handler: (log: FuelLog<${type}>, ctx: FuelContractContext<${contractName}>) => void | Promise<void>, 
+               logIdFilter?: LogIdFilter<${logIdFilterValues.map((d) => `typeof ${d}`).join(' | ')}> ) {
+    return super.onLog<${type}>(logIdFilter ?? [${logIdFilterValues.join(', ')}], (log, ctx) => handler(log, ctx))
   }`
 }
 

package/src/fuel/context.ts

@@ -1,5 +1,5 @@
 import { BaseContext, Labels, normalizeLabels } from '../core/index.js'
-import { ChainId } from '@sentio/chain'
+import { FuelChainId } from '@sentio/chain'
 import { RecordMetaData } from '@sentio/protos'
 import type { CallResult, Contract } from 'fuels'
 import { InvocationScopeLike } from 'fuels'
@@ -20,7 +20,7 @@ export class FuelCall {
 export class FuelContext extends BaseContext {
   private logIndex: number = -1
   constructor(
-    readonly chainId: ChainId,
+    readonly chainId: FuelChainId,
     readonly contractAddress: string,
     readonly contractName: string,
     readonly timestamp: Date,
@@ -30,7 +30,7 @@ export class FuelContext extends BaseContext {
     super({})
   }
 
-  getChainId(): ChainId {
+  getChainId(): FuelChainId {
     return this.chainId
   }
 
@@ -55,7 +55,7 @@ export class FuelContext extends BaseContext {
 
 export class FuelContractContext<TContract extends Contract> extends FuelContext {
   constructor(
-    readonly chainId: ChainId,
+    readonly chainId: FuelChainId,
     readonly contract: TContract,
     readonly contractAddress: string,
     readonly contractName: string,

package/src/fuel/fuel-processor-template.ts

@@ -0,0 +1,161 @@
+import { FuelContext, FuelContractContext } from './context.js'
+import { HandleInterval, TemplateInstance } from '@sentio/protos'
+import { PromiseOrVoid } from '../core/promises.js'
+import { ListStateStorage } from '@sentio/runtime'
+import { TemplateInstanceState } from '../core/template.js'
+import { Contract } from 'fuels'
+import { FuelBlock, FuelLog, FuelTransaction } from './types.js'
+import { DEFAULT_FUEL_FETCH_CONFIG, FuelFetchConfig } from './transaction.js'
+import { FuelProcessor, FuelProcessorConfig, getOptionsSignature } from './fuel-processor.js'
+
+export class FuelProcessorTemplateProcessorState extends ListStateStorage<FuelBaseProcessorTemplate<Contract>> {
+  static INSTANCE = new FuelProcessorTemplateProcessorState()
+}
+
+export abstract class FuelBaseProcessorTemplate<TContract extends Contract> {
+  id: number
+  binds = new Set<string>()
+  blockHandlers: {
+    handler: (block: FuelBlock, ctx: FuelContractContext<TContract>) => PromiseOrVoid
+    blockInterval?: HandleInterval
+    timeIntervalInMinutes?: HandleInterval
+    // fetchConfig?: FuelFetchConfig
+  }[] = []
+
+  logHandlers: {
+    logIdFilter: string | string[]
+    handler: (logs: FuelLog<any>, ctx: FuelContractContext<TContract>) => PromiseOrVoid
+    // fetchConfig?: FuelFetchConfig
+  }[] = []
+
+  transactionHandlers: {
+    handler: (transaction: FuelTransaction, ctx: FuelContractContext<TContract>) => PromiseOrVoid
+    fetchConfig: FuelFetchConfig
+  }[] = []
+
+  constructor() {
+    this.id = FuelProcessorTemplateProcessorState.INSTANCE.getValues().length
+    FuelProcessorTemplateProcessorState.INSTANCE.addValue(this)
+  }
+
+  /**
+   * Bind template using {@param options}, using {@param ctx}'s network value if not provided in the option
+   * @param options
+   * @param ctx
+   */
+  public bind(options: Omit<Omit<FuelProcessorConfig, 'chainId'>, 'abi'>, ctx: FuelContext): void {
+    const sig = getOptionsSignature({
+      address: options.address,
+      chainId: ctx.chainId
+    })
+    if (this.binds.has(sig)) {
+      console.log(`Same address can be bind to one template only once, ignore duplicate bind: ${sig}`)
+      return
+    }
+    this.binds.add(sig)
+
+    const processor = this.bindInternal({ ...options, chainId: ctx.chainId })
+
+    for (const eh of this.logHandlers) {
+      processor.onLog(eh.logIdFilter, eh.handler)
+    }
+    for (const bh of this.blockHandlers) {
+      processor.onInterval(bh.handler, bh.timeIntervalInMinutes, bh.blockInterval)
+    }
+    for (const th of this.transactionHandlers) {
+      processor.onTransaction(th.handler)
+    }
+
+    const instance: TemplateInstance = {
+      templateId: this.id,
+      contract: {
+        address: options.address,
+        name: options.name || '',
+        chainId: ctx.chainId,
+        abi: ''
+      },
+      startBlock: BigInt(options.startBlock || 0),
+      endBlock: BigInt(options.endBlock || 0),
+      baseLabels: {}
+      // baseLabels: options.baseLabels
+    }
+    TemplateInstanceState.INSTANCE.addValue(instance)
+    ctx.update({
+      states: {
+        configUpdated: true
+      }
+    })
+  }
+
+  protected onLog<T>(
+    logIdFilter: string | string[],
+    handler: (logs: FuelLog<T>, ctx: FuelContractContext<TContract>) => PromiseOrVoid
+    // fetchConfig?: Partial<FuelFetchConfig>
+  ) {
+    this.logHandlers.push({
+      logIdFilter,
+      handler
+      // fetchConfig: { ...fetchConfig}
+    })
+    return this
+  }
+
+  public onBlockInterval(
+    handler: (block: FuelBlock, ctx: FuelContractContext<TContract>) => PromiseOrVoid,
+    blockInterval = 1000,
+    backfillBlockInterval = 4000
+    // fetchConfig?: Partial<FuelFetchConfig>
+  ) {
+    return this.onInterval(
+      handler,
+      undefined,
+      {
+        recentInterval: blockInterval,
+        backfillInterval: backfillBlockInterval
+      }
+      // fetchConfig
+    )
+  }
+
+  public onTimeInterval(
+    handler: (block: FuelBlock, ctx: FuelContractContext<TContract>) => PromiseOrVoid,
+    timeIntervalInMinutes = 60,
+    backfillBlockInterval = 240
+    // fetchConfig?: Partial<FuelFetchConfig>
+  ) {
+    return this.onInterval(
+      handler,
+      { recentInterval: timeIntervalInMinutes, backfillInterval: backfillBlockInterval },
+      undefined
+      // fetchConfig
+    )
+  }
+
+  public onInterval(
+    handler: (block: FuelBlock, ctx: FuelContractContext<TContract>) => PromiseOrVoid,
+    timeInterval: HandleInterval | undefined,
+    blockInterval: HandleInterval | undefined
+    // fetchConfig?: FuelFetchConfig
+  ) {
+    this.blockHandlers.push({
+      handler,
+      timeIntervalInMinutes: timeInterval,
+      blockInterval
+      // fetchConfig: { ...fetchConfig }
+    })
+    return this
+  }
+
+  protected onTransaction(
+    handler: (transaction: FuelTransaction, ctx: FuelContractContext<TContract>) => PromiseOrVoid,
+    config: FuelFetchConfig = DEFAULT_FUEL_FETCH_CONFIG
+  ) {
+    this.transactionHandlers.push({
+      handler,
+      fetchConfig: config
+    })
+    return this
+  }
+
+  protected abstract bindInternal(options: Omit<FuelProcessorConfig, 'abi'>): FuelProcessor<TContract>
+}