eco-solver 0.0.1-security → 1.5.1

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

@@ -0,0 +1,176 @@
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common'
+import { EcoConfigService } from '../eco-configs/eco-config.service'
+import { EcoLogMessage } from '../common/logging/eco-log-message'
+import { IntentProcessData, UtilsIntentService } from './utils-intent.service'
+import { QUEUES } from '../common/redis/constants'
+import { JobsOptions, Queue } from 'bullmq'
+import { InjectQueue } from '@nestjs/bullmq'
+import { getIntentJobId } from '../common/utils/strings'
+import { Solver } from '../eco-configs/eco-config.types'
+import { IntentSourceModel } from './schemas/intent-source.schema'
+import { Hex } from 'viem'
+import { EcoError } from '../common/errors/eco-error'
+import { ValidationChecks, ValidationService, validationsFailed } from '@/intent/validation.sevice'
+import { MultichainPublicClientService } from '@/transaction/multichain-public-client.service'
+import { IntentSourceAbi } from '@eco-foundation/routes-ts'
+import { IntentDataModel } from '@/intent/schemas/intent-data.schema'
+
+/**
+ * Type that merges the {@link ValidationChecks} with the intentFunded check
+ */
+export type IntentValidations = ValidationChecks & {
+  intentFunded: boolean
+}
+
+/**
+ * Service class that acts as the main validation service for intents.
+ * Validation {@license ValidationService}:
+ * 1. Supports the prover
+ * 2. Supports the targets
+ * 3. Supports the selectors
+ * 4. Has a valid transfer limit
+ * 5. Has a valid expiration time
+ * 6. Fulfill chain not same as source chain
+ *
+ * Validates that the intent was also funded:
+ * 1. The intent was funded on chain in the IntentSource
+ *
+ * As well as some structural checks on the intent model
+ */
+@Injectable()
+export class ValidateIntentService implements OnModuleInit {
+  private logger = new Logger(ValidateIntentService.name)
+  private intentJobConfig: JobsOptions
+
+  constructor(
+    @InjectQueue(QUEUES.SOURCE_INTENT.queue) private readonly intentQueue: Queue,
+    private readonly validationService: ValidationService,
+    private readonly multichainPublicClientService: MultichainPublicClientService,
+    private readonly utilsIntentService: UtilsIntentService,
+    private readonly ecoConfigService: EcoConfigService,
+  ) {}
+
+  onModuleInit() {
+    this.intentJobConfig = this.ecoConfigService.getRedis().jobs.intentJobConfig
+  }
+
+  /**
+   * @param intentHash the hash of the intent to fulfill
+   */
+  async validateIntent(intentHash: Hex) {
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `validateIntent ${intentHash}`,
+        properties: {
+          intentHash: intentHash,
+        },
+      }),
+    )
+
+    const { model, solver } = await this.destructureIntent(intentHash)
+    if (!model || !solver) {
+      return false
+    }
+
+    if (!(await this.assertValidations(model, solver))) {
+      return false
+    }
+
+    const jobId = getIntentJobId('validate', intentHash, model.intent.logIndex)
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `validateIntent ${intentHash}`,
+        properties: {
+          intentHash,
+          jobId,
+        },
+      }),
+    )
+    //add to processing queue
+    await this.intentQueue.add(QUEUES.SOURCE_INTENT.jobs.feasable_intent, intentHash, {
+      jobId,
+      ...this.intentJobConfig,
+    })
+
+    return true
+  }
+
+  /**
+   * Executes all the validations we have on the model and solver
+   *
+   * @param model the source intent model
+   * @param solver the solver for the source chain
+   * @returns true if they all pass, false otherwise
+   */
+  async assertValidations(model: IntentSourceModel, solver: Solver): Promise<boolean> {
+    const validations = (await this.validationService.assertValidations(
+      model.intent,
+      solver,
+    )) as IntentValidations
+    validations.intentFunded = await this.intentFunded(model)
+
+    if (validationsFailed(validations)) {
+      await this.utilsIntentService.updateInvalidIntentModel(model, validations)
+      this.logger.log(
+        EcoLogMessage.fromDefault({
+          message: EcoError.IntentValidationFailed(model.intent.hash).message,
+          properties: {
+            model,
+            validations,
+          },
+        }),
+      )
+      return false
+    }
+
+    return true
+  }
+
+  /**
+   * Makes on onchain read call to make sure that the intent was funded in the IntentSource
+   * contract.
+   * @Notice An event emitted is not enough to guarantee that the intent was funded
+   * @param model the source intent model
+   * @returns
+   */
+  async intentFunded(model: IntentSourceModel): Promise<boolean> {
+    const sourceChainID = Number(model.intent.route.source)
+    const client = await this.multichainPublicClientService.getClient(sourceChainID)
+    const intentSource = this.ecoConfigService.getIntentSource(sourceChainID)
+    if (!intentSource) {
+      this.logger.error(
+        EcoLogMessage.fromDefault({
+          message: EcoError.IntentSourceNotFound(sourceChainID).message,
+          properties: {
+            model,
+          },
+        }),
+      )
+      return false
+    }
+
+    const isIntentFunded = await client.readContract({
+      address: intentSource.sourceAddress,
+      abi: IntentSourceAbi,
+      functionName: 'isIntentFunded',
+      args: [IntentDataModel.toChainIntent(model.intent)],
+    })
+    return isIntentFunded
+  }
+
+  /**
+   * Fetches the intent from the db and its solver and model from configs. Validates
+   * that both are returned without any error
+   *
+   * @param intentHash the hash of the intent to find in the db
+   * @returns
+   */
+  private async destructureIntent(intentHash: Hex): Promise<IntentProcessData> {
+    const data = await this.utilsIntentService.getIntentProcessData(intentHash)
+    const { model, solver, err } = data ?? {}
+    if (!data || !model || !solver) {
+      throw EcoError.ValidateIntentDescructureFailed(err)
+    }
+    return data
+  }
+}

