eco-solver 0.0.1-security → 1.5.1

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

@@ -0,0 +1,215 @@
+const mockDecodeCreateIntentLog = 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 { BullModule, getQueueToken } from '@nestjs/bullmq'
+import { QUEUES } from '../../common/redis/constants'
+import { Queue } from 'bullmq'
+import { CreateIntentService } from '../create-intent.service'
+import { ValidSmartWalletService } from '../../solver/filters/valid-smart-wallet.service'
+import { IntentDataModel } from '../schemas/intent-data.schema'
+import { FlagService } from '../../flags/flags.service'
+
+jest.mock('../../contracts', () => {
+  return {
+    ...jest.requireActual('../../contracts'),
+    decodeCreateIntentLog: mockDecodeCreateIntentLog,
+  }
+})
+
+describe('CreateIntentService', () => {
+  let createIntentService: CreateIntentService
+  let validSmartWalletService: DeepMocked<ValidSmartWalletService>
+  let flagService: DeepMocked<FlagService>
+  let ecoConfigService: DeepMocked<EcoConfigService>
+  let intentSourceModel: DeepMocked<Model<IntentSourceModel>>
+  let queue: DeepMocked<Queue>
+  const mockLogDebug = jest.fn()
+  const mockLogLog = jest.fn()
+
+  beforeEach(async () => {
+    const chainMod: TestingModule = await Test.createTestingModule({
+      providers: [
+        CreateIntentService,
+        { provide: ValidSmartWalletService, useValue: createMock<ValidSmartWalletService>() },
+        { provide: FlagService, useValue: createMock<FlagService>() },
+        { 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()
+    //turn off the services from logging durring testing
+    chainMod.useLogger(false)
+
+    createIntentService = chainMod.get(CreateIntentService)
+    validSmartWalletService = chainMod.get(ValidSmartWalletService)
+    flagService = chainMod.get(FlagService)
+    ecoConfigService = chainMod.get(EcoConfigService)
+    intentSourceModel = chainMod.get(getModelToken(IntentSourceModel.name))
+    queue = chainMod.get(getQueueToken(QUEUES.SOURCE_INTENT.queue))
+
+    createIntentService['logger'].debug = mockLogDebug
+    createIntentService['logger'].log = mockLogLog
+  })
+
+  afterEach(async () => {
+    // restore the spy created with spyOn
+    jest.restoreAllMocks()
+    mockLogDebug.mockClear()
+    mockLogLog.mockClear()
+  })
+
+  describe('on createIntent', () => {
+    const mockEvent = {
+      creator: '0xaaa',
+      data: '0xda',
+      transactionHash: '0x123',
+      topics: ['0x456'],
+      sourceChainID: 85432,
+    }
+    const mockIntent = {
+      reward: { creator: '0xaaa' },
+      hash: mockEvent.transactionHash,
+      logIndex: 1,
+    }
+    beforeEach(() => {
+      mockDecodeCreateIntentLog.mockReturnValue({ hash: mockEvent.transactionHash })
+      const mockIntentSourceEvent = jest.fn()
+      IntentDataModel.fromEvent = mockIntentSourceEvent
+      mockIntentSourceEvent.mockReturnValue(mockIntent)
+    })
+
+    it('should decode the event', async () => {
+      createIntentService.createIntent(mockEvent as any)
+      expect(mockLogDebug).toHaveBeenCalledWith({
+        msg: `createIntent ${mockEvent.transactionHash}`,
+        intentHash: mockEvent.transactionHash,
+      })
+      expect(mockDecodeCreateIntentLog).toHaveBeenCalledWith(mockEvent.data, mockEvent.topics)
+    })
+
+    it('should return if model has already been created in db', async () => {
+      const mockFindOne = jest.fn().mockReturnValue({ hash: mockEvent.transactionHash })
+      intentSourceModel.findOne = mockFindOne
+      await createIntentService.createIntent(mockEvent as any)
+      expect(mockFindOne).toHaveBeenCalledWith({ 'intent.hash': mockEvent.transactionHash })
+      expect(mockLogDebug).toHaveBeenNthCalledWith(2, {
+        msg: `Record for intent already exists ${mockEvent.transactionHash}`,
+        intentHash: mockIntent.hash,
+        intent: mockIntent,
+      })
+      expect(validSmartWalletService.validateSmartWallet).not.toHaveBeenCalled()
+    })
+
+    it('should check if the bendWalletOnly flag is up', async () => {
+      const mockFindOne = jest.fn().mockReturnValue(undefined)
+      intentSourceModel.findOne = mockFindOne
+      const mockFlag = jest.spyOn(flagService, 'getFlagValue').mockReturnValue(false)
+      const mockValidateSmartWallet = jest.fn().mockReturnValue(true)
+      validSmartWalletService.validateSmartWallet = mockValidateSmartWallet
+      await createIntentService.createIntent(mockEvent as any)
+      expect(mockFlag).toHaveBeenCalledTimes(1)
+      expect(mockValidateSmartWallet).toHaveBeenCalledTimes(0)
+    })
+
+    it('should validate the intent is from a bend wallet', async () => {
+      const mockFindOne = jest.fn().mockReturnValue(undefined)
+      intentSourceModel.findOne = mockFindOne
+      const mockValidateSmartWallet = jest.fn().mockReturnValue(true)
+      jest.spyOn(flagService, 'getFlagValue').mockReturnValue(true)
+      validSmartWalletService.validateSmartWallet = mockValidateSmartWallet
+      await createIntentService.createIntent(mockEvent as any)
+      expect(mockValidateSmartWallet).toHaveBeenCalledTimes(1)
+      expect(mockValidateSmartWallet).toHaveBeenCalledWith(
+        mockIntent.reward.creator,
+        mockEvent.sourceChainID,
+      )
+    })
+
+    it('should create an intent model in the database', async () => {
+      const mockFindOne = jest.fn().mockReturnValue(undefined)
+      intentSourceModel.findOne = mockFindOne
+      const mockValidateSmartWallet = jest.fn().mockReturnValue(true)
+      jest.spyOn(flagService, 'getFlagValue').mockReturnValue(true)
+      validSmartWalletService.validateSmartWallet = mockValidateSmartWallet
+      const mockCreate = jest.fn()
+      intentSourceModel.create = mockCreate
+      await createIntentService.createIntent(mockEvent as any)
+      expect(mockCreate).toHaveBeenCalledWith({
+        event: mockEvent,
+        intent: mockIntent,
+        receipt: null,
+        status: 'PENDING',
+      })
+
+      mockCreate.mockClear()
+      mockValidateSmartWallet.mockResolvedValueOnce(false)
+      await createIntentService.createIntent(mockEvent as any)
+      expect(mockCreate).toHaveBeenCalledWith({
+        event: mockEvent,
+        intent: mockIntent,
+        receipt: null,
+        status: 'NON-BEND-WALLET',
+      })
+    })
+
+    it('should not enqueue a job if the intent is not from a bend wallet', async () => {
+      const mockFindOne = jest.fn().mockReturnValue(undefined)
+      const mockQueueAdd = jest.fn()
+      intentSourceModel.findOne = mockFindOne
+      intentSourceModel.create = jest.fn().mockReturnValue({ intent: mockIntent })
+      queue.add = mockQueueAdd
+      jest.spyOn(flagService, 'getFlagValue').mockReturnValue(true)
+      validSmartWalletService.validateSmartWallet = jest.fn().mockReturnValue(false)
+
+      await createIntentService.createIntent(mockEvent as any)
+      expect(mockQueueAdd).not.toHaveBeenCalled()
+      expect(mockLogLog).toHaveBeenNthCalledWith(1, {
+        msg: `Recorded intent ${mockEvent.transactionHash}`,
+        intentHash: mockIntent.hash,
+        intent: mockIntent,
+        validWallet: false,
+      })
+    })
+
+    it('should enqueue a job if the intent is from a bend wallet', async () => {
+      const mockFindOne = jest.fn().mockReturnValue(undefined)
+      const mockQueueAdd = jest.fn()
+      intentSourceModel.findOne = mockFindOne
+      intentSourceModel.create = jest.fn().mockReturnValue({ intent: mockIntent })
+      queue.add = mockQueueAdd
+      jest.spyOn(flagService, 'getFlagValue').mockReturnValue(true)
+      validSmartWalletService.validateSmartWallet = jest.fn().mockReturnValue(true)
+
+      const jobId = `create-${mockIntent.hash}-${mockIntent.logIndex}`
+      await createIntentService.createIntent(mockEvent as any)
+      expect(mockQueueAdd).toHaveBeenCalledTimes(1)
+      expect(mockQueueAdd).toHaveBeenCalledWith(
+        QUEUES.SOURCE_INTENT.jobs.validate_intent,
+        mockIntent.hash,
+        { jobId },
+      )
+
+      expect(mockLogLog).toHaveBeenNthCalledWith(1, {
+        msg: `Recorded intent ${mockEvent.transactionHash}`,
+        intentHash: mockIntent.hash,
+        intent: mockIntent,
+        validWallet: true,
+        jobId,
+      })
+    })
+  })
+})

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

@@ -0,0 +1,155 @@
+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 { BullModule, getQueueToken } from '@nestjs/bullmq'
+import { QUEUES } from '../../common/redis/constants'
+import { Queue } from 'bullmq'
+import { FeasableIntentService } from '../feasable-intent.service'
+import { Hex } from 'viem'
+import { FeeService } from '@/fee/fee.service'
+import { QuoteError } from '@/quote/errors'
+
+describe('FeasableIntentService', () => {
+  let feasableIntentService: FeasableIntentService
+  let feeService: DeepMocked<FeeService>
+  let utilsIntentService: DeepMocked<UtilsIntentService>
+  let ecoConfigService: DeepMocked<EcoConfigService>
+  let queue: DeepMocked<Queue>
+  const mockLogDebug = jest.fn()
+  const mockLogLog = jest.fn()
+  const mockLogError = jest.fn()
+  const address1 = '0x1111111111111111111111111111111111111111'
+  const address2 = '0x2222222222222222222222222222222222222222'
+  beforeEach(async () => {
+    const chainMod: TestingModule = await Test.createTestingModule({
+      providers: [
+        FeasableIntentService,
+        { provide: FeeService, useValue: createMock<FeeService>() },
+        { 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()
+
+    feasableIntentService = chainMod.get(FeasableIntentService)
+    feeService = chainMod.get(FeeService)
+    utilsIntentService = chainMod.get(UtilsIntentService)
+    ecoConfigService = chainMod.get(EcoConfigService)
+    queue = chainMod.get(getQueueToken(QUEUES.SOURCE_INTENT.queue))
+
+    feasableIntentService['logger'].debug = mockLogDebug
+    feasableIntentService['logger'].log = mockLogLog
+    feasableIntentService['logger'].error = mockLogError
+  })
+
+  const mockData = { model: { intent: { logIndex: 1, hash: '0x123' as Hex } }, solver: {} }
+  const intentHash = mockData.model.intent.hash
+  const jobId = `feasable-${intentHash}-${mockData.model.intent.logIndex}`
+  afterEach(async () => {
+    // restore the spy created with spyOn
+    jest.restoreAllMocks()
+    mockLogDebug.mockClear()
+    mockLogLog.mockClear()
+  })
+
+  describe('onModuleInit', () => {
+    it('should set the intentJobConfig', async () => {
+      const mockConfig = { foo: 'bar' }
+      jest
+        .spyOn(ecoConfigService, 'getRedis')
+        .mockReturnValue({ jobs: { intentJobConfig: mockConfig } } as any)
+      await feasableIntentService.onModuleInit()
+      expect(feasableIntentService['intentJobConfig']).toEqual(mockConfig)
+    })
+  })
+
+  describe('on feasableIntent', () => {
+    it('should error out if processing intent data fails', async () => {
+      jest.spyOn(utilsIntentService, 'getIntentProcessData').mockResolvedValue(undefined)
+      await expect(feasableIntentService.feasableIntent(intentHash)).resolves.not.toThrow()
+
+      const error = new Error('noo')
+      jest
+        .spyOn(utilsIntentService, 'getIntentProcessData')
+        .mockResolvedValue({ err: error } as any)
+      await expect(feasableIntentService.feasableIntent(intentHash)).rejects.toThrow(error)
+    })
+
+    it('should fail if intent has more than 1 target call', async () => {
+      const mockModel = {
+        intent: {
+          route: {
+            calls: [
+              { data: '0x', target: address1 },
+              { data: '0x', target: address2 },
+            ],
+          },
+          logIndex: 1,
+        },
+      }
+      const errData = { solver: mockData.solver, model: mockModel } as any
+      jest.spyOn(utilsIntentService, 'getIntentProcessData').mockResolvedValue(errData)
+      jest.spyOn(feeService, 'isRouteFeasible').mockResolvedValue({
+        error: QuoteError.MultiFulfillRoute(),
+      } as any)
+      await feasableIntentService.feasableIntent(intentHash)
+      expect(utilsIntentService.updateInfeasableIntentModel).toHaveBeenCalledWith(
+        errData.model,
+        QuoteError.MultiFulfillRoute(),
+      )
+      expect(mockLogDebug).toHaveBeenCalledTimes(2)
+      expect(mockLogDebug).toHaveBeenNthCalledWith(2, {
+        msg: `FeasableIntent intent ${intentHash}`,
+        feasable: false,
+      })
+      expect(queue.add).not.toHaveBeenCalled()
+    })
+
+    it('should update the db intent model if the intent is not feasable', async () => {
+      jest.spyOn(utilsIntentService, 'getIntentProcessData').mockResolvedValue(mockData as any)
+      jest
+        .spyOn(feeService, 'isRouteFeasible')
+        .mockResolvedValue({ error: QuoteError.MultiFulfillRoute() })
+
+      await feasableIntentService.feasableIntent(intentHash)
+
+      expect(utilsIntentService.updateInfeasableIntentModel).toHaveBeenCalledWith(
+        mockData.model,
+        QuoteError.MultiFulfillRoute(),
+      )
+    })
+
+    it('should add the intent when its feasable to the queue to be processed', async () => {
+      jest.spyOn(utilsIntentService, 'getIntentProcessData').mockResolvedValue(mockData as any)
+      jest.spyOn(feeService, 'isRouteFeasible').mockResolvedValue({ calls: [] } as any)
+
+      await feasableIntentService.feasableIntent(intentHash)
+
+      expect(mockLogDebug).toHaveBeenCalledTimes(2)
+      expect(mockLogDebug).toHaveBeenNthCalledWith(2, {
+        msg: `FeasableIntent intent ${intentHash}`,
+        feasable: true,
+        jobId,
+      })
+      expect(queue.add).toHaveBeenCalledWith(QUEUES.SOURCE_INTENT.jobs.fulfill_intent, intentHash, {
+        jobId,
+        ...feasableIntentService['intentJobConfig'],
+      })
+    })
+  })
+})