@sentio/sdk 2.35.1-rc.1 → 2.36.0-rc.10

package/src/aptos/aptos-plugin.ts

@@ -1,4 +1,4 @@
-import { errorString, mergeProcessResults, Plugin, PluginManager, USER_PROCESSOR } from '@sentio/runtime'
+import { errorString, GLOBAL_CONFIG, mergeProcessResults, Plugin, PluginManager, USER_PROCESSOR } from '@sentio/runtime'
 import {
   AccountConfig,
   ContractConfig,
@@ -12,7 +12,7 @@ import {
   MoveOwnerType,
   ProcessConfigResponse,
   ProcessResult,
-  StartRequest,
+  StartRequest
 } from '@sentio/protos'
 
 import { ServerError, Status } from 'nice-grpc'
@@ -24,7 +24,7 @@ import { AptosChainId } from '@sentio/chain'
 import { AptosResourcesContext } from './context.js'
 import {
   AptosResourceProcessorTemplate,
-  AptosResourceProcessorTemplateState,
+  AptosResourceProcessorTemplateState
 } from './aptos-resource-processor-template.js'
 import { AptosNetwork } from './network.js'
 
@@ -38,7 +38,7 @@ export class AptosPlugin extends Plugin {
   handlers: Handlers = {
     aptosEventHandlers: [],
     aptosCallHandlers: [],
-    aptosResourceHandlers: [],
+    aptosResourceHandlers: []
   }
 
   async start(request: StartRequest) {
@@ -57,7 +57,7 @@ export class AptosPlugin extends Plugin {
         {
           address: instance.contract?.address || '',
           network: <AptosNetwork>instance.contract?.chainId || AptosNetwork.MAIN_NET,
-          startVersion: instance.startBlock || 0n,
+          startVersion: instance.startBlock || 0n
         },
         NoopContext
       )
@@ -68,7 +68,7 @@ export class AptosPlugin extends Plugin {
     const handlers: Handlers = {
       aptosEventHandlers: [],
       aptosCallHandlers: [],
-      aptosResourceHandlers: [],
+      aptosResourceHandlers: []
     }
     for (const aptosProcessor of AptosProcessorState.INSTANCE.getValues()) {
       const contractConfig = ContractConfig.fromPartial({
@@ -77,9 +77,9 @@ export class AptosPlugin extends Plugin {
           name: aptosProcessor.moduleName,
           chainId: aptosProcessor.getChainId(),
           address: aptosProcessor.config.address,
-          abi: '',
+          abi: ''
         },
-        startBlock: aptosProcessor.config.startVersion,
+        startBlock: aptosProcessor.config.startVersion
       })
       // 1. Prepare event handlers
       for (const handler of aptosProcessor.eventHandlers) {
@@ -88,11 +88,11 @@ export class AptosPlugin extends Plugin {
           filters: handler.filters.map((f) => {
             return {
               type: f.type,
-              account: f.account || '',
+              account: f.account || ''
             }
           }),
           fetchConfig: handler.fetchConfig,
-          handlerId,
+          handlerId
         }
         contractConfig.moveEventConfigs.push(eventHandlerConfig)
       }
@@ -107,11 +107,11 @@ export class AptosPlugin extends Plugin {
               typeArguments: filter.typeArguments || [],
               withTypeArguments: !!filter.typeArguments,
               includeFailed: filter.includeFailed || false,
-              publicKeyPrefix: filter.publicKeyPrefix || '',
+              publicKeyPrefix: filter.publicKeyPrefix || ''
             }
           }),
           fetchConfig: handler.fetchConfig,
-          handlerId,
+          handlerId
         }
         contractConfig.moveCallConfigs.push(functionHandlerConfig)
       }
@@ -122,7 +122,7 @@ export class AptosPlugin extends Plugin {
       const accountConfig = AccountConfig.fromPartial({
         address: aptosProcessor.config.address,
         chainId: aptosProcessor.getChainId(),
-        startBlock: aptosProcessor.config.startVersion,
+        startBlock: aptosProcessor.config.startVersion
       })
       for (const handler of aptosProcessor.resourcesHandlers) {
         const handlerId = handlers.aptosResourceHandlers.push(handler.handler) - 1
@@ -133,11 +133,11 @@ export class AptosPlugin extends Plugin {
             minutesInterval: handler.timeIntervalInMinutes,
             slot: 0,
             slotInterval: handler.versionInterval,
-            fetchConfig: undefined,
+            fetchConfig: undefined
           },
           type: handler.type || '',
           ownerType: MoveOwnerType.ADDRESS,
-          fetchConfig: undefined,
+          fetchConfig: undefined
         })
       }
       config.accountConfigs.push(accountConfig)
