@sentio/sdk 2.54.0-rc.1 → 2.54.0-rc.11

package/src/btc/btc-plugin.ts

@@ -47,11 +47,13 @@ export class BTCPlugin extends Plugin {
       })
       for (const callHandler of processor.callHandlers) {
         const handlerId = handlers.txHandlers.push(callHandler.handler) - 1
+        const handlerName = callHandler.handlerName
 
         if (callHandler.filter) {
           contractConfig.btcTransactionConfigs.push({
             filters: filters2Proto(callHandler.filter),
-            handlerId
+            handlerId,
+            handlerName
           })
         } else if (contractConfig.contract?.address != '*') {
           contractConfig.btcTransactionConfigs.push({
@@ -60,7 +62,8 @@ export class BTCPlugin extends Plugin {
                 script_address: processor.config.address
               }
             } as TransactionFilter),
-            handlerId
+            handlerId,
+            handlerName
           })
         }
       }

package/src/btc/btc-processor.ts

@@ -29,6 +29,7 @@ export class BTCProcessor {
     filter?: TransactionFilters
   ) {
     const callHandler = {
+      handlerName: getHandlerName(),
       handler: async (call: Data_BTCTransaction) => {
         const tx = call.transaction as Transaction
 
@@ -133,6 +134,7 @@ interface BTCProcessorConfig {
 }
 
 export type CallHandler<T> = {
+  handlerName: string
   handler: (call: T) => Promise<ProcessResult>
   filter?: TransactionFilters
 }

package/src/cosmos/cosmos-plugin.ts

@@ -45,6 +45,7 @@ export class CosmosPlugin extends Plugin {
 
         contractConfig.cosmosLogConfigs.push({
           handlerId,
+          handlerName: callHandler.handlerName,
           logFilters: callHandler.logConfig?.logFilters || []
         })
       }

package/src/cosmos/cosmos-processor.ts

@@ -2,11 +2,14 @@ import { CallHandler, CosmosProcessorConfig, CosmosProcessorState } from './type
 import { Data_CosmosCall } from '@sentio/protos'
 import { CosmosContext } from './context.js'
 import { CosmosEvent, CosmosTransaction, CosmosTxLog } from './transaction.js'
+import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
 
 export class CosmosProcessor {
   callHandlers: CallHandler<Data_CosmosCall>[] = []
 
-  constructor(readonly config: CosmosProcessorConfig) {}
+  constructor(readonly config: CosmosProcessorConfig) {
+    return proxyProcessor(this)
+  }
 
   static bind(config: CosmosProcessorConfig): CosmosProcessor {
     const processor = new CosmosProcessor(config)
@@ -20,6 +23,7 @@ export class CosmosProcessor {
   ) {
     const filter = Array.isArray(logFilters) ? logFilters : [logFilters]
     const callHandler = {
+      handlerName: getHandlerName(),
       handler: async (call: Data_CosmosCall) => {
         const transaction = call.transaction as CosmosTransaction
 

package/src/cosmos/types.ts

@@ -8,6 +8,7 @@ export class CosmosProcessorState extends ListStateStorage<CosmosProcessor> {
 }
 
 export type CallHandler<T> = {
+  handlerName: string
   handler: (call: T) => Promise<ProcessResult>
   logConfig?: {
     logFilters: string[]

package/src/eth/base-processor.ts

@@ -100,6 +100,8 @@ export class GlobalProcessor {
     if (config.endBlock) {
       this.config.endBlock = BigInt(config.endBlock)
     }
+
+    return proxyProcessor(this)
   }
 
   public onBlockInterval(

package/src/fuel/asset-processor.ts

@@ -5,6 +5,7 @@ import { FuelContext } from './context.js'
 import { decodeFuelTransaction } from './transaction.js'
 import { Provider, InputType, OutputType } from 'fuels'
 import { getOptionsSignature } from './fuel-processor.js'
+import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
 
 export class FuelAssetProcessor implements FuelBaseProcessor<FuelAssetProcessorConfig> {
   callHandlers: CallHandler<Data_FuelCall>[] = []
@@ -23,7 +24,9 @@ export class FuelAssetProcessor implements FuelBaseProcessor<FuelAssetProcessorC
     return processor
   }
 
-  constructor(readonly config: FuelAssetProcessorConfig) {}
+  constructor(readonly config: FuelAssetProcessorConfig) {
+    return proxyProcessor(this)
+  }
 
   async configure(): Promise<void> {
     this.provider = await getProvider(this.config.chainId)
@@ -49,6 +52,7 @@ export class FuelAssetProcessor implements FuelBaseProcessor<FuelAssetProcessorC
     }
 
     const callHandler = {
+      handlerName: getHandlerName(),
       handler: async (call: Data_FuelCall) => {
         const gqlTransaction = call.transaction
         const tx = decodeFuelTransaction(gqlTransaction, this.provider)

package/src/fuel/base-processor.ts

@@ -3,6 +3,7 @@ import { Contract, JsonAbi } from 'fuels'
 // import { FuelCall } from './context.js'
 import { FuelChainId } from '@sentio/chain'
 import { FuelLog } from './types.js'
+import { proxyProcessor } from '../utils/metrics.js'
 
 export abstract class FuelAbstractProcessor<TContract extends Contract> extends FuelProcessor<TContract> {
   protected constructor(abi: JsonAbi, config?: Omit<FuelProcessorConfig, 'abi'>) {
@@ -17,6 +18,7 @@ export abstract class FuelAbstractProcessor<TContract extends Contract> extends
       abi
     })
     addFuelProcessor(config, this)
+    return proxyProcessor(this)
   }
 }
 

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,29 +52,27 @@ 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
-            })
-          } else {
-            const fetchConfig = {
-              handlerId,
-              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({
             filters: assetConfig?.filters || [],
-            handlerId
+            handlerId,
+            handlerName
           })
         } else if (processor instanceof FuelGlobalProcessor) {
           const fetchConfig = {
             handlerId,
+            handlerName,
             filters: []
           }
           contractConfig.fuelCallConfigs.push(fetchConfig)
@@ -78,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({
@@ -92,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:
@@ -126,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 () => {
@@ -55,6 +70,7 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
     config: FuelFetchConfig = DEFAULT_FUEL_FETCH_CONFIG
   ) {
     const callHandler = {
+      handlerName: getHandlerName(),
       handler: async (call: Data_FuelCall) => {
         const abiMap = this.config.abi
           ? {
@@ -113,6 +129,7 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
     }
 
     const callHandler = {
+      handlerName: getHandlerName(),
       handler: async (call: Data_FuelCall) => {
         try {
           // const contract = new Contract(this.config.address, abi, this.provider)
@@ -167,51 +184,41 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
   ) {
     const logIds = new Set(Array.isArray(logIdFilter) ? logIdFilter : [logIdFilter])
 
-    const callHandler = {
-      handler: async (call: Data_FuelCall) => {
+    const logHandler = {
+      handlerName: getHandlerName(),
+      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/global-processor.ts

@@ -7,6 +7,7 @@ import { FuelContext } from './context.js'
 import { FuelProcessorConfig, getOptionsSignature } from './fuel-processor.js'
 import { mergeProcessResults } from '@sentio/runtime'
 import { ALL_ADDRESS } from '../core/index.js'
+import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
 
 type GlobalFuelProcessorConfig = Omit<FuelProcessorConfig, 'address' | 'abi'>
 
@@ -28,7 +29,9 @@ export class FuelGlobalProcessor implements FuelBaseProcessor<GlobalFuelProcesso
     return processor
   }
 
-  constructor(readonly config: GlobalFuelProcessorConfig) {}
+  constructor(readonly config: GlobalFuelProcessorConfig) {
+    return proxyProcessor(this)
+  }
 
   async configure() {
     this.provider = await getProvider(this.config.chainId)
@@ -39,6 +42,7 @@ export class FuelGlobalProcessor implements FuelBaseProcessor<GlobalFuelProcesso
     config: FuelFetchConfig = DEFAULT_FUEL_FETCH_CONFIG
   ) {
     const callHandler = {
+      handlerName: getHandlerName(),
       handler: async (call: Data_FuelCall) => {
         let tx: FuelTransaction
         try {

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>> {
@@ -22,9 +24,15 @@ export class FuelProcessorState extends MapStateStorage<FuelBaseProcessor<any>>
 }
 
 export type CallHandler<T> = {
+  handlerName: string
   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[]
   }

package/src/move/filter.ts

@@ -34,22 +34,26 @@ export interface ArgumentsFilter {
 
 export class EventHandler<T> {
   filters: EventFilter[]
+  handlerName: string
   handler: (event: T) => Promise<ProcessResult>
   fetchConfig: MoveFetchConfig
 }
 
 export class CallHandler<T> {
   filters: FunctionNameAndCallFilter[]
+  handlerName: string
   handler: (call: T) => Promise<ProcessResult>
   fetchConfig: MoveFetchConfig
 }
 
 export class ObjectChangeHandler<T> {
+  handlerName: string
   handler: (call: T) => Promise<ProcessResult>
   type: string
 }
 
 export class ResourceChangeHandler<T> {
+  handlerName: string
   handler: (call: T) => Promise<ProcessResult>
   type: string
 }

package/src/stark/starknet-plugin.ts

@@ -51,7 +51,8 @@ export class StarknetPlugin extends Plugin {
               address: processor.config.address,
               keys: [hash.getSelectorFromName(e)]
             })),
-            handlerId
+            handlerId,
+            handlerName: callHandler.handlerName
           })
         }
       }

package/src/stark/starknet-processor.ts

@@ -6,6 +6,7 @@ import { StarknetEvent } from './event.js'
 import { ListStateStorage, mergeProcessResults } from '@sentio/runtime'
 import { StarknetProcessorConfig } from './types.js'
 import { StarknetContractView } from './contract.js'
+import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
 
 export class StarknetProcessor {
   callHandlers: CallHandler<Data_StarknetEvent>[] = []
@@ -20,7 +21,9 @@ export class StarknetProcessor {
 
   classHash: string
 
-  constructor(readonly config: StarknetProcessorConfig) {}
+  constructor(readonly config: StarknetProcessorConfig) {
+    return proxyProcessor(this)
+  }
 
   async configure() {
     this.provider = new RpcProvider({
@@ -47,6 +50,7 @@ export class StarknetProcessor {
     }
     const abi = this.config.abi
     const callHandler = {
+      handlerName: getHandlerName(),
       handler: async (call: Data_StarknetEvent) => {
         try {
           const eventData = [call.result] as any[]
@@ -98,6 +102,7 @@ export class StarknetProcessor {
 }
 
 export type CallHandler<T> = {
+  handlerName: string
   handler: (call: T) => Promise<ProcessResult>
   eventFilter?: string[]
 }
@@ -123,6 +128,7 @@ export abstract class AbstractStarknetProcessor {
   ) {
     this.processor = new StarknetProcessor(config)
     StarknetProcessorState.INSTANCE.addValue(this.processor)
+    return proxyProcessor(this)
   }
 
   onEvent<T, C>(