@sentio/sdk 2.35.0 → 2.35.1-rc.1

package/src/fuel/codegen/codegen.ts

@@ -0,0 +1,149 @@
+import fs, { readFileSync, writeFileSync } from 'fs'
+import chalk from 'chalk'
+import { AbiTypeGen, IFile, IFunction, ProgramTypeEnum } from '@fuel-ts/abi-typegen'
+import mkdirp from 'mkdirp'
+import path from 'path'
+import { upperFirst } from './utils.js'
+
+export async function codegen(abisDir: string, outDir: string) {
+  if (!fs.existsSync(abisDir)) {
+    return
+  }
+
+  const numFiles = await codegenInternal(abisDir, outDir)
+  console.log(chalk.green(`Generated ${numFiles} files for Fuel`))
+}
+
+function patchImport(contents: string) {
+  return contents.replace(/from\s+['"](\..+)['"]/g, `from '\$1.js'`)
+}
+
+function patchEnumType(contents: string) {
+  const matches = contents.matchAll(/export type (.+) = Enum<{ Ok: T, Err: E }>;/g)
+
+  for (const m of matches) {
+    const vname = m[1]
+    contents = contents.replace(m[0], `export type ${vname}<T,E> = Enum<{ Ok: T, Err: E }>;`)
+
+    const reg = new RegExp(`export type (.+) = ${vname}`, 'g')
+    contents = contents.replace(reg, `export type \$1<T,E> = ${vname}<T,E>`)
+  }
+  return contents
+}
+
+async function codegenInternal(abisDir: string, outDir: string): Promise<number> {
+  const allFiles = fs.readdirSync(abisDir)
+  if (allFiles.length === 0) {
+    return 0
+  }
+
+  const allABIFiles = []
+  for (const f of allFiles) {
+    if (f.toLowerCase().endsWith('-abi.json')) {
+      allABIFiles.push(path.join(abisDir, f))
+    }
+  }
+  if (allABIFiles.length === 0) {
+    return 0
+  }
+  const abiFiles = allABIFiles.map((filepath) => {
+    const abi: IFile = {
+      path: filepath,
+      contents: readFileSync(filepath, 'utf-8')
+    }
+    return abi
+  })
+
+  // fuels type gen
+  const abiTypeGen = new AbiTypeGen({
+    abiFiles,
+    binFiles: [],
+    storageSlotsFiles: [],
+    outputDir: outDir,
+    programType: ProgramTypeEnum.CONTRACT
+  })
+
+  mkdirp.sync(outDir)
+  mkdirp.sync(path.join(outDir, 'factories'))
+
+  abiTypeGen.files.forEach((file) => {
+    if (!file.path.endsWith('.hex.ts')) {
+      let content = patchImport(file.contents)
+      content = patchEnumType(content)
+      writeFileSync(file.path, content)
+    }
+  })
+
+  for (const abi of abiTypeGen.abis) {
+    const name = abi.name.endsWith('Abi') ? abi.name.slice(0, -3) : abi.name
+    const filePath = path.join(outDir, `${name}Processor.ts`)
+    const importedTypes = collectImportedTypes(abi.types)
+
+    const content = `/* Autogenerated file. Do not edit manually. */
+
+/* tslint:disable */
+/* eslint-disable */
+    
+import { FuelAbstractProcessor, FuelContext, FuelProcessorConfig, TypedCall, FuelFetchConfig} from '@sentio/sdk/fuel'
+import {${abi.name}__factory } from './factories/${abi.name}__factory.js'
+import {${abi.commonTypesInUse.join(',')}} from './common.js'
+import {${importedTypes.join(',')}} from './${abi.name}.js'
+
+import type {
+  BigNumberish,
+  BN,
+  BytesLike,
+} from 'fuels';
+
+
+namespace ${name} {
+${abi.functions.map(genCallType).join('\n')}
+}
+
+export class ${name}Processor extends FuelAbstractProcessor {
+  constructor(config?: FuelProcessorConfig) {
+    super(${abi.name}__factory.abi, config)
+  }
+  
+  static bind(config?: FuelProcessorConfig) {
+    return new ${name}Processor(config)
+  }
+
+${abi.functions.map((f) => genOnCallFunction(name, f)).join('\n')}   
+}
+`
+    writeFileSync(filePath, content)
+  }
+
+  return allABIFiles.length
+}
+
+function genCallType(f: IFunction) {
+  const name = upperFirst(f.name)
+  return `
+  export interface ${name}Call extends TypedCall<[${f.attributes.inputs}], ${f.attributes.output}> {
+      args: [${f.attributes.inputs}]
+      returnValue: ${f.attributes.output}
+  }
+`
+}
+
+function genOnCallFunction(contractName: string, f: IFunction) {
+  const name = upperFirst(f.name)
+  return `
+  onCall${name}(handler: (call: ${contractName}.${name}Call, ctx: FuelContext) => void | Promise<void>, config: FuelFetchConfig) {
+      super.onCallMethod('${f.name}', handler, config)
+  }`
+}
+
+function collectImportedTypes(types: any[]): string[] {
+  const ret = new Set<string>()
+  for (const type of types) {
+    if ((type && type.name == 'struct') || type.name == 'enum') {
+      ret.add(type.attributes.inputLabel)
+      ret.add(type.attributes.outputLabel)
+    }
+  }
+
+  return Array.from(ret)
+}

package/src/fuel/codegen/index.ts

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

package/src/fuel/codegen/run.ts

@@ -0,0 +1,10 @@
+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/fuel/codegen/utils.ts

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

package/src/fuel/context.ts

@@ -0,0 +1,34 @@
+import { BaseContext, Labels, normalizeLabels } from '../core/index.js'
+import { ChainId } from '@sentio/chain'
+import { RecordMetaData } from '@sentio/protos'
+import { InvocationCallResult } from 'fuels'
+import { FuelTransaction } from './transaction.js'
+
+export type FuelCall = InvocationCallResult
+
+export class FuelContext extends BaseContext {
+  constructor(
+    readonly transaction: FuelTransaction | null,
+    readonly chainId: ChainId
+  ) {
+    super({})
+  }
+
+  getChainId(): ChainId {
+    return this.chainId
+  }
+
+  protected getMetaDataInternal(name: string, labels: Labels): RecordMetaData {
+    return {
+      address: this.transaction?.id || '',
+      contractName: this.transaction?.id || '', // TODO
+      blockNumber: 0n,
+      transactionIndex: 0,
+      transactionHash: this.transaction?.id || '', // TODO
+      chainId: this.getChainId(),
+      name: name,
+      logIndex: 0,
+      labels: normalizeLabels(labels)
+    }
+  }
+}

package/src/fuel/fuel-plugin.ts

@@ -0,0 +1,128 @@
+import { errorString, GLOBAL_CONFIG, mergeProcessResults, Plugin, PluginManager, USER_PROCESSOR } from '@sentio/runtime'
+import {
+  ContractConfig,
+  Data_FuelCall,
+  DataBinding,
+  HandlerType,
+  ProcessConfigResponse,
+  ProcessResult,
+  StartRequest
+} from '@sentio/protos'
+
+import { ServerError, Status } from 'nice-grpc'
+import { GlobalProcessorState } from '../eth/base-processor.js'
+import { TemplateInstanceState } from '../core/template.js'
+import { FuelProcessorState } from './fuel-processor.js'
+
+interface Handlers {
+  callHandlers: ((trace: Data_FuelCall) => Promise<ProcessResult>)[]
+}
+
+export class FuelPlugin extends Plugin {
+  name: string = 'FuelPlugin'
+  handlers: Handlers = {
+    callHandlers: []
+  }
+
+  async configure(config: ProcessConfigResponse) {
+    const handlers: Handlers = {
+      callHandlers: []
+    }
+
+    for (const processor of FuelProcessorState.INSTANCE.getValues()) {
+      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 = handlers.callHandlers.push(callHandler.handler) - 1
+        const fetchConfig = {
+          handlerId,
+          filters: callHandler.fetchConfig.filters || []
+        }
+        contractConfig.fuelCallConfigs.push(fetchConfig)
+      }
+
+      // Finish up a contract
+      config.contractConfigs.push(contractConfig)
+    }
+
+    for (const processor of GlobalProcessorState.INSTANCE.getValues()) {
+      const chainId = processor.getChainId()
+
+      const contractConfig = ContractConfig.fromPartial({
+        processorType: USER_PROCESSOR,
+        contract: {
+          name: processor.config.name,
+          chainId: chainId.toString(),
+          address: processor.config.address, // can only be *
+          abi: ''
+        },
+        startBlock: processor.config.startBlock,
+        endBlock: processor.config.endBlock
+      })
+
+      config.contractConfigs.push(contractConfig)
+    }
+
+    this.handlers = handlers
+  }
+
+  supportedHandlers = [HandlerType.FUEL_CALL]
+
+  processBinding(request: DataBinding): Promise<ProcessResult> {
+    // return Promise.resolve(undefined);
+    switch (request.handlerType) {
+      // case HandlerType.FUEL_LOG:
+      //   return this.processLog(request)
+      // case HandlerType.FUEL_TRACE:
+      //   return this.processTrace(request)
+      // case HandlerType.FUEL_BLOCK:
+      //   return this.processBlock(request)
+      case HandlerType.FUEL_CALL:
+        return this.processTransaction(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 processTransaction(binding: DataBinding): Promise<ProcessResult> {
+    if (!binding.data?.fuelCall?.transaction) {
+      throw new ServerError(Status.INVALID_ARGUMENT, "transaction can't be null")
+    }
+    const fuelTransaction = binding.data.fuelCall
+
+    const promises: Promise<ProcessResult>[] = []
+
+    for (const handlerId of binding.handlerIds) {
+      const promise = this.handlers.callHandlers[handlerId](fuelTransaction).catch((e) => {
+        throw new ServerError(
+          Status.INTERNAL,
+          'error processing transaction: ' + JSON.stringify(fuelTransaction.transaction) + '\n' + errorString(e)
+        )
+      })
+      if (GLOBAL_CONFIG.execution.sequential) {
+        await promise
+      }
+      promises.push(promise)
+    }
+    return mergeProcessResults(await Promise.all(promises))
+  }
+}
+
+PluginManager.INSTANCE.register(new FuelPlugin())

package/src/fuel/fuel-processor.ts

@@ -0,0 +1,125 @@
+import { ListStateStorage } from '@sentio/runtime'
+import { Data_FuelCall, FuelCallFilter, FuelCallHandlerConfig, ProcessResult } from '@sentio/protos'
+import { FuelCall, FuelContext } from './context.js'
+import { bn, Contract, Interface, InvocationCallResult, JsonAbi, Provider } from 'fuels'
+import { FuelNetwork, getRpcEndpoint } from './network.js'
+import { decodeFuelTransaction, DEFAULT_FUEL_FETCH_CONFIG, FuelFetchConfig, FuelTransaction } from './transaction.js'
+
+export class FuelProcessorState extends ListStateStorage<FuelProcessor> {
+  static INSTANCE = new FuelProcessorState()
+}
+
+export class FuelProcessor {
+  callHandlers: CallHandler<Data_FuelCall>[] = []
+
+  private provider: Provider
+
+  static bind(config: FuelProcessorConfig): FuelProcessor {
+    const processor = new FuelProcessor(config)
+    FuelProcessorState.INSTANCE.addValue(processor)
+    return processor
+  }
+
+  constructor(readonly config: FuelProcessorConfig) {}
+
+  async configure() {
+    const url = getRpcEndpoint(this.config.chainId)
+    this.provider = await Provider.create(url)
+  }
+
+  public onTransaction(
+    handler: (transaction: FuelTransaction, ctx: FuelContext) => void | Promise<void>,
+    config: FuelFetchConfig = DEFAULT_FUEL_FETCH_CONFIG
+  ) {
+    const callHandler = {
+      handler: async (call: Data_FuelCall) => {
+        const abiMap = this.config.abi
+          ? {
+              [this.config.address]: this.config.abi
+            }
+          : {}
+        const tx = decodeFuelTransaction(call.transaction, abiMap, this.provider)
+
+        const ctx = new FuelContext(tx, this.config.chainId)
+        await handler(tx, ctx)
+        return ctx.stopAndGetResult()
+      },
+      fetchConfig: {
+        filters: [],
+        ...config
+      }
+    }
+    this.callHandlers.push(callHandler)
+    return this
+  }
+
+  public onCall(
+    nameFilter: string | string[],
+    handler: (call: FuelCall, ctx: FuelContext) => void | Promise<void>,
+    config: FuelFetchConfig = DEFAULT_FUEL_FETCH_CONFIG
+  ) {
+    const names = new Set(Array.isArray(nameFilter) ? nameFilter : [nameFilter])
+
+    if (!this.config.abi) {
+      throw new Error('ABI must be provided to use onCall')
+    }
+    const abi = this.config.abi
+
+    const filters: Record<string, FuelCallFilter> = {}
+    const abiInterface = new Interface(abi)
+    for (const name of names) {
+      try {
+        const func = abiInterface.functions[name]
+        const filter = bn(func.selector, 'hex').toString()
+        filters[func.name] = {
+          function: filter,
+          includeFailed: !!config.includeFailed
+        }
+      } catch (e) {
+        console.error(e)
+      }
+    }
+
+    const callHandler = {
+      handler: async (call: Data_FuelCall) => {
+        const contract = new Contract(this.config.address, abi, this.provider)
+        const gqlTransaction = call.transaction
+        const tx = decodeFuelTransaction(gqlTransaction, { [this.config.address]: abi }, this.provider)
+
+        const ctx = new FuelContext(tx, this.config.chainId)
+        for (const op of tx.operations) {
+          for (const call of op.calls || []) {
+            if (names.has(call.functionName)) {
+              const fn = contract.functions[call.functionName]
+              const args = Object.values(call.argumentsProvided || {})
+              const scope = fn(...args)
+              const invocationResult = await InvocationCallResult.build(scope, tx, false)
+              await handler(invocationResult, ctx)
+            }
+          }
+        }
+
+        return ctx.stopAndGetResult()
+      },
+      fetchConfig: {
+        filters: Object.values(filters)
+      }
+    }
+    this.callHandlers.push(callHandler)
+    return this
+  }
+}
+
+export type CallHandler<T> = {
+  handler: (call: T) => Promise<ProcessResult>
+  fetchConfig: Partial<FuelCallHandlerConfig>
+}
+
+export type FuelProcessorConfig = {
+  address: string
+  name?: string
+  chainId: FuelNetwork
+  startBlock?: bigint
+  endBlock?: bigint
+  abi?: JsonAbi
+}

package/src/fuel/index.ts

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

package/src/fuel/network.ts

@@ -0,0 +1,16 @@
+import { FuelChainId } from '@sentio/chain'
+import { FUEL_BETA_5_NETWORK_URL, FUEL_NETWORK_URL } from 'fuels'
+
+export type FuelNetwork = FuelChainId
+export const FuelNetwork = <const>{
+  MAIN_NET: FuelChainId.FUEL_MAINNET,
+  TEST_NET: FuelChainId.FUEL_TESTNET_BETA_V5
+}
+
+export function getRpcEndpoint(network: FuelNetwork): string {
+  switch (network) {
+    case FuelNetwork.TEST_NET:
+      return FUEL_BETA_5_NETWORK_URL
+  }
+  return FUEL_NETWORK_URL
+}

package/src/fuel/transaction.ts

@@ -0,0 +1,43 @@
+import {
+  AbiMap,
+  arrayify,
+  assembleTransactionSummary,
+  bn,
+  processGqlReceipt,
+  Provider,
+  TransactionCoder,
+  TransactionSummary
+} from 'fuels'
+
+export type FuelFetchConfig = {
+  includeFailed?: boolean
+}
+
+export const DEFAULT_FUEL_FETCH_CONFIG: FuelFetchConfig = {
+  includeFailed: false
+}
+
+export type FuelTransaction = TransactionSummary
+
+export function decodeFuelTransaction(gqlTransaction: any, abiMap: AbiMap, provider: Provider): FuelTransaction {
+  const rawPayload = arrayify(gqlTransaction.rawPayload)
+
+  const [decodedTransaction] = new TransactionCoder().decode(rawPayload, 0)
+
+  const receipts = gqlTransaction.receipts?.map(processGqlReceipt) || []
+
+  const { gasPerByte, gasPriceFactor, maxInputs, gasCosts } = provider.getChain().consensusParameters
+
+  return assembleTransactionSummary({
+    id: gqlTransaction.id,
+    receipts,
+    transaction: decodedTransaction,
+    transactionBytes: rawPayload,
+    gqlTransactionStatus: gqlTransaction.status,
+    gasPerByte: bn(gasPerByte),
+    gasPriceFactor: bn(gasPriceFactor),
+    abiMap,
+    maxInputs,
+    gasCosts
+  })
+}

package/src/testing/fuel-facet.ts

@@ -0,0 +1,58 @@
+import { TestProcessorServer } from './test-processor-server.js'
+import { FuelChainId } from '@sentio/chain'
+import { DataBinding, HandlerType } from '@sentio/protos'
+import { FuelNetwork } from '../fuel/index.js'
+
+export class FuelFacet {
+  server: TestProcessorServer
+
+  constructor(server: TestProcessorServer) {
+    this.server = server
+  }
+
+  testOnTransaction(transaction: any, network: FuelNetwork = FuelNetwork.TEST_NET) {
+    const bindings = this.buildBinding(transaction, network)
+    if (!bindings) {
+      throw Error('Invalid test transaction: ' + JSON.stringify(transaction))
+    }
+
+    return this.server.processBindings({
+      bindings
+    })
+  }
+
+  private buildBinding(transaction: any, network: FuelChainId): DataBinding[] {
+    const res: DataBinding[] = []
+    for (const config of this.server.contractConfigs) {
+      if (config.contract?.chainId !== network) {
+        continue
+      }
+      for (const callConfig of config.fuelCallConfigs) {
+        const binding = {
+          data: {
+            fuelCall: {
+              transaction,
+              timestamp: new Date()
+            }
+          },
+          handlerIds: [callConfig.handlerId],
+          handlerType: HandlerType.FUEL_CALL
+        }
+
+        const filter = callConfig.filters[0]?.function
+        if (filter) {
+          // filter out by tx receipt
+          for (const receipt of transaction.receipts || []) {
+            if (receipt.receiptType == 'CALL' && receipt.param1 == filter) {
+              res.push(binding)
+            }
+          }
+        } else {
+          res.push(binding)
+        }
+      }
+    }
+
+    return res
+  }
+}

package/src/testing/test-processor-server.ts

@@ -8,7 +8,7 @@ import {
   ProcessConfigRequest,
   ProcessConfigResponse,
   ProcessorServiceImplementation,
-  StartRequest,
+  StartRequest
 } from '@sentio/protos'
 import { CallContext } from 'nice-grpc-common'
 import { Endpoints, ProcessorServiceImpl, State } from '@sentio/runtime'
@@ -18,6 +18,7 @@ import { AptosFacet } from './aptos-facet.js'
 import { SolanaFacet } from './solana-facet.js'
 import { EthFacet } from './eth-facet.js'
 import { SuiFacet } from './sui-facet.js'
+import { FuelFacet } from './fuel-facet.js'
 
 export const TEST_CONTEXT: CallContext = <CallContext>{}
 
@@ -34,6 +35,7 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
   eth: EthFacet
   solana: SolanaFacet
   sui: SuiFacet
+  fuel: FuelFacet
 
   constructor(loader: () => Promise<any>, httpEndpoints: Record<string, string> = {}) {
     cleanTest()
@@ -43,6 +45,7 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
     this.solana = new SolanaFacet(this)
     this.eth = new EthFacet(this)
     this.sui = new SuiFacet(this)
+    this.fuel = new FuelFacet(this)
 
     for (const k in CHAIN_MAP) {
       const http = httpEndpoints[k] || ''