@@ -168,15 +168,16 @@ export class AptosPlugin extends Plugin {
     const event = binding.data.aptEvent
 
     for (const handlerId of binding.handlerIds) {
-      // only support aptos event for now
-      promises.push(
-        this.handlers.aptosEventHandlers[handlerId](event).catch((e) => {
-          throw new ServerError(
-            Status.INTERNAL,
-            'error processing event: ' + JSON.stringify(event) + '\n' + errorString(e)
-          )
-        })
-      )
+      const promise = this.handlers.aptosEventHandlers[handlerId](event).catch((e) => {
+        throw new ServerError(
+          Status.INTERNAL,
+          'error processing event: ' + JSON.stringify(event) + '\n' + errorString(e)
+        )
+      })
+      if (GLOBAL_CONFIG.execution.sequential) {
+        await promise
+      }
+      promises.push(promise)
     }
     return mergeProcessResults(await Promise.all(promises))
   }
@@ -189,14 +190,16 @@ export class AptosPlugin extends Plugin {
 
     const promises: Promise<ProcessResult>[] = []
     for (const handlerId of binding.handlerIds) {
-      promises.push(
-        this.handlers.aptosResourceHandlers[handlerId](resource).catch((e) => {
-          throw new ServerError(
-            Status.INTERNAL,
-            'error processing resource: ' + JSON.stringify(resource) + '\n' + errorString(e)
-          )
-        })
-      )
+      const promise = this.handlers.aptosResourceHandlers[handlerId](resource).catch((e) => {
+        throw new ServerError(
+          Status.INTERNAL,
+          'error processing resource: ' + JSON.stringify(resource) + '\n' + errorString(e)
+        )
+      })
+      if (GLOBAL_CONFIG.execution.sequential) {
+        await promise
+      }
+      promises.push(promise)
     }
     return mergeProcessResults(await Promise.all(promises))
   }
@@ -213,6 +216,9 @@ export class AptosPlugin extends Plugin {
       const promise = this.handlers.aptosCallHandlers[handlerId](call).catch((e) => {
         throw new ServerError(Status.INTERNAL, 'error processing call: ' + JSON.stringify(call) + '\n' + errorString(e))
       })
+      if (GLOBAL_CONFIG.execution.sequential) {
+        await promise
+      }
       promises.push(promise)
     }
     return mergeProcessResults(await Promise.all(promises))

package/src/fuel/asset-processor.ts