package/src/intent/validation.sevice.ts

@@ -0,0 +1,223 @@
+import { EcoLogMessage } from '@/common/logging/eco-log-message'
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import { Solver } from '@/eco-configs/eco-config.types'
+import { FeeService } from '@/fee/fee.service'
+import { getTransactionTargetData } from '@/intent/utils'
+import { ProofService } from '@/prover/proof.service'
+import { QuoteIntentDataInterface } from '@/quote/dto/quote.intent.data.dto'
+import { Injectable, Logger } from '@nestjs/common'
+import { difference } from 'lodash'
+import { Hex } from 'viem'
+
+interface IntentModelWithHashInterface {
+  hash?: Hex
+}
+
+/**
+ * Validation type that mixes the QuoteIntentDataDTO with the hash. This is used to
+ * merge quotes and intents validations
+ */
+export interface ValidationIntentInterface
+  extends QuoteIntentDataInterface,
+    IntentModelWithHashInterface {}
+
+/**
+ * Type that holds all the possible validations that can fail
+ */
+export type ValidationChecks = {
+  supportedProver: boolean
+  supportedTargets: boolean
+  supportedSelectors: boolean
+  validTransferLimit: boolean
+  validExpirationTime: boolean
+  validDestination: boolean
+  fulfillOnDifferentChain: boolean
+}
+
+/**
+ * Validates that all of the validations succeeded
+ * @param validations  the validations to check
+ * @returns true if all of the validations passed
+ */
+export function validationsSucceeded(validations: ValidationType): boolean {
+  return Object.values(validations).every((v) => v)
+}
+
+/**
+ * Checks that at least one of the validations failed
+ * @param validations the validations to check
+ * @returns true if any of the validations failed
+ */
+export function validationsFailed(validations: ValidationType): boolean {
+  return !validationsSucceeded(validations)
+}
+
+/**
+ * Type that holds all the possible validations that can fail
+ */
+export type ValidationType = {
+  [key: string]: boolean
+}
+
+@Injectable()
+export class ValidationService {
+  private readonly logger = new Logger(ValidationService.name)
+
+  constructor(
+    private readonly proofService: ProofService,
+    private readonly feeService: FeeService,
+    private readonly ecoConfigService: EcoConfigService,
+  ) {}
+
+  /**
+   * Executes all the validations we have on the model and solver
+   *
+   * @param intent the source intent model
+   * @param solver the solver for the source chain
+   * @returns true if they all pass, false otherwise
+   */
+  async assertValidations(
+    intent: ValidationIntentInterface,
+    solver: Solver,
+  ): Promise<ValidationChecks> {
+    const supportedProver = this.supportedProver({
+      sourceChainID: intent.route.source,
+      prover: intent.reward.prover,
+    })
+    const supportedTargets = this.supportedTargets(intent, solver)
+    const supportedSelectors = this.supportedSelectors(intent, solver)
+    const validTransferLimit = await this.validTransferLimit(intent)
+    const validExpirationTime = this.validExpirationTime(intent)
+    const validDestination = this.validDestination(intent)
+    const fulfillOnDifferentChain = this.fulfillOnDifferentChain(intent)
+
+    return {
+      supportedProver,
+      supportedTargets,
+      supportedSelectors,
+      validTransferLimit,
+      validExpirationTime,
+      validDestination,
+      fulfillOnDifferentChain,
+    }
+  }
+
+  /**
+   * Checks if the IntentCreated event is using a supported prover. It first finds the source intent contract that is on the
+   * source chain of the event. Then it checks if the prover is supported by the source intent. In the
+   * case that there are multiple matching source intent contracts on the same chain, as long as any of
+   * them support the prover, the function will return true.
+   *
+   * @param ops the intent info
+   * @returns
+   */
+  supportedProver(ops: { sourceChainID: bigint; prover: Hex }): boolean {
+    const srcSolvers = this.ecoConfigService.getIntentSources().filter((intent) => {
+      return BigInt(intent.chainID) == ops.sourceChainID
+    })
+
+    return srcSolvers.some((intent) => {
+      return intent.provers.some((prover) => prover == ops.prover)
+    })
+  }
+
+  /**
+   * Verifies that the intent targets and data arrays are equal in length, and
+   * that every target-data can be decoded
+   *
+   * @param intent the intent model
+   * @param solver the solver for the intent
+   * @returns
+   */
+  supportedSelectors(intent: ValidationIntentInterface, solver: Solver): boolean {
+    if (intent.route.calls.length == 0) {
+      this.logger.log(
+        EcoLogMessage.fromDefault({
+          message: `supportedSelectors: Target/data invalid`,
+        }),
+      )
+      return false
+    }
+    return intent.route.calls.every((call) => {
+      const tx = getTransactionTargetData(solver, call)
+      return tx
+    })
+  }
+
+  /**
+   * Verifies that all the intent targets are supported by the solver
+   *
+   * @param intent the intent model
+   * @param solver the solver for the intent
+   * @returns
+   */
+  supportedTargets(intent: ValidationIntentInterface, solver: Solver): boolean {
+    const intentTargets = intent.route.calls.map((call) => call.target)
+    const solverTargets = Object.keys(solver.targets)
+    //all targets are included in the solver targets array
+    const exist = solverTargets.length > 0 && intentTargets.length > 0
+    const targetsSupported = exist && difference(intentTargets, solverTargets).length == 0
+
+    if (!targetsSupported) {
+      this.logger.debug(
+        EcoLogMessage.fromDefault({
+          message: `Targets not supported for intent ${intent.hash ? intent.hash : 'quote'}`,
+          properties: {
+            ...(intent.hash && {
+              intentHash: intent.hash,
+              source: intent.route.source,
+            }),
+          },
+        }),
+      )
+    }
+    return targetsSupported
+  }
+
+  /**
+   * Checks if the transfer total is within the bounds of the solver, ie below a certain threshold
+   * @param intent the source intent model
+   * @returns  true if the transfer is within the bounds
+   */
+  async validTransferLimit(intent: ValidationIntentInterface): Promise<boolean> {
+    const { totalFillNormalized, error } = await this.feeService.getTotalFill(intent)
+    if (error) {
+      return false
+    }
+    const limitFillBase6 = this.feeService.getFeeConfig({ intent }).limitFillBase6
+    return totalFillNormalized <= limitFillBase6
+  }
+
+  /**
+   *
+   * @param intent the source intent model
+   * @param solver the solver for the source chain
+   * @returns
+   */
+  validExpirationTime(intent: ValidationIntentInterface): boolean {
+    //convert to milliseconds
+    const time = Number.parseInt(`${intent.reward.deadline as bigint}`) * 1000
+    const expires = new Date(time)
+    return this.proofService.isIntentExpirationWithinProofMinimumDate(intent.reward.prover, expires)
+  }
+
+  /**
+   * Checks that the intent destination is supported by the solver
+   * @param intent the source intent model
+   * @returns
+   */
+  validDestination(intent: ValidationIntentInterface): boolean {
+    return this.ecoConfigService.getSupportedChains().includes(intent.route.destination)
+  }
+
+  /**
+   * Checks that the intent fulfillment is on a different chain than its source
+   * Needed since some proving methods(Hyperlane) cant prove same chain
+   * @param intent the source intent
+   * @param solver the solver used to fulfill
+   * @returns
+   */
+  fulfillOnDifferentChain(intent: ValidationIntentInterface): boolean {
+    return intent.route.destination !== intent.route.source
+  }
+}

