eco-solver 0.0.1-security → 1.5.1

package/src/health/indicators/git-commit.indicator.ts

@@ -0,0 +1,67 @@
+import { Injectable, Logger } from '@nestjs/common'
+import { HealthIndicator, HealthIndicatorResult } from '@nestjs/terminus'
+import { exec } from 'child_process'
+import { readFileSync } from 'fs'
+import { join } from 'path'
+import { EcoLogMessage } from '../../common/logging/eco-log-message'
+
+const ECO_ROUTES_PACKAGE_NAME = '@eco-foundation/routes-ts'
+@Injectable()
+export class GitCommitHealthIndicator extends HealthIndicator {
+  private logger = new Logger(GitCommitHealthIndicator.name)
+  constructor() {
+    super()
+  }
+
+  async gitCommit(): Promise<HealthIndicatorResult> {
+    const npmLib = this.getDependencyVersion(ECO_ROUTES_PACKAGE_NAME)
+    return this.getStatus('git-commit', !!npmLib, {
+      commitHash: await this.getCommitHash(),
+      ecoRoutesVersion: npmLib,
+    })
+  }
+
+  private async getCommitHash(): Promise<string> {
+    return new Promise((resolve, reject) => {
+      exec('git rev-parse HEAD', (error, stdout) => {
+        if (error) {
+          reject(error)
+        } else {
+          resolve(stdout.trim())
+        }
+      })
+    })
+  }
+
+  private getDependencyVersion(
+    dependencyName: string,
+  ): { version: string; npm: string } | undefined {
+    try {
+      // Path to the project's package.json file
+      const packageJsonPath = join(process.cwd(), 'package.json')
+
+      // Read and parse the package.json file
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'))
+
+      // Check dependencies and devDependencies for the specified dependency
+      const version =
+        packageJson.dependencies?.[dependencyName] ||
+        packageJson.devDependencies?.[dependencyName] ||
+        'undefined'
+      return {
+        version,
+        npm: `https://www.npmjs.com/package/${dependencyName}/v/${version.replace('^', '')}?activeTab=code`,
+      }
+    } catch (error) {
+      this.logger.error(
+        EcoLogMessage.fromDefault({
+          message: 'Error reading package.json:',
+          properties: {
+            error,
+          },
+        }),
+      )
+      return undefined // Return undefined if there is an error
+    }
+  }
+}

package/src/health/indicators/mongodb.indicator.ts

@@ -0,0 +1,11 @@
+import { Injectable, Logger } from '@nestjs/common'
+import { HealthIndicatorResult, MongooseHealthIndicator } from '@nestjs/terminus'
+
+@Injectable()
+export class MongoDBHealthIndicator extends MongooseHealthIndicator {
+  private logger = new Logger(MongoDBHealthIndicator.name)
+
+  async checkMongoDB(): Promise<HealthIndicatorResult> {
+    return this.pingCheck('mongoDB')
+  }
+}

package/src/health/indicators/permission.indicator.ts

