@sentio/sdk 2.44.0-rc.1 → 2.44.0-rc.10

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>
+}

package/src/fuel/fuel-processor.ts

@@ -25,7 +25,7 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
 
   static bind(config: FuelProcessorConfig): FuelProcessor<any> {
     const processor = new FuelProcessor(config)
-    FuelProcessorState.INSTANCE.addValue(processor)
+    addFuelProcessor(config, processor)
     return processor
   }
 
@@ -49,7 +49,7 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
   }
 
   public onTransaction(
-    handler: (transaction: FuelTransaction, ctx: FuelContractContext<TContract>) => void | Promise<void>,
+    handler: (transaction: FuelTransaction, ctx: FuelContractContext<TContract>) => PromiseOrVoid,
     config: FuelFetchConfig = DEFAULT_FUEL_FETCH_CONFIG
   ) {
     const callHandler = {
@@ -161,7 +161,7 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
 
   public onLog<T>(
     logIdFilter: string | string[],
-    handler: (logs: FuelLog<T>, ctx: FuelContractContext<TContract>) => void | Promise<void>
+    handler: (logs: FuelLog<T>, ctx: FuelContractContext<TContract>) => PromiseOrVoid
   ) {
     const logIds = new Set(Array.isArray(logIdFilter) ? logIdFilter : [logIdFilter])
 
@@ -308,3 +308,32 @@ export type FuelProcessorConfig = {
   endBlock?: bigint
   abi: JsonAbi
 }
+
+export function getOptionsSignature(opts: Omit<FuelProcessorConfig, 'abi'>): string {
+  const sig = [opts.address]
+  if (opts.chainId) {
+    sig.push(opts.chainId)
+  }
+  if (opts.name) {
+    sig.push(opts.name)
+  }
+  if (opts.startBlock) {
+    sig.push(opts.startBlock.toString())
+  }
+  if (opts.endBlock) {
+    sig.push(opts.endBlock.toString())
+  }
+  return sig.join('_')
+}
+
+// Dedup processor that bind multiple times
+export function getFuelProcessor(opts: Omit<FuelProcessorConfig, 'abi'>) {
+  const sig = getOptionsSignature(opts)
+  return FuelProcessorState.INSTANCE.getValue(sig)
+}
+
+export function addFuelProcessor(opts: Omit<FuelProcessorConfig, 'abi'>, processor: FuelBaseProcessor<any>) {
+  const sig = getOptionsSignature(opts)
+
+  FuelProcessorState.INSTANCE.getOrSetValue(sig, processor)
+}

package/src/fuel/global-processor.ts

@@ -4,7 +4,7 @@ import { Provider } from 'fuels'
 import { getRpcEndpoint } from './network.js'
 import { decodeFuelTransaction, DEFAULT_FUEL_FETCH_CONFIG, FuelFetchConfig } from './transaction.js'
 import { FuelContext } from './context.js'
-import { FuelProcessorConfig } from './fuel-processor.js'
+import { FuelProcessorConfig, getOptionsSignature } from './fuel-processor.js'
 import { mergeProcessResults } from '@sentio/runtime'
 
 type GlobalFuelProcessorConfig = Omit<FuelProcessorConfig, 'address' | 'abi'>
@@ -17,7 +17,13 @@ export class FuelGlobalProcessor implements FuelBaseProcessor<GlobalFuelProcesso
 
   static bind(config: GlobalFuelProcessorConfig): FuelGlobalProcessor {
     const processor = new FuelGlobalProcessor(config)
-    FuelProcessorState.INSTANCE.addValue(processor)
+    const sig =
+      'global_' +
+      getOptionsSignature({
+        ...config,
+        address: '*'
+      })
+    FuelProcessorState.INSTANCE.getOrSetValue(sig, processor)
     return processor
   }
 

package/src/fuel/index.ts

@@ -1,6 +1,7 @@
 export { FuelPlugin } from './fuel-plugin.js'
 export * from './context.js'
 export * from './fuel-processor.js'
+export * from './fuel-processor-template.js'
 export * from './network.js'
 export * from './transaction.js'
 export * from './base-processor.js'

package/src/fuel/types.ts

@@ -1,4 +1,4 @@
-import { ListStateStorage } from '@sentio/runtime'
+import { MapStateStorage } from '@sentio/runtime'
 import {
   Data_FuelBlock,
   Data_FuelCall,
@@ -17,7 +17,7 @@ export interface FuelBaseProcessor<T> {
   blockHandlers: BlockHandler[]
 }
 
-export class FuelProcessorState extends ListStateStorage<FuelBaseProcessor<any>> {
+export class FuelProcessorState extends MapStateStorage<FuelBaseProcessor<any>> {
   static INSTANCE = new FuelProcessorState()
 }