package/src/interceptors/big-int.interceptor.ts

@@ -0,0 +1,30 @@
+import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common'
+import { Observable } from 'rxjs'
+import { map } from 'rxjs/operators'
+
+@Injectable()
+export class BigIntToStringInterceptor implements NestInterceptor {
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    return next.handle().pipe(map((data) => this.transformBigInt(data)))
+  }
+
+  private transformBigInt(data: any): any {
+    if (data === null || data === undefined) return data
+
+    if (typeof data === 'bigint') {
+      return data.toString()
+    }
+
+    if (Array.isArray(data)) {
+      return data.map((item) => this.transformBigInt(item))
+    }
+
+    if (typeof data === 'object') {
+      return Object.fromEntries(
+        Object.entries(data).map(([key, value]) => [key, this.transformBigInt(value)]),
+      )
+    }
+
+    return data
+  }
+}

package/src/intervals/interval.module.ts

@@ -0,0 +1,18 @@
+import { Module } from '@nestjs/common'
+import { RetryInfeasableIntentsService } from '@/intervals/retry-infeasable-intents.service'
+import { initBullMQ } from '@/bullmq/bullmq.helper'
+import { QUEUES } from '@/common/redis/constants'
+import { IntentModule } from '@/intent/intent.module'
+import { ProverModule } from '@/prover/prover.module'
+import { IntervalProcessor } from '@/bullmq/processors/interval.processor'
+
+@Module({
+  imports: [
+    initBullMQ(QUEUES.INTERVAL),
+    initBullMQ(QUEUES.SOURCE_INTENT),
+    IntentModule,
+    ProverModule,
+  ],
+  providers: [RetryInfeasableIntentsService, IntervalProcessor],
+})
+export class IntervalModule {}