@@ -0,0 +1,64 @@
+import { Injectable, Logger } from '@nestjs/common'
+import { HealthCheckError, HealthIndicator, HealthIndicatorResult } from '@nestjs/terminus'
+import { EcoConfigService } from '../../eco-configs/eco-config.service'
+import { Solver } from '../../eco-configs/eco-config.types'
+import { Hex } from 'viem'
+import { KernelAccountClientService } from '../../transaction/smart-wallets/kernel/kernel-account-client.service'
+import { InboxAbi } from '@eco-foundation/routes-ts'
+
+@Injectable()
+export class PermissionHealthIndicator extends HealthIndicator {
+  private logger = new Logger(PermissionHealthIndicator.name)
+  private readonly solverPermissions: Map<string, { account: Hex; whitelisted: boolean }> =
+    new Map()
+
+  constructor(
+    private readonly kernelAccountClientService: KernelAccountClientService,
+    private readonly configService: EcoConfigService,
+  ) {
+    super()
+  }
+
+  async checkPermissions(): Promise<HealthIndicatorResult> {
+    //iterate over all solvers
+    await Promise.all(
+      Object.entries(this.configService.getSolvers()).map(async (entry) => {
+        const [, solver] = entry
+        await this.loadPermissions(solver)
+      }),
+    )
+    const isHealthy = Array.from(this.solverPermissions.values()).every(
+      (value) => value.whitelisted,
+    )
+    const permissionsString = {}
+    this.solverPermissions.forEach((value, key) => {
+      permissionsString[key] = value
+    })
+
+    const results = this.getStatus('permissions', isHealthy, { permissions: permissionsString })
+    if (isHealthy) {
+      return results
+    }
+    throw new HealthCheckError('Permissions failed', results)
+  }
+
+  private async loadPermissions(solver: Solver) {
+    const key = this.getSolverKey(solver.network, solver.chainID, solver.inboxAddress)
+    const client = await this.kernelAccountClientService.getClient(solver.chainID)
+    const address = client.kernelAccount.address
+    const whitelisted = await client.readContract({
+      address: solver.inboxAddress,
+      abi: InboxAbi,
+      functionName: 'solverWhitelist',
+      args: [address],
+    })
+    this.solverPermissions.set(key, {
+      account: address,
+      whitelisted,
+    })
+  }
+
+  private getSolverKey(network: string, chainID: number, address: Hex): string {
+    return `${network}-${chainID}-${address}`
+  }
+}

package/src/intent/create-intent.service.ts

@@ -0,0 +1,129 @@
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common'
+import { EcoConfigService } from '../eco-configs/eco-config.service'
+import { EcoLogMessage } from '../common/logging/eco-log-message'
+import { QUEUES } from '../common/redis/constants'
+import { JobsOptions, Queue } from 'bullmq'
+import { InjectQueue } from '@nestjs/bullmq'
+import { IntentSourceModel } from './schemas/intent-source.schema'
+import { InjectModel } from '@nestjs/mongoose'
+import { Model } from 'mongoose'
+import { getIntentJobId } from '../common/utils/strings'
+import { Hex } from 'viem'
+import { ValidSmartWalletService } from '../solver/filters/valid-smart-wallet.service'
+import { decodeCreateIntentLog, IntentCreatedLog } from '../contracts'
+import { IntentDataModel } from './schemas/intent-data.schema'
+import { FlagService } from '../flags/flags.service'
+import { deserialize, Serialize } from '@/liquidity-manager/utils/serialize'
+
+/**
+ * This service is responsible for creating a new intent record in the database. It is
+ * triggered when a new intent is created recieved in {@link WatchIntentService}.
+ * It validates that the record doesn't exist yet, and that its creator is a valid BEND wallet
+ */
+@Injectable()
+export class CreateIntentService implements OnModuleInit {
+  private logger = new Logger(CreateIntentService.name)
+  private intentJobConfig: JobsOptions
+
+  constructor(
+    @InjectQueue(QUEUES.SOURCE_INTENT.queue) private readonly intentQueue: Queue,
+    @InjectModel(IntentSourceModel.name) private intentModel: Model<IntentSourceModel>,
+    private readonly validSmartWalletService: ValidSmartWalletService,
+    private readonly flagService: FlagService,
+    private readonly ecoConfigService: EcoConfigService,
+  ) {}
+
+  onModuleInit() {
+    this.intentJobConfig = this.ecoConfigService.getRedis().jobs.intentJobConfig
+  }
+
+  /**
+   * Decodes the intent log, validates the creator is a valid BEND wallet, and creates a new record in the database
+   * if one doesn't yet exist. Finally it enqueue the intent for validation
+   *
+   * @param serializedIntentWs the serialized intent created log
+   * @returns
+   */
+  async createIntent(serializedIntentWs: Serialize<IntentCreatedLog>) {
+    const intentWs = deserialize(serializedIntentWs)
+
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `createIntent ${intentWs.transactionHash}`,
+        properties: {
+          intentHash: intentWs.transactionHash,
+        },
+      }),
+    )
+
+    const ei = decodeCreateIntentLog(intentWs.data, intentWs.topics)
+    const intent = IntentDataModel.fromEvent(ei, intentWs.logIndex || 0)
+
+    try {
+      //check db if the intent is already filled
+      const model = await this.intentModel.findOne({
+        'intent.hash': intent.hash,
+      })
+
+      if (model) {
+        // Record already exists, do nothing and return
+        this.logger.debug(
+          EcoLogMessage.fromDefault({
+            message: `Record for intent already exists ${intent.hash}`,
+            properties: {
+              intentHash: intent.hash,
+              intent: intent,
+            },
+          }),
+        )
+        return
+      }
+
+      const validWallet = this.flagService.getFlagValue('bendWalletOnly')
+        ? await this.validSmartWalletService.validateSmartWallet(
+            intent.reward.creator as Hex,
+            intentWs.sourceChainID,
+          )
+        : true
+
+      //create db record
+      const record = await this.intentModel.create({
+        event: intentWs,
+        intent: intent,
+        receipt: null,
+        status: validWallet ? 'PENDING' : 'NON-BEND-WALLET',
+      })
+
+      const jobId = getIntentJobId('create', intent.hash as Hex, intent.logIndex)
+      if (validWallet) {
+        //add to processing queue
+        await this.intentQueue.add(QUEUES.SOURCE_INTENT.jobs.validate_intent, intent.hash, {
+          jobId,
+          ...this.intentJobConfig,
+        })
+      }
+
+      this.logger.log(
+        EcoLogMessage.fromDefault({
+          message: `Recorded intent ${record.intent.hash}`,
+          properties: {
+            intentHash: intent.hash,
+            intent: record.intent,
+            validWallet,
+            ...(validWallet ? { jobId } : {}),
+          },
+        }),
+      )
+    } catch (e) {
+      this.logger.error(
+        EcoLogMessage.fromDefault({
+          message: `Error in createIntent ${intentWs.transactionHash}`,
+          properties: {
+            intentHash: intentWs.transactionHash,
+            error: e,
+          },
+        }),
+      )
+    }
+  }
+}

