eco-solver 0.0.1-security → 1.5.0

package/src/intent/tests/validation.service.spec.ts

@@ -0,0 +1,337 @@
+const mockGetTransactionTargetData = jest.fn()
+import { Test, TestingModule } from '@nestjs/testing'
+import { createMock, DeepMocked } from '@golevelup/ts-jest'
+import { TransactionTargetData, UtilsIntentService } from '@/intent/utils-intent.service'
+import { ProofService } from '@/prover/proof.service'
+import {
+  ValidationChecks,
+  ValidationService,
+  validationsSucceeded,
+} from '@/intent/validation.sevice'
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import { entries } from 'lodash'
+import { FeeService } from '@/fee/fee.service'
+import { FeeConfigType } from '@/eco-configs/eco-config.types'
+jest.mock('@/intent/utils', () => {
+  return {
+    ...jest.requireActual('@/intent/utils'),
+    getTransactionTargetData: mockGetTransactionTargetData,
+  }
+})
+describe('ValidationService', () => {
+  let validationService: ValidationService
+  let proofService: DeepMocked<ProofService>
+  let feeService: DeepMocked<FeeService>
+  let ecoConfigService: DeepMocked<EcoConfigService>
+  let utilsIntentService: DeepMocked<UtilsIntentService>
+  const mockLogLog = jest.fn()
+
+  beforeEach(async () => {
+    const mod: TestingModule = await Test.createTestingModule({
+      providers: [
+        ValidationService,
+        { provide: ProofService, useValue: createMock<ProofService>() },
+        { provide: FeeService, useValue: createMock<FeeService>() },
+        { provide: EcoConfigService, useValue: createMock<EcoConfigService>() },
+        { provide: UtilsIntentService, useValue: createMock<UtilsIntentService>() },
+      ],
+    }).compile()
+
+    validationService = mod.get(ValidationService)
+    proofService = mod.get(ProofService)
+    feeService = mod.get(FeeService)
+    ecoConfigService = mod.get(EcoConfigService)
+    utilsIntentService = mod.get(UtilsIntentService)
+
+    validationService['logger'].log = mockLogLog
+
+    jest.spyOn(ecoConfigService, 'getIntentConfigs').mockReturnValueOnce({} as any)
+  })
+
+  afterEach(async () => {
+    jest.restoreAllMocks()
+    mockLogLog.mockClear()
+  })
+
+  describe('on validationsSucceeded', () => {
+    it('should return false if any validations are false', async () => {
+      const validations = {
+        supportedProver: true,
+        supportedTargets: true,
+        supportedSelectors: true,
+        validTransferLimit: true,
+        validExpirationTime: false,
+        validDestination: true,
+        fulfillOnDifferentChain: true,
+      } as ValidationChecks
+      expect(validationsSucceeded(validations)).toBe(false)
+    })
+
+    it('should return false if all validations are false', async () => {
+      const validations = {
+        supportedProver: false,
+        supportedTargets: false,
+        supportedSelectors: false,
+        validTransferLimit: false,
+        validExpirationTime: false,
+        validDestination: false,
+        fulfillOnDifferentChain: false,
+      } as ValidationChecks
+      expect(validationsSucceeded(validations)).toBe(false)
+    })
+
+    it('should return true if all validations are true', async () => {
+      const validations = {
+        supportedProver: true,
+        supportedTargets: true,
+        supportedSelectors: true,
+        validExpirationTime: true,
+        validDestination: true,
+        fulfillOnDifferentChain: true,
+      } as ValidationChecks
+      expect(validationsSucceeded(validations)).toBe(true)
+    })
+  })
+
+  describe('on individual validation cases', () => {
+    describe('on supportedProver', () => {
+      const sourceChainID = 1n
+      const chainID = sourceChainID
+      const prover = '0xcf25397DC87C750eEF006101172FFbeAeA98Aa76'
+      const unsupportedChain = 2n
+      const unsupportedProver = '0x26D2C47c5659aC8a1c4A29A052Fa7B2ccD45Ca43'
+      it('should fail if no source intent exists with the models source chain id', async () => {
+        const intent = { event: { sourceChainID } } as any
+        ecoConfigService.getIntentSources.mockReturnValueOnce([])
+        expect(validationService.supportedProver(intent)).toBe(false)
+      })
+
+      it('should fail if no source supports the prover', async () => {
+        const intent = { event: { sourceChainID }, intent: { reward: { prover } } } as any
+        ecoConfigService.getIntentSources.mockReturnValueOnce([
+          { provers: [unsupportedProver], chainID } as any,
+        ])
+        expect(validationService.supportedProver(intent)).toBe(false)
+      })
+
+      it('should fail if no source supports the prover on the required chain', async () => {
+        const intent = { event: { sourceChainID }, intent: { prover } } as any
+        ecoConfigService.getIntentSources.mockReturnValueOnce([
+          { provers: [prover], chainID: unsupportedChain } as any,
+        ])
+        expect(validationService.supportedProver(intent)).toBe(false)
+      })
+
+      it('should succeed if a single source supports the prover', async () => {
+        const intent = { sourceChainID, prover } as any
+        ecoConfigService.getIntentSources.mockReturnValueOnce([
+          { provers: [unsupportedProver], chainID } as any,
+          { provers: [prover], chainID } as any,
+        ])
+        expect(validationService.supportedProver(intent)).toBe(true)
+      })
+
+      it('should succeed if multiple sources supports the prover', async () => {
+        const intent = { sourceChainID, prover } as any
+        ecoConfigService.getIntentSources.mockReturnValueOnce([
+          { provers: [prover], chainID } as any,
+          { provers: [prover], chainID } as any,
+        ])
+        expect(validationService.supportedProver(intent)).toBe(true)
+      })
+    })
+
+    describe('on supportedTargets', () => {
+      const intent = { route: { calls: [] } } as any
+      const solver = { targets: {} } as any
+      it('should fail solver has no targets', async () => {
+        intent.route.calls = []
+        expect(validationService.supportedTargets(intent, solver)).toBe(false)
+      })
+
+      it('should fail intent has no targets', async () => {
+        intent.route.calls = [{ target: '0x1' }]
+        solver.targets = {}
+        expect(validationService.supportedTargets(intent, solver)).toBe(false)
+      })
+
+      it('should fail not all targets are supported on solver', async () => {
+        intent.route.calls = [{ target: '0x1' }, { target: '0x2' }]
+        solver.targets = { [intent.route.calls[0].target]: {} }
+        expect(validationService.supportedTargets(intent, solver)).toBe(false)
+      })
+
+      it('should succeed if targets supported ', async () => {
+        intent.route.calls = [{ target: '0x1' }, { target: '0x2' }]
+        solver.targets = { [intent.route.calls[0].target]: {}, [intent.route.calls[1].target]: {} }
+        expect(validationService.supportedTargets(intent, solver)).toBe(true)
+      })
+    })
+
+    describe('on supportedSelectors', () => {
+      const intent = { route: { calls: [] } } as any
+      const solver = { targets: {} } as any
+      it('should fail if there are no calls', async () => {
+        intent.route.calls = []
+        expect(validationService.supportedSelectors(intent, solver)).toBe(false)
+        expect(mockLogLog).toHaveBeenCalledTimes(1)
+        expect(mockLogLog).toHaveBeenCalledWith({ msg: 'supportedSelectors: Target/data invalid' })
+      })
+
+      it('should fail not every call is supported', async () => {
+        intent.route.calls = [{ target: '0x1' }, { target: '0x2' }]
+        mockGetTransactionTargetData.mockImplementation((solver, call) => {
+          return call.target == intent.route.calls[0].target
+            ? ({} as any as TransactionTargetData)
+            : null
+        })
+        expect(validationService.supportedSelectors(intent, solver)).toBe(false)
+      })
+
+      it('should succeed if every call is supported', async () => {
+        intent.route.calls = [{ target: '0x1' }, { target: '0x2' }]
+        mockGetTransactionTargetData.mockReturnValue({} as any as TransactionTargetData)
+        expect(validationService.supportedSelectors(intent, solver)).toBe(true)
+      })
+    })
+
+    describe('on validTransferLimit', () => {
+      const defaultFee: FeeConfigType = {
+        limitFillBase6: 1000n * 10n ** 6n,
+        algorithm: 'linear',
+        constants: {
+          baseFee: 20_000n,
+          tranche: {
+            unitFee: 15_000n,
+            unitSize: 100_000_000n,
+          },
+        },
+      }
+      it('should return false if feeService does', async () => {
+        const error = new Error('error here')
+        jest
+          .spyOn(feeService, 'getTotalFill')
+          .mockResolvedValueOnce({ totalFillNormalized: 1n, error })
+        expect(await validationService.validTransferLimit({} as any)).toBe(false)
+      })
+
+      it('should return false if the total fill above the max fill', async () => {
+        jest.spyOn(feeService, 'getTotalFill').mockResolvedValueOnce({
+          totalFillNormalized: defaultFee.limitFillBase6 + 1n,
+        })
+        const mockFeeConfig = jest.fn().mockReturnValue(defaultFee)
+        feeService.getFeeConfig = mockFeeConfig
+        expect(await validationService.validTransferLimit({} as any)).toBe(false)
+        expect(mockFeeConfig).toHaveBeenCalledTimes(1)
+      })
+
+      it('should return true if no error and the total fill is below max fill', async () => {
+        const mockFeeConfig = jest.fn().mockReturnValue(defaultFee)
+        feeService.getFeeConfig = mockFeeConfig
+
+        jest
+          .spyOn(feeService, 'getTotalFill')
+          .mockResolvedValueOnce({ totalFillNormalized: defaultFee.limitFillBase6 - 1n })
+        expect(await validationService.validTransferLimit({} as any)).toBe(true)
+        expect(mockFeeConfig).toHaveBeenCalledTimes(1)
+      })
+    })
+
+    describe('on validExpirationTime', () => {
+      //mostly covered in utilsIntentService
+      it('should return whatever UtilsIntentService does', async () => {
+        const intent = { reward: { deadline: 100 } } as any
+        proofService.isIntentExpirationWithinProofMinimumDate.mockReturnValueOnce(true)
+        expect(validationService['validExpirationTime'](intent)).toBe(true)
+        proofService.isIntentExpirationWithinProofMinimumDate.mockReturnValueOnce(false)
+        expect(validationService['validExpirationTime'](intent)).toBe(false)
+      })
+    })
+
+    describe('on validDestination', () => {
+      it('should fail if destination is not supported', async () => {
+        const intent = { route: { destination: 10n } } as any
+        ecoConfigService.getSupportedChains.mockReturnValueOnce([11n, 12n])
+        expect(validationService['validDestination'](intent)).toBe(false)
+      })
+
+      it('should fail if destination is not supported', async () => {
+        const intent = { route: { destination: 10n } } as any
+        ecoConfigService.getSupportedChains.mockReturnValueOnce([10n, 12n])
+        expect(validationService['validDestination'](intent)).toBe(true)
+      })
+    })
+
+    describe('on fulfillOnDifferentChain', () => {
+      it('should fail if the fulfillment is on the same chain as the event', async () => {
+        const intent = {
+          route: { destination: 10, source: 10 },
+        } as any
+        expect(validationService['fulfillOnDifferentChain'](intent)).toBe(false)
+      })
+
+      it('should succeed if the fulfillment is on a different chain as the event', async () => {
+        const intent = {
+          route: { destination: 10, source: 20 },
+        } as any
+        proofService.isIntentExpirationWithinProofMinimumDate.mockReturnValueOnce(true)
+        expect(validationService['fulfillOnDifferentChain'](intent)).toBe(true)
+      })
+    })
+  })
+
+  describe('on assertValidations', () => {
+    const updateInvalidIntentModel = jest.fn()
+    const assetCases: Record<keyof ValidationChecks, string> = {
+      supportedProver: 'supportedProver',
+      supportedTargets: 'supportedTargets',
+      supportedSelectors: 'supportedSelectors',
+      validTransferLimit: 'validTransferLimit',
+      validExpirationTime: 'validExpirationTime',
+      validDestination: 'validDestination',
+      fulfillOnDifferentChain: 'fulfillOnDifferentChain',
+    }
+    beforeEach(() => {
+      utilsIntentService.updateInvalidIntentModel = updateInvalidIntentModel
+    })
+
+    afterEach(() => {
+      jest.clearAllMocks()
+    })
+
+    entries(assetCases).forEach(([fun, boolVarName]: [string, string]) => {
+      it(`should fail on ${fun}`, async () => {
+        const intent = {
+          reward: {
+            creator: '0xa',
+            prover: '0xb',
+            deadline: 100,
+            tokens: [
+              { token: '0x1', amount: 1n },
+              { token: '0x2', amount: 2n },
+            ],
+          },
+          route: {
+            salt: '0x1',
+            destination: 10,
+            source: 11,
+            calls: [],
+          },
+        } as any
+        const solver = { targets: {} } as any
+        const logObj = entries(assetCases).reduce(
+          (ac, [, a]) => ({ ...ac, [a]: a == boolVarName }),
+          {},
+        )
+        if (boolVarName == 'fulfillOnDifferentChain') {
+          intent.route.destination = intent.route.source
+        }
+        const now = new Date()
+        proofService.getProofMinimumDate = jest.fn().mockReturnValueOnce(now)
+        validationService[fun] = jest.fn().mockReturnValueOnce(false)
+        const validations = await validationService['assertValidations'](intent, solver)
+        expect(validations[boolVarName]).toBe(false)
+      })
+    })
+  })
+})

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

@@ -0,0 +1,168 @@
+import { Injectable, Logger } from '@nestjs/common'
+import { InjectModel } from '@nestjs/mongoose'
+import { IntentSourceModel } from './schemas/intent-source.schema'
+import { Model } from 'mongoose'
+import { EcoLogMessage } from '../common/logging/eco-log-message'
+import { EcoConfigService } from '../eco-configs/eco-config.service'
+import { Solver, TargetContract } from '../eco-configs/eco-config.types'
+import { EcoError } from '../common/errors/eco-error'
+import { DecodeFunctionDataReturnType, Hex } from 'viem'
+import { FulfillmentLog } from '@/contracts/inbox'
+import { Network } from 'alchemy-sdk'
+import { ValidationChecks } from '@/intent/validation.sevice'
+
+/**
+ * Data for a transaction target
+ */
+export interface TransactionTargetData {
+  decodedFunctionData: DecodeFunctionDataReturnType
+  selector: Hex
+  targetConfig: TargetContract
+}
+
+/**
+ * Type for logging in validations
+ */
+export interface IntentLogType {
+  hash?: Hex
+  sourceNetwork?: Network
+}
+
+/**
+ * Model and solver for the intent
+ */
+export interface IntentProcessData {
+  model: IntentSourceModel | null
+  solver: Solver | null
+  err?: EcoError
+}
+
+/**
+ * Service class for solving an intent on chain
+ */
+@Injectable()
+export class UtilsIntentService {
+  private logger = new Logger(UtilsIntentService.name)
+
+  constructor(
+    @InjectModel(IntentSourceModel.name) private intentModel: Model<IntentSourceModel>,
+    private readonly ecoConfigService: EcoConfigService,
+  ) {}
+
+  /**
+   * updateOne the intent model in the database, using the intent hash as the query
+   *
+   * @param intentModel the model factory to use
+   * @param model the new model data
+   */
+  async updateIntentModel(model: IntentSourceModel) {
+    return await this.intentModel.updateOne({ 'intent.hash': model.intent.hash }, model)
+  }
+
+  /**
+   * Updates the intent model with the invalid cause, using {@link updateIntentModel}
+   *
+   * @param intentModel the model factory to use
+   * @param model the new model data
+   * @param invalidCause the reason the intent is invalid
+   * @returns
+   */
+  async updateInvalidIntentModel(model: IntentSourceModel, invalidCause: ValidationChecks) {
+    model.status = 'INVALID'
+    model.receipt = invalidCause as any
+    return await this.updateIntentModel(model)
+  }
+
+  /**
+   * Updates the intent model with the infeasable cause and receipt, using {@link updateIntentModel}
+   *
+   * @param intentModel  the model factory to use
+   * @param model  the new model data
+   * @param infeasable  the infeasable result
+   * @returns
+   */
+  async updateInfeasableIntentModel(model: IntentSourceModel, infeasable: Error) {
+    model.status = 'INFEASABLE'
+    model.receipt = infeasable as any
+    return await this.updateIntentModel(model)
+  }
+
+  /**
+   * Updates the intent model with the fulfillment status. If the intent was fulfilled by this solver, then
+   * the status should already be SOLVED: in that case this function does nothing.
+   *
+   * @param fulfillment the fulfillment log event
+   */
+  async updateOnFulfillment(fulfillment: FulfillmentLog) {
+    const model = await this.intentModel.findOne({
+      'intent.hash': fulfillment.args._hash,
+    })
+    if (model) {
+      model.status = 'SOLVED'
+      await this.intentModel.updateOne({ 'intent.hash': fulfillment.args._hash }, model)
+    } else {
+      this.logger.warn(
+        EcoLogMessage.fromDefault({
+          message: `Intent not found for fulfillment ${fulfillment.args._hash}`,
+          properties: {
+            fulfillment,
+          },
+        }),
+      )
+    }
+  }
+
+  /**
+   * Finds the the intent model in the database by the intent hash and the solver that can fulfill
+   * on the destination chain for that intent
+   *
+   * @param intentHash the intent hash
+   * @returns Intent model and solver
+   */
+  async getIntentProcessData(intentHash: string): Promise<IntentProcessData | undefined> {
+    try {
+      const model = await this.intentModel.findOne({
+        'intent.hash': intentHash,
+      })
+      if (!model) {
+        return { model, solver: null, err: EcoError.IntentSourceDataNotFound(intentHash) }
+      }
+
+      const solver = await this.getSolver(model.intent.route.destination, {
+        intentHash: intentHash,
+        sourceNetwork: model.event.sourceNetwork,
+      })
+      if (!solver) {
+        return
+      }
+      return { model, solver }
+    } catch (e) {
+      this.logger.error(
+        EcoLogMessage.fromDefault({
+          message: `Error in getIntentProcessData ${intentHash}`,
+          properties: {
+            intentHash: intentHash,
+            error: e,
+          },
+        }),
+      )
+      return
+    }
+  }
+
+  async getSolver(destination: bigint, opts?: any): Promise<Solver | undefined> {
+    const solver = this.ecoConfigService.getSolver(destination)
+    if (!solver) {
+      this.logger.log(
+        EcoLogMessage.fromDefault({
+          message: `No solver found for chain ${destination}`,
+          properties: {
+            ...(opts ? opts : {}),
+          },
+        }),
+      )
+      return
+    }
+    return solver
+  }
+}

package/src/intent/utils.ts

@@ -0,0 +1,37 @@
+import { EcoError } from '@/common/errors/eco-error'
+import { getFunctionBytes } from '@/common/viem/contracts'
+import { CallDataInterface, getERCAbi } from '@/contracts'
+import { Solver, TargetContract } from '@/eco-configs/eco-config.types'
+import { TransactionTargetData } from '@/intent/utils-intent.service'
+import { includes } from 'lodash'
+import { decodeFunctionData, toFunctionSelector } from 'viem'
+
+/**
+ * Decodes the function data for a target contract
+ *
+ * @param solver the solver for the intent
+ * @param call the call to decode
+ * @returns
+ */
+export function getTransactionTargetData(
+  solver: Solver,
+  call: CallDataInterface,
+): TransactionTargetData | null {
+  const targetConfig = solver.targets[call.target as string] as TargetContract
+  if (!targetConfig) {
+    //shouldn't happen since we do this.targetsSupported(model, solver) before this call
+    throw EcoError.IntentSourceTargetConfigNotFound(call.target as string)
+  }
+
+  const tx = decodeFunctionData({
+    abi: getERCAbi(targetConfig.contractType),
+    data: call.data,
+  })
+  const selector = getFunctionBytes(call.data)
+  const supportedSelectors = targetConfig.selectors.map((s) => toFunctionSelector(s))
+  const supported = tx && includes(supportedSelectors, selector)
+  if (!supported) {
+    return null
+  }
+  return { decodedFunctionData: tx, selector, targetConfig }
+}