@@ -0,0 +1,122 @@
+import { CallHandler, FuelBaseProcessor, FuelProcessorState } from './types.js'
+import { Data_FuelCall, FuelAssetHandlerConfig_AssetFilter } from '@sentio/protos'
+import { FuelNetwork, getRpcEndpoint } from './network.js'
+import { FuelContext } from './context.js'
+import { decodeFuelTransaction } from './transaction.js'
+import { Provider } from '@fuel-ts/account'
+import { InputType, OutputType } from '@fuel-ts/transactions'
+
+export class FuelAssetProcessor implements FuelBaseProcessor<FuelAssetProcessorConfig> {
+  callHandlers: CallHandler<Data_FuelCall>[] = []
+  private provider: Provider
+
+  static bind(config: FuelAssetProcessorConfig): FuelAssetProcessor {
+    const processor = new FuelAssetProcessor(config)
+    FuelProcessorState.INSTANCE.addValue(processor)
+    return processor
+  }
+
+  constructor(readonly config: FuelAssetProcessorConfig) {}
+
+  async configure(): Promise<void> {
+    const url = getRpcEndpoint(this.config.chainId)
+    this.provider = await Provider.create(url)
+  }
+
+  onTransfer(filter: TransferFilter, handler: (transfers: FuelTransfer, ctx: FuelContext) => void | Promise<void>) {
+    const filters: FuelAssetHandlerConfig_AssetFilter[] = []
+
+    const assetIds = arrayify(filter.assetId)
+    const froms = arrayify(filter.from)
+    const tos = arrayify(filter.to)
+
+    for (const assetId of assetIds) {
+      for (const from of froms) {
+        for (const to of tos) {
+          filters.push({
+            assetId: assetId,
+            fromAddress: from,
+            toAddress: to
+          })
+        }
+      }
+    }
+
+    const callHandler = {
+      handler: async (call: Data_FuelCall) => {
+        const gqlTransaction = call.transaction
+        const tx = decodeFuelTransaction(gqlTransaction, this.provider)
+
+        const transfer: FuelTransfer = {
+          from: [],
+          to: []
+        }
+        for (const input of tx.transaction.inputs || []) {
+          if (input.type == InputType.Coin) {
+            transfer.from.push({
+              address: input.owner,
+              assetId: input.assetId
+            })
+          }
+        }
+
+        for (const output of tx.transaction.outputs || []) {
+          if (output.type == OutputType.Coin) {
+            const value = output.amount.toString(10)
+            transfer.to.push({
+              address: output.to,
+              amount: BigInt(value),
+              assetId: output.assetId
+            })
+          }
+        }
+
+        const assetId = transfer.from[0].assetId || ''
+
+        const ctx = new FuelContext(this.config.chainId, assetId, this.config.name ?? '', tx)
+        await handler(transfer, ctx)
+        return ctx.stopAndGetResult()
+      },
+      assetConfig: {
+        filters
+      }
+    }
+    this.callHandlers.push(callHandler)
+    return this
+  }
+}
+
+export type FuelAssetProcessorConfig = {
+  name?: string
+  chainId: FuelNetwork
+  startBlock?: bigint
+  endBlock?: bigint
+}
+
+export type TransferFilter = {
+  from?: string | string[]
+  to?: string | string[]
+  assetId?: string | string[]
+}
+
+export type FuelTransfer = {
+  from: {
+    assetId: string
+    address: string
+  }[]
+  to: {
+    address: string
+    amount: bigint
+    assetId: string
+  }[]
+}
+
+function arrayify(value?: string | string[]): Array<string | undefined> {
+  if (value) {
+    if (Array.isArray(value)) {
+      return value.length > 0 ? value : [undefined]
+    }
+    return [value]
+  }
+  return [undefined]
+}

package/src/fuel/base-processor.ts

@@ -1,38 +1,33 @@
-import { FuelProcessor, FuelProcessorConfig, FuelProcessorState } from './fuel-processor.js'
-import { JsonAbi } from 'fuels'
-import { FuelCall, FuelContext } from './context.js'
-import { FuelFetchConfig } from './transaction.js'
+import { FuelProcessor, FuelProcessorConfig } from './fuel-processor.js'
+import { JsonAbi } from '@fuel-ts/abi-coder'
+import { FuelCall } from './context.js'
 import { FuelChainId } from '@sentio/chain'
-
+import { FuelLog, FuelProcessorState } from './types.js'
 
 export abstract class FuelAbstractProcessor extends FuelProcessor {
-
   protected constructor(abi: JsonAbi, config?: FuelProcessorConfig) {
     if (!config) {
       config = {
         chainId: FuelChainId.FUEL_MAINNET,
-        address: ''
+        address: '*'
       }
     }
     config.abi = abi
     super(config)
     FuelProcessorState.INSTANCE.addValue(this)
   }
-
-  protected onCallMethod<T extends Array<any>, R>(method: string, fn: (call: TypedCall<T, R>, ctx: FuelContext) => (void | Promise<void>), config: FuelFetchConfig): this {
-    const nameFilter = method
-    const handler =async (call: FuelCall, ctx: FuelContext) => {
-      await fn({
-        args: call.functionScopes[0].getCallConfig().args as T,
-        returnValue: call.value as R
-      }, ctx)
-    }
-    return super.onCall(nameFilter, handler, config)
-  }
-
 }
 
-export type TypedCall<T extends Array<any>, R> = {
+export class TypedCall<T extends Array<any>, R> {
   args: T
   returnValue: R
-}
+  argsObject?: Record<string, any>
+  logs?: FuelLog[]
+
+  constructor(call: FuelCall) {
+    this.args = call.functionScopes[0].getCallConfig().args as T
+    this.returnValue = call.value as R
+    this.argsObject = call.args
+    this.logs = call.logs
+  }
+}