package/src/intent/feasable-intent.service.ts

@@ -0,0 +1,80 @@
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common'
+import { EcoConfigService } from '../eco-configs/eco-config.service'
+import { JobsOptions, Queue } from 'bullmq'
+import { InjectQueue } from '@nestjs/bullmq'
+import { QUEUES } from '../common/redis/constants'
+import { UtilsIntentService } from './utils-intent.service'
+import { EcoLogMessage } from '../common/logging/eco-log-message'
+import { getIntentJobId } from '../common/utils/strings'
+import { Hex } from 'viem'
+import { QuoteIntentModel } from '@/quote/schemas/quote-intent.schema'
+import { FeeService } from '@/fee/fee.service'
+
+/**
+ * Service class for getting configs for the app
+ */
+@Injectable()
+export class FeasableIntentService implements OnModuleInit {
+  private logger = new Logger(FeasableIntentService.name)
+  private intentJobConfig: JobsOptions
+  constructor(
+    @InjectQueue(QUEUES.SOURCE_INTENT.queue) private readonly intentQueue: Queue,
+    private readonly feeService: FeeService,
+    private readonly utilsIntentService: UtilsIntentService,
+    private readonly ecoConfigService: EcoConfigService,
+  ) {}
+
+  async onModuleInit() {
+    this.intentJobConfig = this.ecoConfigService.getRedis().jobs.intentJobConfig
+  }
+  async feasableQuote(quoteIntent: QuoteIntentModel) {
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `feasableQuote intent ${quoteIntent._id}`,
+      }),
+    )
+  }
+  /**
+   * Validates that the execution of the intent is feasible. This means that the solver can execute
+   * the transaction and that transaction cost is profitable to the solver.
+   * @param intentHash the intent hash to fetch the intent data from the db with
+   * @returns
+   */
+  async feasableIntent(intentHash: Hex) {
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `FeasableIntent intent ${intentHash}`,
+      }),
+    )
+    const data = await this.utilsIntentService.getIntentProcessData(intentHash)
+    const { model, solver, err } = data ?? {}
+    if (!model || !solver) {
+      if (err) {
+        throw err
+      }
+      return
+    }
+
+    const { error } = await this.feeService.isRouteFeasible(model.intent)
+
+    const jobId = getIntentJobId('feasable', intentHash, model!.intent.logIndex)
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `FeasableIntent intent ${intentHash}`,
+        properties: {
+          feasable: !error,
+          ...(!error ? { jobId } : {}),
+        },
+      }),
+    )
+    if (!error) {
+      //add to processing queue
+      await this.intentQueue.add(QUEUES.SOURCE_INTENT.jobs.fulfill_intent, intentHash, {
+        jobId,
+        ...this.intentJobConfig,
+      })
+    } else {
+      await this.utilsIntentService.updateInfeasableIntentModel(model, error)
+    }
+  }
+}