package/src/intervals/retry-infeasable-intents.service.ts

@@ -0,0 +1,89 @@
+import { EcoLogMessage } from '@/common/logging/eco-log-message'
+import { QUEUES } from '@/common/redis/constants'
+import { getIntentJobId } from '@/common/utils/strings'
+import { Proofs } from '@/contracts'
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import { IntentSourceModel } from '@/intent/schemas/intent-source.schema'
+import { ProofService } from '@/prover/proof.service'
+import { InjectQueue } from '@nestjs/bullmq'
+import { Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common'
+import { InjectModel } from '@nestjs/mongoose'
+import { JobsOptions, Queue } from 'bullmq'
+import { Model } from 'mongoose'
+
+@Injectable()
+export class RetryInfeasableIntentsService implements OnApplicationBootstrap {
+  private logger = new Logger(RetryInfeasableIntentsService.name)
+  private intentJobConfig: JobsOptions
+
+  constructor(
+    @InjectQueue(QUEUES.INTERVAL.queue) private readonly intervalQueue: Queue,
+    @InjectQueue(QUEUES.SOURCE_INTENT.queue) private readonly intentQueue: Queue,
+    @InjectModel(IntentSourceModel.name) private intentModel: Model<IntentSourceModel>,
+    private readonly proofService: ProofService,
+    private readonly ecoConfigService: EcoConfigService,
+  ) {}
+
+  async onModuleInit() {
+    this.intentJobConfig = this.ecoConfigService.getIntervals().retryInfeasableIntents.jobTemplate
+      .opts as JobsOptions
+  }
+
+  async onApplicationBootstrap() {
+    const config = this.ecoConfigService.getIntervals().retryInfeasableIntents
+    config.repeatOpts = { ...config.repeatOpts, immediately: true }
+    config.jobTemplate = {
+      ...config.jobTemplate,
+      name: QUEUES.INTERVAL.jobs.retry_infeasable_intents,
+    }
+    this.intervalQueue.upsertJobScheduler(
+      QUEUES.INTERVAL.jobs.RETRY_INFEASABLE_INTENTS,
+      config.repeatOpts,
+      config.jobTemplate,
+    )
+  }
+
+  /**
+   * Retries intents that are infeasable but still within the proof expiration window.
+   * Sends them on the {@link QUEUES.SOURCE_INTENT.jobs.retry_intent} queue to validate
+   */
+  async retryInfeasableIntents() {
+    const models = await this.getInfeasableIntents()
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `retryInfeasableIntents`,
+        properties: {
+          models,
+        },
+      }),
+    )
+
+    const retryTasks = models.map(async (model) => {
+      const jobId = getIntentJobId('retry', model.intent.hash, model.intent.logIndex)
+
+      //add to processing queue
+      await this.intentQueue.add(QUEUES.SOURCE_INTENT.jobs.retry_intent, model.intent.hash, {
+        jobId,
+        ...this.intentJobConfig,
+      })
+    })
+
+    await Promise.all(retryTasks)
+  }
+
+  private async getInfeasableIntents() {
+    return await this.intentModel.find({
+      status: 'INFEASABLE',
+      $or: [
+        {
+          'intent.expiration': { $gt: this.proofService.getProofMinimumDate(Proofs.Hyperlane) },
+          'intent.prover': { $in: this.proofService.getProvers(Proofs.Hyperlane) },
+        },
+        {
+          'intent.expiration': { $gt: this.proofService.getProofMinimumDate(Proofs.Storage) },
+          'intent.prover': { $in: this.proofService.getProvers(Proofs.Storage) },
+        },
+      ],
+    })
+  }
+}