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

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,71 @@ 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 logByTypes: 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
+      const typeName = t?.attributes?.outputLabel
+      if (typeName) {
+        if (!logByTypes[typeName]) {
+          logByTypes[typeName] = []
+        }
+        logByTypes[typeName].push(logType.logId)
+      }
+    }
+
     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(logByTypes)
+  .flatMap(([t, ids]) =>
+    ids.map(
+      (id) => `   getLog${id}(): Array<${t}>  {
+      return this.logs?.filter(l => l.logId == ${id})?.map(l => l.decodedLog) as Array<${t}>
+    }`
+    )
+  )
+  .join('\n')}
+  }
+
 ${abi.functions.map(genCallType).join('\n')}
 }
 
@@ -105,25 +153,46 @@ 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')}   
+
+${Object.entries(logByTypes).map(genOnLogFunction).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 +200,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) {
+    return super.onCall('${f.name}', (call, ctx) => handler(new ${contractName}.${name}Call(call), ctx), config)
   }`
 }
 
@@ -147,3 +216,11 @@ function collectImportedTypes(types: any[]): string[] {
 
   return Array.from(ret)
 }
+
+function genOnLogFunction([type, ids]: [string, string[]]) {
+  const name = upperFirst(type.replace('Output', ''))
+  return `
+  onLog${name}(handler: (logs: ${type}[], ctx: FuelContext) => void | Promise<void>, logIdFilter?: number | number[]) {
+    return super.onLog<${type}>(logIdFilter ?? [${ids.join(', ')}], (logs, ctx) => handler(logs, ctx))
+  }`
+}

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,11 @@ 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'
+import { BN } from '@fuel-ts/math'
 
 interface Handlers {
   callHandlers: ((trace: Data_FuelCall) => Promise<ProcessResult>)[]
@@ -36,58 +38,47 @@ 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) {
+          if (callHandler.logConfig?.logIds?.length) {
+            contractConfig.fuelLogConfigs.push({
+              logIds: callHandler.logConfig.logIds.map((logId) => new BN(logId).toString(10)),
+              handlerId
+            })
+          } else {
+            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:

package/src/fuel/fuel-processor.ts

@@ -1,15 +1,19 @@
-import { ListStateStorage } from '@sentio/runtime'
-import { Data_FuelCall, FuelCallFilter, FuelCallHandlerConfig, ProcessResult } from '@sentio/protos'
+import { Data_FuelCall, FuelCallFilter } from '@sentio/protos'
 import { FuelCall, FuelContext } from './context.js'
-import { bn, Contract, Interface, InvocationCallResult, JsonAbi, Provider } from 'fuels'
+import { Provider } from '@fuel-ts/account'
+import { Contract } from '@fuel-ts/program'
+import { Interface, JsonAbi } from '@fuel-ts/abi-coder'
+import { bn } from '@fuel-ts/math'
 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 {
+import {
+  decodeFuelTransactionWithAbi,
+  DEFAULT_FUEL_FETCH_CONFIG,
+  FuelFetchConfig,
+  FuelTransaction
+} from './transaction.js'
+import { CallHandler, FuelBaseProcessor, FuelProcessorState } from './types.js'
+
+export class FuelProcessor implements FuelBaseProcessor<FuelProcessorConfig> {
   callHandlers: CallHandler<Data_FuelCall>[] = []
 
   private provider: Provider
@@ -38,9 +42,14 @@ export class FuelProcessor {
               [this.config.address]: this.config.abi
             }
           : {}
-        const tx = decodeFuelTransaction(call.transaction, abiMap, this.provider)
-
-        const ctx = new FuelContext(tx, this.config.chainId)
+        const tx = decodeFuelTransactionWithAbi(call.transaction, abiMap, this.provider)
+
+        const ctx = new FuelContext(
+          this.config.chainId,
+          this.config.address,
+          this.config.name ?? this.config.address,
+          tx
+        )
         await handler(tx, ctx)
         return ctx.stopAndGetResult()
       },
@@ -84,16 +93,22 @@ export class FuelProcessor {
       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)
+        const tx = decodeFuelTransactionWithAbi(gqlTransaction, { [this.config.address]: abi }, this.provider)
+
+        const ctx = new FuelContext(
+          this.config.chainId,
+          this.config.address,
+          this.config.name ?? this.config.address,
+          tx
+        )
         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)
+              const invocationResult = new FuelCall(scope, tx, false, call.argumentsProvided, tx.logs)
+
               await handler(invocationResult, ctx)
             }
           }
@@ -108,11 +123,36 @@ export class FuelProcessor {
     this.callHandlers.push(callHandler)
     return this
   }
-}
 
-export type CallHandler<T> = {
-  handler: (call: T) => Promise<ProcessResult>
-  fetchConfig: Partial<FuelCallHandlerConfig>
+  public onLog<T>(logIdFilter: number | number[], handler: (logs: T[], ctx: FuelContext) => void | Promise<void>) {
+    const logIds = new Set(Array.isArray(logIdFilter) ? logIdFilter : [logIdFilter])
+
+    const callHandler = {
+      handler: async (call: Data_FuelCall) => {
+        const gqlTransaction = call.transaction
+        const tx = decodeFuelTransactionWithAbi(
+          gqlTransaction,
+          { [this.config.address]: this.config.abi! },
+          this.provider
+        )
+
+        const ctx = new FuelContext(
+          this.config.chainId,
+          this.config.address,
+          this.config.name ?? this.config.address,
+          tx
+        )
+        const logs = (tx.logs || []).filter((log) => logIds.has(log.logId)).map((log) => log.decodedLog as T)
+        await handler(logs, ctx)
+        return ctx.stopAndGetResult()
+      },
+      logConfig: {
+        logIds: Array.from(logIds)
+      }
+    }
+    this.callHandlers.push(callHandler)
+    return this
+  }
 }
 
 export type FuelProcessorConfig = {

package/src/fuel/index.ts

@@ -3,4 +3,6 @@ export * from './context.js'
 export * from './fuel-processor.js'
 export * from './network.js'
 export * from './transaction.js'
-export * from './base-processor.js'
+export * from './base-processor.js'
+export * from './asset-processor.js'
+export * from './types.js'

package/src/fuel/network.ts

@@ -1,5 +1,5 @@
 import { FuelChainId } from '@sentio/chain'
-import { FUEL_BETA_5_NETWORK_URL, FUEL_NETWORK_URL } from 'fuels'
+import { FUEL_BETA_5_NETWORK_URL, FUEL_NETWORK_URL } from '@fuel-ts/account/configs'
 
 export type FuelNetwork = FuelChainId
 export const FuelNetwork = <const>{

package/src/fuel/transaction.ts

@@ -1,13 +1,9 @@
-import {
-  AbiMap,
-  arrayify,
-  assembleTransactionSummary,
-  bn,
-  processGqlReceipt,
-  Provider,
-  TransactionCoder,
-  TransactionSummary
-} from 'fuels'
+import { AbiMap, assembleTransactionSummary, processGqlReceipt, Provider, TransactionSummary } from '@fuel-ts/account'
+import { ReceiptType, TransactionCoder } from '@fuel-ts/transactions'
+import { bn } from '@fuel-ts/math'
+import { arrayify } from '@fuel-ts/utils'
+import { Interface, BigNumberCoder } from '@fuel-ts/abi-coder'
+import { FuelLog } from './types.js'
 
 export type FuelFetchConfig = {
   includeFailed?: boolean
@@ -17,27 +13,81 @@ export const DEFAULT_FUEL_FETCH_CONFIG: FuelFetchConfig = {
   includeFailed: false
 }
 
-export type FuelTransaction = TransactionSummary
+export type FuelTransaction = TransactionSummary & {
+  blockNumber?: string
+  logs?: FuelLog[]
+}
+
+export function decodeFuelTransaction(gqlTransaction: any, provider: Provider): FuelTransaction {
+  const rawPayload = arrayify(gqlTransaction.rawPayload)
+
+  const [decodedTransaction] = new TransactionCoder().decode(rawPayload, 0)
+  const { gasCosts, maxInputs, gasPerByte, gasPriceFactor } = provider.getChain().consensusParameters
+  const blockNumber = gqlTransaction.status?.block?.header?.height
+  const gqlTransactionStatus = {
+    type: gqlTransaction.status?.__typename,
+    ...gqlTransaction.status
+  }
+  return {
+    ...assembleTransactionSummary({
+      id: gqlTransaction.id,
+      receipts: [],
+      transaction: decodedTransaction,
+      transactionBytes: rawPayload,
+      gqlTransactionStatus,
+      gasPerByte: bn(gasPerByte),
+      gasPriceFactor: bn(gasPriceFactor),
+      maxInputs,
+      gasCosts
+    }),
+    blockNumber
+  }
+}
 
-export function decodeFuelTransaction(gqlTransaction: any, abiMap: AbiMap, provider: Provider): FuelTransaction {
+export function decodeFuelTransactionWithAbi(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
-  })
+  const { gasCosts, maxInputs, gasPerByte, gasPriceFactor } = provider.getChain().consensusParameters
+
+  const gqlTransactionStatus = {
+    type: gqlTransaction.status?.__typename,
+    ...gqlTransaction.status
+  }
+  const blockNumber = gqlTransactionStatus?.block?.header?.height
+
+  const abi = Object.values(abiMap)[0]
+
+  const logs: FuelLog[] = []
+  for (const receipt of receipts) {
+    if (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 = receipt.val1.toNumber()
+      const [decodedLog] = interfaceToUse.decodeLog(data, logId)
+      logs.push({ logId, decodedLog })
+    }
+  }
+
+  return {
+    ...assembleTransactionSummary({
+      id: gqlTransaction.id,
+      receipts,
+      transaction: decodedTransaction,
+      transactionBytes: rawPayload,
+      gqlTransactionStatus,
+      gasPerByte: bn(gasPerByte),
+      gasPriceFactor: bn(gasPriceFactor),
+      abiMap,
+      maxInputs,
+      gasCosts
+    }),
+    blockNumber,
+    logs
+  }
 }

package/src/fuel/types.ts

@@ -0,0 +1,26 @@
+import { ListStateStorage } from '@sentio/runtime'
+import { Data_FuelCall, FuelAssetHandlerConfig, FuelCallHandlerConfig, ProcessResult } from '@sentio/protos'
+
+export interface FuelBaseProcessor<T> {
+  configure(): Promise<void>
+  config: T
+  callHandlers: CallHandler<Data_FuelCall>[]
+}
+
+export class FuelProcessorState extends ListStateStorage<FuelBaseProcessor<any>> {
+  static INSTANCE = new FuelProcessorState()
+}
+
+export type CallHandler<T> = {
+  handler: (call: T) => Promise<ProcessResult>
+  fetchConfig?: Partial<FuelCallHandlerConfig>
+  assetConfig?: Partial<FuelAssetHandlerConfig>
+  logConfig?: {
+    logIds: number[]
+  }
+}
+
+export interface FuelLog {
+  logId: number
+  decodedLog: any
+}

package/src/testing/fuel-facet.ts

@@ -51,6 +51,41 @@ export class FuelFacet {
           res.push(binding)
         }
       }
+
+      for (const logConfig of config.fuelLogConfigs) {
+        const binding = {
+          data: {
+            fuelCall: {
+              transaction,
+              timestamp: new Date()
+            }
+          },
+          handlerIds: [logConfig.handlerId],
+          handlerType: HandlerType.FUEL_CALL
+        }
+
+        const logIds = logConfig.logIds
+        for (const receipt of transaction.receipts || []) {
+          if ((receipt.receiptType == 'LOG' || receipt.receiptType == 'LOG_DATA') && logIds.includes(receipt.rb)) {
+            res.push(binding)
+          }
+        }
+      }
+
+      for (const assetConfig of config.assetConfigs) {
+        const binding = {
+          data: {
+            fuelCall: {
+              transaction,
+              timestamp: new Date()
+            }
+          },
+          handlerIds: [assetConfig.handlerId],
+          handlerType: HandlerType.FUEL_CALL
+        }
+
+        res.push(binding)
+      }
     }
 
     return res