package/src/intent/fulfill-intent.service.ts

@@ -0,0 +1,318 @@
+import { Injectable, Logger } from '@nestjs/common'
+import {
+  ContractFunctionArgs,
+  ContractFunctionName,
+  encodeAbiParameters,
+  encodeFunctionData,
+  erc20Abi,
+  Hex,
+  pad,
+  zeroAddress,
+} from 'viem'
+import {
+  IntentProcessData,
+  TransactionTargetData,
+  UtilsIntentService,
+} from './utils-intent.service'
+import { getERC20Selector } from '../contracts'
+import { EcoError } from '../common/errors/eco-error'
+import { EcoLogMessage } from '../common/logging/eco-log-message'
+import { Solver } from '../eco-configs/eco-config.types'
+import { IntentSourceModel } from './schemas/intent-source.schema'
+import { EcoConfigService } from '../eco-configs/eco-config.service'
+import { ProofService } from '../prover/proof.service'
+import { ExecuteSmartWalletArg } from '../transaction/smart-wallets/smart-wallet.types'
+import { KernelAccountClientService } from '../transaction/smart-wallets/kernel/kernel-account-client.service'
+import { InboxAbi } from '@eco-foundation/routes-ts'
+import { getTransactionTargetData } from '@/intent/utils'
+import { FeeService } from '@/fee/fee.service'
+import { IntentDataModel } from '@/intent/schemas/intent-data.schema'
+
+type FulfillmentMethod = ContractFunctionName<typeof InboxAbi>
+
+/**
+ * This class fulfills an intent by creating the transactions for the intent targets and the fulfill intent transaction.
+ */
+@Injectable()
+export class FulfillIntentService {
+  private logger = new Logger(FulfillIntentService.name)
+
+  constructor(
+    private readonly kernelAccountClientService: KernelAccountClientService,
+    private readonly proofService: ProofService,
+    private readonly feeService: FeeService,
+    private readonly utilsIntentService: UtilsIntentService,
+    private readonly ecoConfigService: EcoConfigService,
+  ) {}
+
+  /**
+   * Executes the fulfill intent process for an intent. It creates the transaction for fulfillment, and posts it
+   * to the chain. It then updates the db model of the intent with the status and receipt.
+   *
+   * @param intentHash the intent hash to fulfill
+   * @returns
+   */
+  async executeFulfillIntent(intentHash: Hex) {
+    const data = await this.utilsIntentService.getIntentProcessData(intentHash)
+    const { model, solver, err } = data ?? {}
+    if (!data || !model || !solver) {
+      if (err) {
+        throw err
+      }
+      return
+    }
+    // If the intent is already solved, return
+    // Could happen if redis has pending job while this is still executing
+    if (model.status === 'SOLVED') {
+      return
+    }
+
+    const kernelAccountClient = await this.kernelAccountClientService.getClient(solver.chainID)
+
+    // Create transactions for intent targets
+    const targetSolveTxs = this.getTransactionsForTargets(data)
+
+    // Create fulfill tx
+    const fulfillTx = await this.getFulfillIntentTx(solver.inboxAddress, model)
+
+    // Combine all transactions
+    const transactions = [...targetSolveTxs, fulfillTx]
+
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `Fulfilling ${this.getFulfillment()} transaction`,
+        properties: {
+          transactions,
+        },
+      }),
+    )
+
+    try {
+      await this.finalFeasibilityCheck(model.intent)
+
+      const transactionHash = await kernelAccountClient.execute(transactions)
+
+      const receipt = await kernelAccountClient.waitForTransactionReceipt({ hash: transactionHash })
+
+      // set the status and receipt for the model
+      model.receipt = receipt as any
+      if (receipt.status === 'reverted') {
+        throw EcoError.FulfillIntentRevertError(receipt)
+      }
+      model.status = 'SOLVED'
+
+      this.logger.debug(
+        EcoLogMessage.fromDefault({
+          message: `Fulfilled transactionHash ${receipt.transactionHash}`,
+          properties: {
+            userOPHash: receipt,
+            destinationChainID: model.intent.route.destination,
+            sourceChainID: model.event.sourceChainID,
+          },
+        }),
+      )
+    } catch (e) {
+      model.status = 'FAILED'
+      model.receipt = model.receipt ? { previous: model.receipt, current: e } : e
+
+      this.logger.error(
+        EcoLogMessage.withError({
+          message: `fulfillIntent: Invalid transaction`,
+          error: EcoError.FulfillIntentBatchError,
+          properties: {
+            model: model,
+            flatExecuteData: transactions,
+            errorPassed: e,
+          },
+        }),
+      )
+
+      // Throw error to retry job
+      throw e
+    } finally {
+      // Update the db model
+      await this.utilsIntentService.updateIntentModel(model)
+    }
+  }
+
+  /**
+   * Checks that the intent is feasible for the fulfillment. This
+   * could occur due to changes to the fees/limits of the intent. A failed
+   * intent might retry later when its no longer profitable, etc.
+   * Throws an error if the intent is not feasible.
+   * @param intent the intent to check
+   */
+  async finalFeasibilityCheck(intent: IntentDataModel) {
+    const { error } = await this.feeService.isRouteFeasible(intent)
+    if (error) {
+      throw error
+    }
+  }
+
+  /**
+   * Checks if the transaction is feasible for an erc20 token transfer.
+   *
+   * @param tt the transaction target data
+   * @param solver the target solver
+   * @param target the target ERC20 address
+   * @returns
+   */
+  handleErc20(tt: TransactionTargetData, solver: Solver, target: Hex) {
+    switch (tt.selector) {
+      case getERC20Selector('transfer'):
+        const dstAmount = tt.decodedFunctionData.args?.[1] as bigint
+        // Approve the inbox to spend the amount, inbox contract pulls the funds
+        // then does the transfer call for the target
+        const transferFunctionData = encodeFunctionData({
+          abi: erc20Abi,
+          functionName: 'approve',
+          args: [solver.inboxAddress, dstAmount], //spender, amount
+        })
+
+        return [{ to: target, data: transferFunctionData }]
+      default:
+        return []
+    }
+  }
+
+  /**
+   * Returns the transactions for the intent targets
+   * @param intentProcessData
+   * @private
+   */
+  private getTransactionsForTargets(intentProcessData: IntentProcessData) {
+    const { model, solver } = intentProcessData
+    if (!model || !solver) {
+      return []
+    }
+
+    // Create transactions for intent targets
+    return model.intent.route.calls.flatMap((call) => {
+      const tt = getTransactionTargetData(solver, call)
+      if (tt === null) {
+        this.logger.error(
+          EcoLogMessage.withError({
+            message: `fulfillIntent: Invalid transaction data`,
+            error: EcoError.FulfillIntentNoTransactionError,
+            properties: {
+              model: model,
+            },
+          }),
+        )
+        return []
+      }
+
+      switch (tt.targetConfig.contractType) {
+        case 'erc20':
+          return this.handleErc20(tt, solver, call.target)
+        case 'erc721':
+        case 'erc1155':
+        default:
+          return []
+      }
+    })
+  }
+
+  /**
+   * Returns the fulfill intent data
+   * @param inboxAddress
+   * @param model
+   * @private
+   */
+  private async getFulfillIntentTx(
+    inboxAddress: Hex,
+    model: IntentSourceModel,
+  ): Promise<ExecuteSmartWalletArg> {
+    const claimant = this.ecoConfigService.getEth().claimant
+    const isHyperlane = this.proofService.isHyperlaneProver(model.intent.reward.prover)
+    const functionName: FulfillmentMethod = this.proofService.isStorageProver(
+      model.intent.reward.prover,
+    )
+      ? 'fulfillStorage'
+      : this.getFulfillment()
+
+    const args = [
+      model.intent.route,
+      // @ts-expect-error we dynamically set the args
+      model.intent.reward.getHash(),
+      claimant,
+      // @ts-expect-error we dynamically set the args
+      model.intent.getHash().intentHash,
+    ]
+
+    if (isHyperlane) {
+      args.push(model.intent.reward.prover)
+      if (functionName === 'fulfillHyperInstantWithRelayer') {
+        args.push('0x0')
+        args.push(zeroAddress)
+      }
+    }
+    let fee = 0n
+    if (isHyperlane && functionName === 'fulfillHyperInstantWithRelayer') {
+      fee = BigInt((await this.getHyperlaneFee(inboxAddress, model)) || '0x0')
+    }
+
+    const fulfillIntentData = encodeFunctionData({
+      abi: InboxAbi,
+      functionName,
+      // @ts-expect-error we dynamically set the args
+      args,
+    })
+
+    return {
+      to: inboxAddress,
+      data: fulfillIntentData,
+      // ...(isHyperlane && fee > 0 && { value: fee }),
+      value: fee,
+    }
+  }
+
+  /**
+   * Returns the hyperlane fee
+   * @param prover
+   * @private
+   */
+  private async getHyperlaneFee(
+    inboxAddress: Hex,
+    model: IntentSourceModel,
+  ): Promise<Hex | undefined> {
+    const client = await this.kernelAccountClientService.getClient(
+      Number(model.intent.route.destination),
+    )
+    const encodedMessageBody = encodeAbiParameters(
+      [{ type: 'bytes[]' }, { type: 'address[]' }],
+      [[model.intent.hash], [this.ecoConfigService.getEth().claimant]],
+    )
+    const functionName = 'fetchFee'
+    const args: ContractFunctionArgs<typeof InboxAbi, 'view', typeof functionName> = [
+      model.event.sourceChainID, //_sourceChainID
+      pad(model.intent.reward.prover), //_prover
+      encodedMessageBody, //_messageBody
+      '0x0', //_metadata
+      zeroAddress, //_postDispatchHook
+    ]
+    const callData = encodeFunctionData({
+      abi: InboxAbi,
+      functionName,
+      args,
+    })
+    const proverData = await client.call({
+      to: inboxAddress,
+      data: callData,
+    })
+    return proverData.data
+  }
+
+  /**
+   * @returns the fulfillment method
+   */
+  private getFulfillment(): FulfillmentMethod {
+    switch (this.ecoConfigService.getFulfill().run) {
+      case 'batch':
+        return 'fulfillHyperBatched'
+      case 'single':
+      default:
+        return 'fulfillHyperInstantWithRelayer'
+    }
+  }
+}