@sentio/sdk 2.54.0-rc.6 → 2.54.0-rc.8

package/src/fuel/fuel-plugin.ts

@@ -3,6 +3,7 @@ import {
   ContractConfig,
   Data_FuelBlock,
   Data_FuelCall,
+  Data_FuelReceipt,
   DataBinding,
   HandlerType,
   ProcessConfigResponse,
@@ -18,21 +19,24 @@ import { FuelProcessor } from './fuel-processor.js'
 import { FuelGlobalProcessor } from './global-processor.js'
 
 interface Handlers {
-  callHandlers: ((trace: Data_FuelCall) => Promise<ProcessResult>)[]
+  transactionHandlers: ((trace: Data_FuelCall) => Promise<ProcessResult>)[]
   blockHandlers: ((block: Data_FuelBlock) => Promise<ProcessResult>)[]
+  logHandlers: ((log: Data_FuelReceipt) => Promise<ProcessResult>)[]
 }
 
 export class FuelPlugin extends Plugin {
   name: string = 'FuelPlugin'
   handlers: Handlers = {
-    callHandlers: [],
-    blockHandlers: []
+    transactionHandlers: [],
+    blockHandlers: [],
+    logHandlers: []
   }
 
   async configure(config: ProcessConfigResponse) {
     const handlers: Handlers = {
-      callHandlers: [],
-      blockHandlers: []
+      transactionHandlers: [],
+      blockHandlers: [],
+      logHandlers: []
     }
 
     for (const processor of FuelProcessorState.INSTANCE.getValues()) {
@@ -48,23 +52,16 @@ export class FuelPlugin extends Plugin {
         endBlock: processor.config.endBlock
       })
       for (const callHandler of processor.callHandlers) {
-        const handlerId = handlers.callHandlers.push(callHandler.handler) - 1
+        const handlerId = handlers.transactionHandlers.push(callHandler.handler) - 1
         const handlerName = callHandler.handlerName
         if (processor instanceof FuelProcessor) {
-          if (callHandler.logConfig?.logIds?.length) {
-            contractConfig.fuelLogConfigs.push({
-              logIds: callHandler.logConfig.logIds,
-              handlerId,
-              handlerName
-            })
-          } else {
-            const fetchConfig = {
-              handlerId,
-              handlerName,
-              filters: callHandler.fetchConfig?.filters || []
-            }
-            contractConfig.fuelCallConfigs.push(fetchConfig)
+          // on transaction
+          const fetchConfig = {
+            handlerId,
+            handlerName,
+            filters: callHandler.fetchConfig?.filters || []
           }
+          contractConfig.fuelCallConfigs.push(fetchConfig)
         } else if (processor instanceof FuelAssetProcessor) {
           const assetConfig = callHandler.assetConfig
           contractConfig.assetConfigs.push({
@@ -83,6 +80,18 @@ export class FuelPlugin extends Plugin {
         }
       }
 
+      for (const logHandler of processor.logHandlers ?? []) {
+        const handlerId = handlers.logHandlers.push(logHandler.handler) - 1
+        const handlerName = logHandler.handlerName
+        if (processor instanceof FuelProcessor) {
+          contractConfig.fuelLogConfigs.push({
+            logIds: logHandler.logConfig?.logIds || [],
+            handlerId,
+            handlerName
+          })
+        }
+      }
+
       for (const blockHandler of processor.blockHandlers) {
         const handlerId = handlers.blockHandlers.push(blockHandler.handler) - 1
         contractConfig.intervalConfigs.push({
@@ -97,19 +106,25 @@ export class FuelPlugin extends Plugin {
         })
       }
 
-      // Finish up a contract
       config.contractConfigs.push(contractConfig)
     }
 
     this.handlers = handlers
   }
 
-  supportedHandlers = [HandlerType.FUEL_CALL, HandlerType.FUEL_BLOCK]
+  supportedHandlers = [
+    HandlerType.FUEL_TRANSACTION,
+    HandlerType.FUEL_RECEIPT,
+    HandlerType.FUEL_CALL,
+    HandlerType.FUEL_BLOCK
+  ]
 
   processBinding(request: DataBinding): Promise<ProcessResult> {
     switch (request.handlerType) {
-      case HandlerType.FUEL_CALL:
+      case HandlerType.FUEL_TRANSACTION:
         return this.processTransaction(request)
+      case HandlerType.FUEL_RECEIPT:
+        return this.processLog(request)
       case HandlerType.FUEL_BLOCK:
         return this.processBlock(request)
       default:
@@ -131,16 +146,38 @@ export class FuelPlugin extends Plugin {
     return TemplateInstanceState.INSTANCE.getValues().length !== config.templateInstances.length
   }
 
+  async processLog(binding: DataBinding): Promise<ProcessResult> {
+    if (!binding.data?.fuelLog?.transaction) {
+      throw new ServerError(Status.INVALID_ARGUMENT, "transaction can't be null")
+    }
+    const log = binding.data.fuelLog
+
+    const promises: Promise<ProcessResult>[] = []
+
+    for (const handlerId of binding.handlerIds) {
+      const promise = this.handlers.logHandlers[handlerId](log).catch((e) => {
+        throw new ServerError(
+          Status.INTERNAL,
+          'error processing transaction: ' + JSON.stringify(log) + '\n' + errorString(e)
+        )
+      })
+      if (GLOBAL_CONFIG.execution.sequential) {
+        await promise
+      }
+      promises.push(promise)
+    }
+    return mergeProcessResults(await Promise.all(promises))
+  }
   async processTransaction(binding: DataBinding): Promise<ProcessResult> {
-    if (!binding.data?.fuelCall?.transaction) {
+    if (!binding.data?.fuelTransaction?.transaction) {
       throw new ServerError(Status.INVALID_ARGUMENT, "transaction can't be null")
     }
-    const fuelTransaction = binding.data.fuelCall
+    const fuelTransaction = binding.data.fuelTransaction
 
     const promises: Promise<ProcessResult>[] = []
 
     for (const handlerId of binding.handlerIds) {
-      const promise = this.handlers.callHandlers[handlerId](fuelTransaction).catch((e) => {
+      const promise = this.handlers.transactionHandlers[handlerId](fuelTransaction).catch((e) => {
         throw new ServerError(
           Status.INTERNAL,
           'error processing transaction: ' + JSON.stringify(fuelTransaction.transaction) + '\n' + errorString(e)

package/src/fuel/fuel-processor.ts

@@ -1,8 +1,21 @@
-import { Data_FuelBlock, Data_FuelCall, FuelCallFilter, HandleInterval, ProcessResult } from '@sentio/protos'
+import {
+  Data_FuelBlock,
+  Data_FuelCall,
+  Data_FuelReceipt,
+  FuelCallFilter,
+  HandleInterval,
+  ProcessResult
+} from '@sentio/protos'
 import { FuelCall, FuelContext, FuelContractContext } from './context.js'
 import { bn, Contract, Interface, JsonAbi, Provider } from 'fuels'
 import { FuelNetwork, getProvider } from './network.js'
-import { decodeFuelTransactionWithAbi, DEFAULT_FUEL_FETCH_CONFIG, FuelFetchConfig } from './transaction.js'
+import {
+  decodeFuelTransaction,
+  decodeFuelTransactionWithAbi,
+  decodeLog,
+  DEFAULT_FUEL_FETCH_CONFIG,
+  FuelFetchConfig
+} from './transaction.js'
 import {
   BlockHandler,
   CallHandler,
@@ -10,9 +23,9 @@ import {
   FuelBlock,
   FuelLog,
   FuelProcessorState,
-  FuelTransaction
+  FuelTransaction,
+  LogHandler
 } from './types.js'
-import { mergeProcessResults } from '@sentio/runtime'
 import { PromiseOrVoid } from '../core/index.js'
 import { ServerError, Status } from 'nice-grpc'
 import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
@@ -20,6 +33,7 @@ import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
 export class FuelProcessor<TContract extends Contract> implements FuelBaseProcessor<FuelProcessorConfig> {
   callHandlers: CallHandler<Data_FuelCall>[] = []
   blockHandlers: BlockHandler[] = []
+  logHandlers: LogHandler<Data_FuelReceipt>[] = []
 
   private provider: Provider
   private contract: TContract
@@ -35,6 +49,7 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
   }
 
   latestGasPrice: string | undefined
+
   async configure() {
     this.provider = await getProvider(this.config.chainId)
     this.provider.getLatestGasPrice = async () => {
@@ -169,52 +184,41 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
   ) {
     const logIds = new Set(Array.isArray(logIdFilter) ? logIdFilter : [logIdFilter])
 
-    const callHandler = {
+    const logHandler = {
       handlerName: getHandlerName(),
-      handler: async (call: Data_FuelCall) => {
+      handler: async ({ transaction, receiptIndex, timestamp }: Data_FuelReceipt) => {
         try {
-          const gqlTransaction = call.transaction
-          const tx = await decodeFuelTransactionWithAbi(
-            gqlTransaction,
-            { [this.config.address]: this.config.abi! },
-            this.provider
-          )
-
-          const results: ProcessResult[] = []
-          const logs = (tx.logs || []).filter((log) => logIds.has(log.logId))
-          for (const log of logs) {
+          const tx = decodeFuelTransaction(transaction, this.provider)
+          const index = Number(receiptIndex)
+          const receipt = tx.receipts[index]
+          const log = decodeLog(receipt, this.config.abi)
+          if (log) {
             const ctx = new FuelContractContext(
               this.config.chainId,
               this.contract,
               this.config.address,
               this.config.name ?? this.config.address,
-              call.timestamp || new Date(0),
+              timestamp || new Date(0),
               tx,
               null
             )
-            ctx.setLogIndex(log.receiptIndex)
-            await handler(log, ctx)
-            results.push(ctx.stopAndGetResult())
+            ctx.setLogIndex(index)
+            await handler({ receiptIndex: index, ...log }, ctx)
+            return ctx.stopAndGetResult()
+          } else {
+            console.error(`Log with receipt index ${receiptIndex} not found in tx`)
           }
-          return mergeProcessResults(results)
         } catch (e) {
           console.error(e)
-          return {
-            gauges: [],
-            counters: [],
-            events: [],
-            exports: [],
-            states: {
-              configUpdated: false
-            }
-          }
         }
+
+        return ProcessResult.fromPartial({})
       },
       logConfig: {
         logIds: Array.from(logIds)
       }
     }
-    this.callHandlers.push(callHandler)
+    this.logHandlers.push(logHandler)
     return this
   }
 

package/src/fuel/transaction.ts

@@ -7,6 +7,7 @@ import {
   Input,
   InputType,
   Interface,
+  JsonAbi,
   processGqlReceipt,
   Provider,
   ReceiptType,
@@ -65,6 +66,17 @@ export function decodeFuelTransaction(gqlTransaction: any, provider: Provider):
   }
 }
 
+export function decodeLog(receipt: any | undefined, abi: JsonAbi) {
+  if (receipt && (receipt.type === ReceiptType.LogData || receipt.type === ReceiptType.Log)) {
+    const interfaceToUse = new Interface(abi)
+    const data = receipt.type === ReceiptType.Log ? new BigNumberCoder('u64').encode(receipt.val0) : receipt.data
+    const logId: string = receipt.val1.toString()
+    const [decodedLog] = interfaceToUse.decodeLog(data, logId)
+    return { logId, data: decodedLog }
+  }
+  return null
+}
+
 export async function decodeFuelTransactionWithAbi(
   gqlTransaction: any,
   abiMap: AbiMap,
@@ -92,16 +104,13 @@ export async function decodeFuelTransactionWithAbi(
   const abi = Object.values(abiMap)[0]
   const logs = [] as FuelLog<any>[]
   ;(receipts as any[]).forEach((receipt, idx) => {
-    if (receipt.type === ReceiptType.LogData || receipt.type === ReceiptType.Log) {
-      try {
-        const interfaceToUse = new Interface(abi)
-        const data = receipt.type === ReceiptType.Log ? new BigNumberCoder('u64').encode(receipt.val0) : receipt.data
-        const logId = receipt.val1.toString()
-        const [decodedLog] = interfaceToUse.decodeLog(data, logId)
-        logs.push({ logId, data: decodedLog, receiptIndex: idx })
-      } catch (e) {
-        console.warn('Failed to decode log', e)
+    try {
+      const log = decodeLog(receipt, abi)
+      if (log) {
+        logs.push({ ...log, receiptIndex: idx })
       }
+    } catch (e) {
+      console.warn('Failed to decode log', e)
     }
   })
 

package/src/fuel/types.ts

@@ -2,6 +2,7 @@ import { MapStateStorage } from '@sentio/runtime'
 import {
   Data_FuelBlock,
   Data_FuelCall,
+  Data_FuelReceipt,
   FuelAssetHandlerConfig,
   FuelCallHandlerConfig,
   HandleInterval,
@@ -15,6 +16,7 @@ export interface FuelBaseProcessor<T> {
   config: T
   callHandlers: CallHandler<Data_FuelCall>[]
   blockHandlers: BlockHandler[]
+  logHandlers?: LogHandler<Data_FuelReceipt>[]
 }
 
 export class FuelProcessorState extends MapStateStorage<FuelBaseProcessor<any>> {
@@ -26,6 +28,11 @@ export type CallHandler<T> = {
   handler: (call: T) => Promise<ProcessResult>
   fetchConfig?: Partial<FuelCallHandlerConfig>
   assetConfig?: Partial<FuelAssetHandlerConfig>
+}
+
+export type LogHandler<T> = {
+  handlerName: string
+  handler: (call: T) => Promise<ProcessResult>
   logConfig?: {
     logIds: string[]
   }