@sentio/sdk 2.35.0 → 2.36.0-rc.1

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] || ''