package/src/fuel/codegen/codegen.ts

@@ -15,7 +15,22 @@ export async function codegen(abisDir: string, outDir: string) {
 }
 
 function patchImport(contents: string) {
-  return contents.replace(/from\s+['"](\..+)['"]/g, `from '\$1.js'`)
+  return contents
+    .replace(
+      `import { Interface, Contract, ContractFactory } from "fuels";`,
+      `import { Contract, } from "@fuel-ts/program";
+import { ContractFactory } from "@fuel-ts/contract";
+import { Interface } from "@fuel-ts/abi-coder";`
+    )
+    .replace(
+      `import type { Provider, Account, AbstractAddress, BytesLike, DeployContractOptions, StorageSlot } from "fuels";
+`,
+      `import type { Provider, Account } from "@fuel-ts/account";
+import type { AbstractAddress, BytesLike } from "@fuel-ts/interfaces";
+import type { DeployContractOptions } from "@fuel-ts/contract";
+import type { StorageSlot } from "@fuel-ts/transactions";`
+    )
+    .replace(/from\s+['"](\..+)['"]/g, `from '\$1.js'`)
 }
 
 function patchEnumType(contents: string) {
@@ -65,38 +80,63 @@ async function codegenInternal(abisDir: string, outDir: string): Promise<number>
 
   mkdirp.sync(outDir)
   mkdirp.sync(path.join(outDir, 'factories'))
-
+  let count = 0
   abiTypeGen.files.forEach((file) => {
     if (!file.path.endsWith('.hex.ts')) {
       let content = patchImport(file.contents)
       content = patchEnumType(content)
       writeFileSync(file.path, content)
+      count++
     }
   })
 
+  // for (const file of abiTypeGen.files) {
+  //   const jsonAbi: JsonAbi = JSON.parse(file.contents)
+  //   for (const logType of jsonAbi.loggedTypes) {
+  //     logType.loggedType.name
+  //
+  //   }
+  // }
+
   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 logTypes: Record<string, string> = {}
+    for (const logType of abi.rawContents.loggedTypes) {
+      // @ts-ignore - we know that the type is in the abi
+      const t = abi.types.find((t) => t.rawAbiType.typeId == logType.loggedType?.type)
+      // @ts-ignore - we know that the type is in the abi
+      logTypes[logType.logId] = t?.attributes?.outputLabel
+    }
+
     const content = `/* Autogenerated file. Do not edit manually. */
 
 /* tslint:disable */
 /* eslint-disable */
     
-import { FuelAbstractProcessor, FuelContext, FuelProcessorConfig, TypedCall, FuelFetchConfig} from '@sentio/sdk/fuel'
+import { FuelAbstractProcessor, FuelContext, FuelProcessorConfig, TypedCall, FuelFetchConfig, FuelCall} 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';
+import type { BigNumberish, BN } from '@fuel-ts/math';
+import type { BytesLike } from '@fuel-ts/interfaces';
 
 
 namespace ${name} {
+  export abstract class CallWithLogs<T extends Array<any>, R> extends TypedCall<T, R> {
+${Object.entries(logTypes)
+  .map(
+    ([k, v]) =>
+      `   getLog${k}(): Array<${v}>  {
+      return this.logs?.filter(l => l.logId == ${k})?.map(l => l.decodedLog) as Array<${v}>
+    }`
+  )
+  .join('\n')}
+  }
+
 ${abi.functions.map(genCallType).join('\n')}
 }
 
@@ -105,25 +145,43 @@ export class ${name}Processor extends FuelAbstractProcessor {
     super(${abi.name}__factory.abi, config)
   }
   
-  static bind(config?: FuelProcessorConfig) {
-    return new ${name}Processor(config)
+  static bind(config: FuelProcessorConfig) {
+    return new ${name}Processor({
+      name: '${name}',
+      ...config,
+    })
   }
 
 ${abi.functions.map((f) => genOnCallFunction(name, f)).join('\n')}   
 }
 `
     writeFileSync(filePath, content)
+    count++
   }
 
-  return allABIFiles.length
+  return count
 }
 
 function genCallType(f: IFunction) {
   const name = upperFirst(f.name)
+  const argMap: Record<string, string> = {}
+  const argTypes = f.attributes.inputs.split(',').map((t) => t.trim())
+  f.rawAbiFunction.inputs.forEach((input, idx) => {
+    argMap[input.name] = argTypes[idx]
+  })
+
   return `
-  export interface ${name}Call extends TypedCall<[${f.attributes.inputs}], ${f.attributes.output}> {
-      args: [${f.attributes.inputs}]
-      returnValue: ${f.attributes.output}
+  export class ${name}Call extends CallWithLogs<[${argTypes.join(', ')}], ${f.attributes.output}> {
+      declare args: [${argTypes.join(', ')}]
+      declare returnValue: ${f.attributes.output}
+      declare argsObject: {
+          ${Object.entries(argMap)
+            .map(([k, v]) => `${k}: ${v}`)
+            .join(', ')}
+      } 
+      constructor(call: FuelCall) {
+        super(call)
+      }
   }
 `
 }
@@ -131,8 +189,8 @@ function genCallType(f: IFunction) {
 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)
+  onCall${name}(handler: (call: ${contractName}.${name}Call, ctx: FuelContext) => void | Promise<void>, config?: FuelFetchConfig) {
+      super.onCall('${f.name}', (call, ctx) => handler(new ${contractName}.${name}Call(call), ctx), config)
   }`
 }
 

package/src/fuel/context.ts

@@ -1,15 +1,29 @@
 import { BaseContext, Labels, normalizeLabels } from '../core/index.js'
 import { ChainId } from '@sentio/chain'
 import { RecordMetaData } from '@sentio/protos'
-import { InvocationCallResult } from 'fuels'
+import { InvocationCallResult, InvocationScopeLike } from '@fuel-ts/program'
 import { FuelTransaction } from './transaction.js'
+import type { CallResult } from '@fuel-ts/account'
+import { FuelLog } from './types.js'
 
-export type FuelCall = InvocationCallResult
+export class FuelCall extends InvocationCallResult {
+  constructor(
+    funcScopes: InvocationScopeLike | Array<InvocationScopeLike>,
+    callResult: CallResult,
+    isMultiCall: boolean,
+    readonly args?: Record<string, any>,
+    readonly logs?: FuelLog[]
+  ) {
+    super(funcScopes, callResult, isMultiCall)
+  }
+}
 
 export class FuelContext extends BaseContext {
   constructor(
-    readonly transaction: FuelTransaction | null,
-    readonly chainId: ChainId
+    readonly chainId: ChainId,
+    readonly contractAddress: string,
+    readonly contractName: string,
+    readonly transaction: FuelTransaction | null
   ) {
     super({})
   }
@@ -20,14 +34,14 @@ export class FuelContext extends BaseContext {
 
   protected getMetaDataInternal(name: string, labels: Labels): RecordMetaData {
     return {
-      address: this.transaction?.id || '',
-      contractName: this.transaction?.id || '', // TODO
-      blockNumber: 0n,
+      address: this.contractAddress,
+      contractName: this.contractName,
+      blockNumber: BigInt(this.transaction?.blockNumber || 0),
       transactionIndex: 0,
       transactionHash: this.transaction?.id || '', // TODO
       chainId: this.getChainId(),
       name: name,
-      logIndex: 0,
+      logIndex: -1,
       labels: normalizeLabels(labels)
     }
   }

package/src/fuel/fuel-plugin.ts

@@ -10,9 +10,10 @@ import {
 } 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'
+import { FuelAssetProcessor } from './asset-processor.js'
+import { FuelProcessorState } from './types.js'
+import { FuelProcessor } from './fuel-processor.js'
 
 interface Handlers {
   callHandlers: ((trace: Data_FuelCall) => Promise<ProcessResult>)[]
@@ -36,58 +37,40 @@ export class FuelPlugin extends Plugin {
         contract: {
           name: processor.config.name,
           chainId: processor.config.chainId.toString(),
-          address: processor.config.address,
+          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 || []
+        if (processor instanceof FuelProcessor) {
+          const fetchConfig = {
+            handlerId,
+            filters: callHandler.fetchConfig?.filters || []
+          }
+          contractConfig.fuelCallConfigs.push(fetchConfig)
+        } else if (processor instanceof FuelAssetProcessor) {
+          const assetConfig = callHandler.assetConfig
+          contractConfig.assetConfigs.push({
+            filters: assetConfig?.filters || [],
+            handlerId
+          })
         }
-        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: