eco-solver 0.0.1-security → 1.5.2

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

@@ -0,0 +1,308 @@
+const mockDecodeFunctionData = jest.fn()
+import { createMock, DeepMocked } from '@golevelup/ts-jest'
+import { EcoConfigService } from '../../eco-configs/eco-config.service'
+import { Test, TestingModule } from '@nestjs/testing'
+import { getModelToken } from '@nestjs/mongoose'
+import { IntentSourceModel } from '../schemas/intent-source.schema'
+import { Model } from 'mongoose'
+import { UtilsIntentService } from '../utils-intent.service'
+import { getQueueToken } from '@nestjs/bullmq'
+import { QUEUES } from '../../common/redis/constants'
+import { Queue } from 'bullmq'
+import { EcoError } from '../../common/errors/eco-error'
+import { getFunctionBytes } from '../../common/viem/contracts'
+import { FulfillmentLog } from '@/contracts/inbox'
+import { CallDataInterface } from '@/contracts'
+import { ValidationChecks } from '@/intent/validation.sevice'
+import { QuoteError } from '@/quote/errors'
+
+jest.mock('viem', () => {
+  return {
+    ...jest.requireActual('viem'),
+    decodeFunctionData: mockDecodeFunctionData,
+  }
+})
+
+describe('UtilsIntentService', () => {
+  let utilsIntentService: UtilsIntentService
+  let ecoConfigService: DeepMocked<EcoConfigService>
+  let intentModel: DeepMocked<Model<IntentSourceModel>>
+  const mockLogDebug = jest.fn()
+  const mockLogLog = jest.fn()
+  const mockLogWarn = jest.fn()
+  const address1 = '0x1111111111111111111111111111111111111111'
+  const address2 = '0x2222222222222222222222222222222222222222'
+  beforeEach(async () => {
+    const chainMod: TestingModule = await Test.createTestingModule({
+      providers: [
+        UtilsIntentService,
+        { provide: EcoConfigService, useValue: createMock<EcoConfigService>() },
+        {
+          provide: getModelToken(IntentSourceModel.name),
+          useValue: createMock<Model<IntentSourceModel>>(),
+        },
+      ],
+    })
+      .overrideProvider(getQueueToken(QUEUES.SOURCE_INTENT.queue))
+      .useValue(createMock<Queue>())
+      .compile()
+
+    utilsIntentService = chainMod.get(UtilsIntentService)
+    ecoConfigService = chainMod.get(EcoConfigService)
+    intentModel = chainMod.get(getModelToken(IntentSourceModel.name))
+
+    utilsIntentService['logger'].debug = mockLogDebug
+    utilsIntentService['logger'].log = mockLogLog
+    utilsIntentService['logger'].warn = mockLogWarn
+  })
+
+  afterEach(async () => {
+    // restore the spy created with spyOn
+    jest.restoreAllMocks()
+    mockLogDebug.mockClear()
+    mockLogLog.mockClear()
+    mockLogWarn.mockClear()
+    mockDecodeFunctionData.mockClear()
+  })
+
+  describe('on update models', () => {
+    const mockUpdateOne = jest.fn()
+    const model = { intent: { hash: '0x123' } } as any
+    beforeEach(() => {
+      intentModel.updateOne = mockUpdateOne
+    })
+
+    afterEach(() => {
+      mockUpdateOne.mockClear()
+    })
+
+    describe('on updateIntentModel', () => {
+      it('should updateOne model off the intent hash', async () => {
+        await utilsIntentService.updateIntentModel(model)
+        expect(mockUpdateOne).toHaveBeenCalledTimes(1)
+        expect(mockUpdateOne).toHaveBeenCalledWith({ 'intent.hash': model.intent.hash }, model)
+      })
+    })
+
+    describe('on updateInvalidIntentModel', () => {
+      it('should updateOne the model as invalid', async () => {
+        const invalidCause = {
+          supportedProver: false,
+          supportedTargets: true,
+          supportedSelectors: true,
+          validExpirationTime: true,
+          validDestination: true,
+          fulfillOnDifferentChain: true,
+        } as ValidationChecks
+        await utilsIntentService.updateInvalidIntentModel(model, invalidCause)
+        expect(mockUpdateOne).toHaveBeenCalledTimes(1)
+        expect(mockUpdateOne).toHaveBeenCalledWith(
+          { 'intent.hash': model.intent.hash },
+          { ...model, status: 'INVALID', receipt: invalidCause },
+        )
+      })
+    })
+
+    describe('on updateInfeasableIntentModel', () => {
+      it('should updateOne the model as infeasable', async () => {
+        const error = QuoteError.RouteIsInfeasable(10n, 9n)
+        await utilsIntentService.updateInfeasableIntentModel(model, error)
+        expect(mockUpdateOne).toHaveBeenCalledTimes(1)
+        expect(mockUpdateOne).toHaveBeenCalledWith(
+          { 'intent.hash': model.intent.hash },
+          { ...model, status: 'INFEASABLE', receipt: error },
+        )
+      })
+    })
+  })
+
+  // describe('on selectorsSupported', () => {
+  //   it('should return false when target length is 0', async () => {
+  //     const model = { intent: { route: { calls: [] } } } as any
+  //     expect(utilsIntentService.selectorsSupported(model, {} as any)).toBe(false)
+  //     expect(mockLogLog).toHaveBeenCalledTimes(1)
+  //     expect(mockLogLog).toHaveBeenCalledWith({
+  //       msg: 'validateIntent: Target/data invalid',
+  //       intent: model.intent,
+  //     })
+  //   })
+
+  //   it('should return false some target transactions fail to decode', async () => {
+  //     const model = {
+  //       intent: {
+  //         route: {
+  //           calls: [
+  //             { target: address1, data: '0x11' },
+  //             { target: address2, data: '0x22' },
+  //           ],
+  //         },
+  //       },
+  //     } as any
+  //     utilsIntentService.getTransactionTargetData = jest
+  //       .fn()
+  //       .mockImplementation((model, solver, call) => {
+  //         if (call.target === address2) return null
+  //         return { decoded: true }
+  //       })
+  //     expect(utilsIntentService.selectorsSupported(model, {} as any)).toBe(false)
+  //   })
+
+  //   it('should return true when all target transactions decode', async () => {
+  //     const model = {
+  //       intent: {
+  //         route: {
+  //           calls: [
+  //             { target: address1, data: '0x11' },
+  //             { target: address2, data: '0x22' },
+  //           ],
+  //         },
+  //       },
+  //     } as any
+  //     utilsIntentService.getTransactionTargetData = jest.fn().mockReturnValue({ decoded: true })
+  //     expect(utilsIntentService.selectorsSupported(model, {} as any)).toBe(true)
+  //   })
+  // })
+  // describe('on targetsSupported', () => {
+  //   const target = address1
+  //   const target1 = address2
+  //   const targetConfig = { contractType: 'erc20', selectors: [] }
+
+  //   it('should return false if model targets are empty', async () => {
+  //     const model = {
+  //       intent: { route: { calls: [] }, hash: '0x9' },
+  //       event: { sourceNetwork: 'opt-sepolia' },
+  //     } as any
+  //     const solver = { targets: { address1: { contractType: 'erc20', selectors: [] } } }
+  //     expect(utilsIntentService.supportedTargets(model, solver as any)).toBe(false)
+  //     expect(mockLogDebug).toHaveBeenCalledTimes(1)
+  //     expect(mockLogDebug).toHaveBeenCalledWith({
+  //       msg: `Targets not supported for intent ${model.intent.hash}`,
+  //       intentHash: model.intent.hash,
+  //       sourceNetwork: model.event.sourceNetwork,
+  //     })
+  //   })
+
+  //   it('should return false if solver targets are empty', async () => {
+  //     const model = {
+  //       intent: { route: { calls: [{ target, data: '0x' }] }, hash: '0x9' },
+  //       event: { sourceNetwork: 'opt-sepolia' },
+  //     } as any
+  //     const solver = { targets: {} }
+  //     expect(utilsIntentService.supportedTargets(model, solver as any)).toBe(false)
+  //     expect(mockLogDebug).toHaveBeenCalledTimes(1)
+  //     expect(mockLogDebug).toHaveBeenCalledWith({
+  //       msg: `Targets not supported for intent ${model.intent.hash}`,
+  //       intentHash: model.intent.hash,
+  //       sourceNetwork: model.event.sourceNetwork,
+  //     })
+  //   })
+
+  //   it('should return false if solver doesn`t support the targets of the model', async () => {
+  //     const model = {
+  //       intent: { route: { calls: [{ target, data: '0x' }] }, hash: '0x9' },
+  //       event: { sourceNetwork: 'opt-sepolia' },
+  //     } as any
+  //     const solver = { targets: { [target1]: targetConfig } }
+  //     expect(utilsIntentService.supportedTargets(model, solver as any)).toBe(false)
+  //     expect(mockLogDebug).toHaveBeenCalledTimes(1)
+  //     expect(mockLogDebug).toHaveBeenCalledWith({
+  //       msg: `Targets not supported for intent ${model.intent.hash}`,
+  //       intentHash: model.intent.hash,
+  //       sourceNetwork: model.event.sourceNetwork,
+  //     })
+  //   })
+
+  //   it('should return true if model targets are a subset of solver targets', async () => {
+  //     const model = {
+  //       intent: { route: { calls: [{ target, data: '0x' }] }, hash: '0x9' },
+  //       event: { sourceNetwork: 'opt-sepolia' },
+  //     } as any
+  //     const solver = { targets: { [target]: targetConfig, [target1]: targetConfig } }
+  //     expect(utilsIntentService.supportedTargets(model, solver as any)).toBe(true)
+  //   })
+  // })
+
+  describe('on getIntentProcessData', () => {
+    const intentHash = address1
+    const model = {
+      intent: { route: { hash: intentHash, destination: '85432' } },
+      event: { sourceNetwork: 'opt-sepolia' },
+    } as any
+    it('should return undefined if it could not find the model in the db', async () => {
+      intentModel.findOne = jest.fn().mockReturnValue(null)
+      expect(await utilsIntentService.getIntentProcessData(intentHash)).toStrictEqual({
+        err: EcoError.IntentSourceDataNotFound(intentHash),
+        model: null,
+        solver: null,
+      })
+    })
+
+    it('should return undefined if solver could for destination chain could not be found', async () => {
+      intentModel.findOne = jest.fn().mockReturnValue(model)
+      ecoConfigService.getSolver = jest.fn().mockReturnValue(undefined)
+      expect(await utilsIntentService.getIntentProcessData(intentHash)).toBe(undefined)
+      expect(mockLogLog).toHaveBeenCalledTimes(1)
+      expect(mockLogLog).toHaveBeenCalledWith({
+        msg: `No solver found for chain ${model.intent.route.destination}`,
+        intentHash: intentHash,
+        sourceNetwork: model.event.sourceNetwork,
+      })
+    })
+
+    it('should throw an error if model db throws (permissions issue usually)', async () => {
+      const mockLogError = jest.fn()
+      utilsIntentService['logger'].error = mockLogError
+      const err = new Error('DB error')
+      intentModel.findOne = jest.fn().mockRejectedValue(err)
+      expect(await utilsIntentService.getIntentProcessData(intentHash)).toBe(undefined)
+      expect(mockLogError).toHaveBeenCalledTimes(1)
+      expect(mockLogError).toHaveBeenCalledWith({
+        msg: `Error in getIntentProcessData ${intentHash}`,
+        intentHash: intentHash,
+        error: err,
+      })
+    })
+
+    it('should return the model and solver when successful', async () => {
+      intentModel.findOne = jest.fn().mockReturnValue(model)
+      const solver = { chainID: '85432' }
+      ecoConfigService.getSolver = jest.fn().mockReturnValue(solver)
+      expect(await utilsIntentService.getIntentProcessData(intentHash)).toEqual({ model, solver })
+    })
+  })
+
+  describe('on updateOnFulfillment', () => {
+    const fulfillment = {
+      args: {
+        _hash: '0x123',
+        _solver: '0x456',
+        _intent: '0x789',
+        _receipt: '0xabc',
+        _result: '0xdef',
+      },
+    } as any as FulfillmentLog
+    it('should log a warning if no intent exists in the db for the fulfillment hash', async () => {
+      intentModel.findOne = jest.fn().mockReturnValue(undefined)
+      await utilsIntentService.updateOnFulfillment(fulfillment)
+      expect(mockLogWarn).toHaveBeenCalledTimes(1)
+      expect(mockLogWarn).toHaveBeenCalledWith({
+        msg: `Intent not found for fulfillment ${fulfillment.args._hash}`,
+        fulfillment,
+      })
+    })
+
+    it('should update the intent as solved if it exists', async () => {
+      const model = {
+        face: 1,
+        status: 'PENDING',
+      }
+      intentModel.findOne = jest.fn().mockReturnValue(model)
+      await utilsIntentService.updateOnFulfillment(fulfillment)
+      expect(intentModel.updateOne).toHaveBeenCalledTimes(1)
+      expect(intentModel.updateOne).toHaveBeenCalledWith(
+        { 'intent.hash': fulfillment.args._hash },
+        { ...model, status: 'SOLVED' },
+      )
+    })
+  })
+})

package/src/intent/tests/utils.spec.ts

@@ -0,0 +1,62 @@
+const mockDecodeFunctionData = jest.fn()
+import { EcoError } from '@/common/errors/eco-error'
+import { getFunctionBytes } from '@/common/viem/contracts'
+import { CallDataInterface } from '@/contracts'
+import { getTransactionTargetData } from '@/intent/utils'
+
+jest.mock('viem', () => {
+  return {
+    ...jest.requireActual('viem'),
+    decodeFunctionData: mockDecodeFunctionData,
+  }
+})
+
+const address1 = '0x1111111111111111111111111111111111111111'
+describe('utils tests', () => {
+  describe('on getTransactionTargetData', () => {
+    const callData: CallDataInterface = { target: address1, data: '0xa9059cbb3333333', value: 0n } //transfer selector plus data fake
+    const selectors = ['transfer(address,uint256)']
+    const targetConfig = { contractType: 'erc20', selectors }
+    const decodedData = { stuff: true }
+
+    it('should throw when no target config exists on solver', async () => {
+      const solver = { targets: {} }
+      expect(() => getTransactionTargetData(solver as any, callData)).toThrow(
+        EcoError.IntentSourceTargetConfigNotFound(callData.target as string),
+      )
+    })
+
+    it('should return null when tx is not decoded ', async () => {
+      mockDecodeFunctionData.mockReturnValue(null)
+      expect(
+        getTransactionTargetData(
+          { targets: { [address1]: { contractType: 'erc20', selectors } } } as any,
+          callData,
+        ),
+      ).toBe(null)
+    })
+
+    it('should return null when target selector is not supported by the solver', async () => {
+      const fakeData = '0xaaaaaaaa11112333'
+      const call: CallDataInterface = { target: callData.target, data: fakeData, value: 0n }
+      mockDecodeFunctionData.mockReturnValue(decodedData)
+      expect(
+        getTransactionTargetData(
+          { targets: { [address1]: { contractType: 'erc20', selectors } } } as any,
+          call,
+        ),
+      ).toBe(null)
+    })
+
+    it('should return the decoded function data, selctor and target config when successful', async () => {
+      mockDecodeFunctionData.mockReturnValue(decodedData)
+      expect(
+        getTransactionTargetData({ targets: { [address1]: targetConfig } } as any, callData),
+      ).toEqual({
+        decodedFunctionData: decodedData,
+        selector: getFunctionBytes(callData.data),
+        targetConfig,
+      })
+    })
+  })
+})

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

@@ -0,0 +1,297 @@
+const mockGetIntentJobId = jest.fn()
+import { createMock, DeepMocked } from '@golevelup/ts-jest'
+import { EcoConfigService } from '../../eco-configs/eco-config.service'
+import { Test, TestingModule } from '@nestjs/testing'
+import { getModelToken } from '@nestjs/mongoose'
+import { IntentSourceModel } from '../schemas/intent-source.schema'
+import { Model } from 'mongoose'
+import { ValidateIntentService } from '../validate-intent.service'
+import { UtilsIntentService } from '../utils-intent.service'
+import { BullModule, getQueueToken } from '@nestjs/bullmq'
+import { QUEUES } from '../../common/redis/constants'
+import { Queue } from 'bullmq'
+import { ValidationService } from '@/intent/validation.sevice'
+import { zeroHash } from 'viem'
+import { MultichainPublicClientService } from '@/transaction/multichain-public-client.service'
+import { EcoError } from '@/common/errors/eco-error'
+
+jest.mock('../../common/utils/strings', () => {
+  return {
+    ...jest.requireActual('../../common/utils/strings'),
+    getIntentJobId: mockGetIntentJobId,
+  }
+})
+
+describe('ValidateIntentService', () => {
+  let validateIntentService: ValidateIntentService
+  let validationService: DeepMocked<ValidationService>
+  let multichainPublicClientService: DeepMocked<MultichainPublicClientService>
+  let utilsIntentService: DeepMocked<UtilsIntentService>
+  let ecoConfigService: DeepMocked<EcoConfigService>
+  let queue: DeepMocked<Queue>
+  const mockLogDebug = jest.fn()
+  const mockLog = jest.fn()
+  const mockLogError = jest.fn()
+
+  beforeEach(async () => {
+    const chainMod: TestingModule = await Test.createTestingModule({
+      providers: [
+        ValidateIntentService,
+        {
+          provide: UtilsIntentService,
+          useValue: createMock<UtilsIntentService>(),
+        },
+        { provide: ValidationService, useValue: createMock<ValidationService>() },
+        {
+          provide: MultichainPublicClientService,
+          useValue: createMock<MultichainPublicClientService>(),
+        },
+        { provide: UtilsIntentService, useValue: createMock<UtilsIntentService>() },
+        { provide: EcoConfigService, useValue: createMock<EcoConfigService>() },
+        {
+          provide: getModelToken(IntentSourceModel.name),
+          useValue: createMock<Model<IntentSourceModel>>(),
+        },
+      ],
+      imports: [
+        BullModule.registerQueue({
+          name: QUEUES.SOURCE_INTENT.queue,
+        }),
+      ],
+    })
+      .overrideProvider(getQueueToken(QUEUES.SOURCE_INTENT.queue))
+      .useValue(createMock<Queue>())
+      .compile()
+
+    validateIntentService = chainMod.get(ValidateIntentService)
+    validationService = chainMod.get(ValidationService)
+    multichainPublicClientService = chainMod.get(MultichainPublicClientService)
+    utilsIntentService = chainMod.get(UtilsIntentService)
+    ecoConfigService = chainMod.get(EcoConfigService)
+    queue = chainMod.get(getQueueToken(QUEUES.SOURCE_INTENT.queue))
+
+    validateIntentService['logger'].debug = mockLogDebug
+    validateIntentService['logger'].log = mockLog
+    validateIntentService['logger'].error = mockLogError
+  })
+
+  afterEach(async () => {
+    // restore the spy created with spyOn
+    jest.resetAllMocks()
+  })
+
+  describe('on module init', () => {
+    it('should set the intentJobConfig', () => {
+      const config = { a: 1 } as any
+      ecoConfigService.getRedis = jest
+        .fn()
+        .mockReturnValueOnce({ jobs: { intentJobConfig: config } })
+      validateIntentService.onModuleInit()
+      expect(validateIntentService['intentJobConfig']).toEqual(config)
+    })
+  })
+
+  describe('on destructureIntent', () => {
+    it('should throw if get intent returns no data', async () => {
+      utilsIntentService.getIntentProcessData.mockResolvedValueOnce(undefined)
+      await expect(validateIntentService['destructureIntent'](zeroHash)).rejects.toThrow(
+        'Desctructuring the intent from the intent hash failed',
+      )
+    })
+
+    it('should throw if solver is undefined', async () => {
+      utilsIntentService.getIntentProcessData.mockResolvedValueOnce({ model: {} } as any)
+      await expect(validateIntentService['destructureIntent'](zeroHash)).rejects.toThrow(
+        'Desctructuring the intent from the intent hash failed',
+      )
+    })
+
+    it('should throw if model is undefined', async () => {
+      utilsIntentService.getIntentProcessData.mockResolvedValueOnce({ solver: {} } as any)
+      await expect(validateIntentService['destructureIntent'](zeroHash)).rejects.toThrow(
+        'Desctructuring the intent from the intent hash failed',
+      )
+    })
+
+    it('should throw error if its returned', async () => {
+      const msg = 'Error from getIntentProcessData'
+      utilsIntentService.getIntentProcessData.mockResolvedValueOnce({
+        err: new Error(msg),
+      } as any)
+      await expect(validateIntentService['destructureIntent'](zeroHash)).rejects.toThrow('Error')
+    })
+
+    it('should throw generic error if no error returned', async () => {
+      utilsIntentService.getIntentProcessData.mockResolvedValueOnce({} as any)
+      await expect(validateIntentService['destructureIntent'](zeroHash)).rejects.toThrow(
+        'Desctructuring the intent from the intent hash failed',
+      )
+    })
+
+    it('should succeed and return data', async () => {
+      const dataIn = { model: {}, solver: {} } as any
+      utilsIntentService.getIntentProcessData.mockResolvedValueOnce(dataIn)
+      const dataOut = await validateIntentService['destructureIntent'](zeroHash)
+      expect(dataOut).toBe(dataIn)
+    })
+  })
+
+  describe('on validateIntent entrypoint', () => {
+    it('should log when entering function and return on failed destructure', async () => {
+      const intentHash = '0x1'
+      validateIntentService['destructureIntent'] = jest
+        .fn()
+        .mockReturnValueOnce({ model: undefined, solver: undefined })
+      expect(await validateIntentService.validateIntent(intentHash)).toBe(false)
+      expect(mockLogDebug).toHaveBeenCalledTimes(1)
+      expect(mockLogDebug).toHaveBeenCalledWith({ msg: `validateIntent ${intentHash}`, intentHash })
+    })
+
+    it('should return on failed assertions', async () => {
+      const intentHash = '0x1'
+      validateIntentService['destructureIntent'] = jest
+        .fn()
+        .mockReturnValueOnce({ model: {}, solver: {} })
+      validateIntentService['assertValidations'] = jest.fn().mockReturnValueOnce(false)
+      expect(await validateIntentService.validateIntent(intentHash)).toBe(false)
+      expect(mockLogDebug).toHaveBeenCalledTimes(1)
+    })
+
+    it('should log, create a job and enque it', async () => {
+      const intentHash = '0x1'
+      const model = { intent: { logIndex: 10 } }
+      const config = { a: 1 } as any
+      validateIntentService['destructureIntent'] = jest
+        .fn()
+        .mockReturnValueOnce({ model, solver: {} })
+      validateIntentService['assertValidations'] = jest.fn().mockReturnValueOnce(true)
+      validateIntentService['intentJobConfig'] = config
+      const mockAddQueue = jest.fn()
+      queue.add = mockAddQueue
+      const jobId = 'validate-asdf-0'
+      mockGetIntentJobId.mockReturnValueOnce(jobId)
+      expect(await validateIntentService.validateIntent(intentHash)).toBe(true)
+      expect(mockGetIntentJobId).toHaveBeenCalledTimes(1)
+      expect(mockAddQueue).toHaveBeenCalledTimes(1)
+      expect(mockLogDebug).toHaveBeenCalledTimes(2)
+      expect(mockGetIntentJobId).toHaveBeenCalledWith('validate', intentHash, model.intent.logIndex)
+      expect(mockAddQueue).toHaveBeenCalledWith(
+        QUEUES.SOURCE_INTENT.jobs.feasable_intent,
+        intentHash,
+        {
+          jobId,
+          ...validateIntentService['intentJobConfig'],
+        },
+      )
+      expect(mockLogDebug).toHaveBeenCalledWith({
+        msg: `validateIntent ${intentHash}`,
+        intentHash,
+        jobId,
+      })
+    })
+  })
+
+  describe('on assertValidations', () => {
+    const model = { intent: { hash: '0x12' } } as any
+    const solver = {} as any
+    const validations = { isIntentFunded: false, supportedSelectors: true } as any
+    const validValidations = { isIntentFunded: true, supportedSelectors: true } as any
+    let mockValidations: jest.Mock
+    let mockIntentFunded: jest.Mock
+    let mockUpdateModel: jest.Mock
+
+    beforeEach(() => {
+      mockValidations = jest.fn().mockResolvedValueOnce(validations)
+      mockIntentFunded = jest.fn().mockResolvedValueOnce(true)
+      mockUpdateModel = jest.fn()
+
+      validationService.assertValidations = mockValidations
+      validateIntentService.intentFunded = mockIntentFunded
+      utilsIntentService.updateInvalidIntentModel = mockUpdateModel
+    })
+
+    it('should return false if ValidationService is false', async () => {
+      expect(await validateIntentService.assertValidations(model, solver)).toBe(false)
+      expect(mockValidations).toHaveBeenCalledTimes(1)
+      expect(mockIntentFunded).toHaveBeenCalledTimes(1)
+      expect(mockUpdateModel).toHaveBeenCalledTimes(1)
+      expect(mockLog).toHaveBeenCalledTimes(1)
+      expect(mockLog).toHaveBeenCalledWith({
+        msg: EcoError.IntentValidationFailed(model.intent.hash).message,
+        model,
+        validations,
+      })
+      expect(mockUpdateModel).toHaveBeenCalledWith(model, validations)
+    })
+
+    it('should return false if intentFunded returns false', async () => {
+      mockValidations = jest.fn().mockResolvedValueOnce(validValidations)
+      mockIntentFunded = jest.fn().mockResolvedValueOnce(false)
+      validationService.assertValidations = mockValidations
+      validateIntentService.intentFunded = mockIntentFunded
+
+      expect(await validateIntentService.assertValidations(model, solver)).toBe(false)
+      expect(mockValidations).toHaveBeenCalledTimes(1)
+      expect(mockIntentFunded).toHaveBeenCalledTimes(1)
+      expect(mockUpdateModel).toHaveBeenCalledTimes(1)
+      expect(mockLog).toHaveBeenCalledTimes(1)
+      expect(mockLog).toHaveBeenCalledWith({
+        msg: EcoError.IntentValidationFailed(model.intent.hash).message,
+        model,
+        validations: validValidations,
+      })
+      expect(mockUpdateModel).toHaveBeenCalledWith(model, validValidations)
+    })
+
+    it('should return true if intentFunded and ValidationService are all true ', async () => {
+      mockValidations = jest.fn().mockResolvedValueOnce(validValidations)
+      mockIntentFunded = jest.fn().mockResolvedValueOnce(true)
+      validationService.assertValidations = mockValidations
+      validateIntentService.intentFunded = mockIntentFunded
+
+      expect(await validateIntentService.assertValidations(model, solver)).toBe(true)
+      expect(mockValidations).toHaveBeenCalledTimes(1)
+      expect(mockIntentFunded).toHaveBeenCalledTimes(1)
+      expect(mockUpdateModel).toHaveBeenCalledTimes(0)
+      expect(mockLog).toHaveBeenCalledTimes(0)
+    })
+  })
+
+  describe('on intentFunded', () => {
+    const chainID = 1
+    const model = { intent: { hash: '0x12', route: { source: chainID } } } as any
+
+    it('should return false if no intentSource for intent', async () => {
+      jest.spyOn(ecoConfigService, 'getIntentSource').mockReturnValue(undefined)
+
+      expect(await validateIntentService.intentFunded(model)).toBe(false)
+      expect(mockLogError).toHaveBeenCalledTimes(1)
+      expect(mockLogError).toHaveBeenCalledWith({
+        msg: EcoError.IntentSourceNotFound(chainID).message,
+        model,
+      })
+    })
+
+    it('should return false if isIntentFunded contract call returns false', async () => {
+      jest.spyOn(ecoConfigService, 'getIntentSource').mockReturnValue({ face: 'face' } as any)
+      const mockRead = jest.fn().mockReturnValue(false)
+      const client = { readContract: mockRead }
+      multichainPublicClientService.getClient = jest.fn().mockReturnValue(client)
+
+      expect(await validateIntentService.intentFunded(model)).toBe(false)
+      expect(mockLogError).toHaveBeenCalledTimes(0)
+      expect(mockRead).toHaveBeenCalledTimes(1)
+    })
+
+    it('should return true if isIntentFunded contract call returns true', async () => {
+      jest.spyOn(ecoConfigService, 'getIntentSource').mockReturnValue({ face: 'face' } as any)
+      const mockRead = jest.fn().mockReturnValue(true)
+      const client = { readContract: mockRead }
+      multichainPublicClientService.getClient = jest.fn().mockReturnValue(client)
+
+      expect(await validateIntentService.intentFunded(model)).toBe(true)
+      expect(mockLogError).toHaveBeenCalledTimes(0)
+      expect(mockRead).toHaveBeenCalledTimes(1)
+    })
+  })
+})