eco-solver 0.0.1-security → 1.5.1

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

@@ -0,0 +1,257 @@
+import { QUEUES } from '@/common/redis/constants'
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import { WatchCreateIntentService } from '@/watch/intent/watch-create-intent.service'
+import { createMock, DeepMocked } from '@golevelup/ts-jest'
+import { BullModule, getQueueToken } from '@nestjs/bullmq'
+import { Test, TestingModule } from '@nestjs/testing'
+import { Job, Queue } from 'bullmq'
+import { EcoError } from '@/common/errors/eco-error'
+import { MultichainPublicClientService } from '@/transaction/multichain-public-client.service'
+import { serialize } from '@/liquidity-manager/utils/serialize'
+import { IntentCreatedLog } from '@/contracts'
+
+describe('WatchIntentService', () => {
+  let watchIntentService: WatchCreateIntentService
+  let publicClientService: DeepMocked<MultichainPublicClientService>
+  let ecoConfigService: DeepMocked<EcoConfigService>
+  let queue: DeepMocked<Queue>
+  const mockLogDebug = jest.fn()
+  const mockLogLog = jest.fn()
+  const mockLogError = jest.fn()
+
+  const sources = [
+    { chainID: 1n, sourceAddress: '0x1234', provers: ['0x88'], network: 'testnet1' },
+    { chainID: 2n, sourceAddress: '0x5678', provers: ['0x88', '0x99'], network: 'testnet2' },
+  ] as any
+  const supportedChains = sources.map((s) => BigInt(s.chainID))
+
+  beforeEach(async () => {
+    const chainMod: TestingModule = await Test.createTestingModule({
+      providers: [
+        WatchCreateIntentService,
+        {
+          provide: MultichainPublicClientService,
+          useValue: createMock<MultichainPublicClientService>(),
+        },
+        { provide: EcoConfigService, useValue: createMock<EcoConfigService>() },
+      ],
+      imports: [
+        BullModule.registerQueue({
+          name: QUEUES.SOURCE_INTENT.queue,
+        }),
+      ],
+    })
+      .overrideProvider(getQueueToken(QUEUES.SOURCE_INTENT.queue))
+      .useValue(createMock<Queue>())
+      .compile()
+
+    watchIntentService = chainMod.get(WatchCreateIntentService)
+    publicClientService = chainMod.get(MultichainPublicClientService)
+    ecoConfigService = chainMod.get(EcoConfigService)
+    queue = chainMod.get(getQueueToken(QUEUES.SOURCE_INTENT.queue))
+
+    watchIntentService['logger'].debug = mockLogDebug
+    watchIntentService['logger'].log = mockLogLog
+    watchIntentService['logger'].error = mockLogError
+  })
+
+  afterEach(async () => {
+    // restore the spy created with spyOn
+    jest.restoreAllMocks()
+    mockLogDebug.mockClear()
+    mockLogLog.mockClear()
+  })
+
+  describe('on lifecycle', () => {
+    describe('on startup', () => {
+      it('should subscribe to nothing if no source intents', async () => {
+        const mock = jest.spyOn(watchIntentService, 'subscribe')
+        await watchIntentService.onApplicationBootstrap()
+        expect(mock).toHaveBeenCalledTimes(1)
+      })
+
+      it('should subscribe to all source intents', async () => {
+        const mockWatch = jest.fn()
+        publicClientService.getClient.mockResolvedValue({
+          watchContractEvent: mockWatch,
+        } as any)
+        ecoConfigService.getIntentSources.mockReturnValue(sources)
+        ecoConfigService.getSolvers.mockReturnValue(sources)
+        await watchIntentService.onApplicationBootstrap()
+        expect(mockWatch).toHaveBeenCalledTimes(2)
+
+        for (const [index, s] of sources.entries()) {
+          const { address, eventName, args } = mockWatch.mock.calls[index][0]
+          const partial = { address, eventName, args }
+          expect(partial).toEqual({
+            address: s.sourceAddress,
+            eventName: 'IntentCreated',
+            args: { prover: s.provers },
+          })
+        }
+      })
+    })
+
+    describe('on destroy', () => {
+      it('should unsubscribe to nothing if no source intents', async () => {
+        const mock = jest.spyOn(watchIntentService, 'unsubscribe')
+        await watchIntentService.onModuleDestroy()
+        expect(mock).toHaveBeenCalledTimes(1)
+      })
+
+      it('should unsubscribe to all source intents', async () => {
+        const mockUnwatch = jest.fn()
+        publicClientService.getClient.mockResolvedValue({
+          watchContractEvent: () => mockUnwatch,
+        } as any)
+        ecoConfigService.getIntentSources.mockReturnValue(sources)
+        ecoConfigService.getSolvers.mockReturnValue(sources)
+        await watchIntentService.onApplicationBootstrap()
+        await watchIntentService.onModuleDestroy()
+        expect(mockUnwatch).toHaveBeenCalledTimes(2)
+      })
+    })
+  })
+
+  describe('on intent', () => {
+    const s = sources[0]
+    const log: any = { logIndex: 2, args: { hash: '0x1' } as Partial<IntentCreatedLog['args']> }
+    let mockQueueAdd: jest.SpyInstance<Promise<Job<any, any, string>>>
+
+    beforeEach(async () => {
+      mockQueueAdd = jest.spyOn(queue, 'add')
+      await watchIntentService.addJob(s)([log])
+      expect(mockLogDebug).toHaveBeenCalledTimes(1)
+    })
+    it('should convert all bigints to strings', async () => {
+      expect(mockLogDebug.mock.calls[0][0].createIntent).toEqual(
+        expect.objectContaining(serialize(log)),
+      )
+    })
+
+    it('should should attach source chainID and network', async () => {
+      expect(mockLogDebug.mock.calls[0][0].createIntent).toEqual(
+        expect.objectContaining(
+          serialize({
+            sourceChainID: s.chainID,
+            sourceNetwork: s.network,
+          }),
+        ),
+      )
+    })
+
+    it('should should enque a job for every intent', async () => {
+      expect(mockQueueAdd).toHaveBeenCalledTimes(1)
+      expect(mockQueueAdd).toHaveBeenCalledWith(
+        QUEUES.SOURCE_INTENT.jobs.create_intent,
+        expect.any(Object),
+        { jobId: 'watch-create-intent-0x1-2' },
+      )
+    })
+  })
+
+  describe('on unsubscribe', () => {
+    let mockUnwatch1: jest.Mock = jest.fn()
+    let mockUnwatch2: jest.Mock = jest.fn()
+    beforeEach(async () => {
+      mockUnwatch1 = jest.fn()
+      mockUnwatch2 = jest.fn()
+      watchIntentService['unwatch'] = {
+        1: mockUnwatch1,
+        2: mockUnwatch2,
+      }
+    })
+
+    afterEach(async () => {
+      jest.clearAllMocks()
+    })
+
+    it('should unsubscribe to every unwatch and catch any throws', async () => {
+      const e = new Error('test')
+      mockUnwatch1.mockImplementation(() => {
+        throw e
+      })
+      await watchIntentService.unsubscribe()
+      expect(mockUnwatch1).toHaveBeenCalledTimes(1)
+      expect(mockUnwatch2).toHaveBeenCalledTimes(1)
+      expect(mockLogError).toHaveBeenCalledTimes(1)
+      expect(mockLogError).toHaveBeenCalledWith({
+        msg: 'watch-event: unsubscribe',
+        error: EcoError.WatchEventUnsubscribeError.toString(),
+        errorPassed: e,
+      })
+    })
+
+    it('should unsubscribe to every unwatch', async () => {
+      await watchIntentService.unsubscribe()
+      expect(mockUnwatch1).toHaveBeenCalledTimes(1)
+      expect(mockUnwatch2).toHaveBeenCalledTimes(1)
+      expect(mockLogError).toHaveBeenCalledTimes(0)
+      expect(mockLogDebug).toHaveBeenCalledTimes(1)
+      expect(mockLogDebug).toHaveBeenCalledWith({
+        msg: 'watch-event: unsubscribe',
+      })
+    })
+  })
+
+  describe('on unsubscribeFrom', () => {
+    let mockUnwatch1: jest.Mock = jest.fn()
+    const chainID = 1
+    beforeEach(async () => {
+      mockUnwatch1 = jest.fn()
+      watchIntentService['unwatch'] = {
+        [chainID]: mockUnwatch1,
+      }
+    })
+
+    afterEach(async () => {
+      jest.clearAllMocks()
+    })
+
+    describe('on unwatch exists', () => {
+      it('should unsubscribe to unwatch', async () => {
+        await watchIntentService.unsubscribeFrom(chainID)
+        expect(mockUnwatch1).toHaveBeenCalledTimes(1)
+        expect(mockLogDebug).toHaveBeenCalledTimes(1)
+        expect(mockLogError).toHaveBeenCalledTimes(0)
+        expect(mockLogDebug).toHaveBeenCalledWith({
+          msg: 'watch-event: unsubscribeFrom',
+          chainID,
+        })
+      })
+
+      it('should unsubscribe to unwatch and catch throw', async () => {
+        const e = new Error('test')
+        mockUnwatch1.mockImplementation(() => {
+          throw e
+        })
+        await watchIntentService.unsubscribeFrom(chainID)
+        expect(mockUnwatch1).toHaveBeenCalledTimes(1)
+        expect(mockLogError).toHaveBeenCalledTimes(1)
+        expect(mockLogError).toHaveBeenCalledWith({
+          msg: 'watch-event: unsubscribeFrom',
+          error: EcoError.WatchEventUnsubscribeFromError(chainID).toString(),
+          errorPassed: e,
+          chainID,
+        })
+      })
+    })
+
+    describe('on unwatch doesnt exist', () => {
+      beforeEach(async () => {
+        watchIntentService['unwatch'] = {}
+      })
+
+      it('should log error', async () => {
+        await watchIntentService.unsubscribeFrom(chainID)
+        expect(mockUnwatch1).toHaveBeenCalledTimes(0)
+        expect(mockLogError).toHaveBeenCalledTimes(1)
+        expect(mockLogError).toHaveBeenCalledWith({
+          msg: 'watch event: unsubscribeFrom',
+          error: EcoError.WatchEventNoUnsubscribeError(chainID).toString(),
+          chainID,
+        })
+      })
+    })
+  })
+})

package/src/watch/intent/tests/watch-fulfillment.service.spec.ts

@@ -0,0 +1,141 @@
+import { QUEUES } from '@/common/redis/constants'
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import { MultichainPublicClientService } from '@/transaction/multichain-public-client.service'
+import { WatchFulfillmentService } from '@/watch/intent/watch-fulfillment.service'
+import { createMock, DeepMocked } from '@golevelup/ts-jest'
+import { BullModule, getQueueToken } from '@nestjs/bullmq'
+import { Test, TestingModule } from '@nestjs/testing'
+import { Job, Queue } from 'bullmq'
+
+describe('WatchFulfillmentService', () => {
+  let watchFulfillmentService: WatchFulfillmentService
+  let publicClientService: DeepMocked<MultichainPublicClientService>
+  let ecoConfigService: DeepMocked<EcoConfigService>
+  let queue: DeepMocked<Queue>
+  const mockLogDebug = jest.fn()
+  const mockLogLog = jest.fn()
+
+  const inboxes = [
+    { chainID: 1, inboxAddress: '0x1234' },
+    { chainID: 2, inboxAddress: '0x5678' },
+  ] as any
+  const inboxRecord = inboxes.reduce((acc, solver) => {
+    acc[solver.chainID] = solver
+    return acc
+  }, {})
+  const supportedChains = inboxes.map((s) => BigInt(s.chainID))
+
+  beforeEach(async () => {
+    const chainMod: TestingModule = await Test.createTestingModule({
+      providers: [
+        WatchFulfillmentService,
+        {
+          provide: MultichainPublicClientService,
+          useValue: createMock<MultichainPublicClientService>(),
+        },
+        { provide: EcoConfigService, useValue: createMock<EcoConfigService>() },
+      ],
+      imports: [
+        BullModule.registerQueue({
+          name: QUEUES.INBOX.queue,
+        }),
+      ],
+    })
+      .overrideProvider(getQueueToken(QUEUES.INBOX.queue))
+      .useValue(createMock<Queue>())
+      .compile()
+
+    watchFulfillmentService = chainMod.get(WatchFulfillmentService)
+    publicClientService = chainMod.get(MultichainPublicClientService)
+    ecoConfigService = chainMod.get(EcoConfigService)
+    queue = chainMod.get(getQueueToken(QUEUES.INBOX.queue))
+
+    watchFulfillmentService['logger'].debug = mockLogDebug
+    watchFulfillmentService['logger'].log = mockLogLog
+  })
+
+  afterEach(async () => {
+    // restore the spy created with spyOn
+    jest.restoreAllMocks()
+    mockLogDebug.mockClear()
+    mockLogLog.mockClear()
+  })
+
+  describe('on lifecycle', () => {
+    describe('on startup', () => {
+      it('should subscribe to nothing if no solvers', async () => {
+        const mock = jest.spyOn(watchFulfillmentService, 'subscribe')
+        await watchFulfillmentService.onApplicationBootstrap()
+        expect(mock).toHaveBeenCalledTimes(1)
+      })
+
+      it('should subscribe to all solvers', async () => {
+        const mockWatch = jest.fn()
+        publicClientService.getClient.mockResolvedValue({
+          watchContractEvent: mockWatch,
+        } as any)
+        ecoConfigService.getSolvers.mockReturnValue(inboxRecord)
+        watchFulfillmentService.getSupportedChains = jest.fn().mockReturnValue(supportedChains)
+        await watchFulfillmentService.onApplicationBootstrap()
+        expect(mockWatch).toHaveBeenCalledTimes(2)
+
+        for (const [index, s] of inboxes.entries()) {
+          const { address, eventName, args } = mockWatch.mock.calls[index][0]
+          const partial = { address, eventName, args }
+          expect(partial).toEqual({
+            address: s.inboxAddress,
+            eventName: 'Fulfillment',
+            args: { _sourceChainID: supportedChains },
+          })
+        }
+      })
+    })
+
+    describe('on destroy', () => {
+      it('should unsubscribe to nothing if no solvers', async () => {
+        const mock = jest.spyOn(watchFulfillmentService, 'unsubscribe')
+        await watchFulfillmentService.onModuleDestroy()
+        expect(mock).toHaveBeenCalledTimes(1)
+      })
+
+      it('should unsubscribe to all solvers', async () => {
+        const mockUnwatch = jest.fn()
+        publicClientService.getClient.mockResolvedValue({
+          watchContractEvent: () => mockUnwatch,
+        } as any)
+        ecoConfigService.getSolvers.mockReturnValue(inboxRecord)
+        await watchFulfillmentService.onApplicationBootstrap()
+        await watchFulfillmentService.onModuleDestroy()
+        expect(mockUnwatch).toHaveBeenCalledTimes(2)
+      })
+    })
+
+    describe('on fulfillment', () => {
+      const log = { args: { _hash: BigInt(1), logIndex: BigInt(2) } } as any
+      let mockQueueAdd: jest.SpyInstance<Promise<Job<any, any, string>>>
+
+      beforeEach(async () => {
+        mockQueueAdd = jest.spyOn(queue, 'add')
+        await watchFulfillmentService.addJob()([log])
+        expect(mockLogDebug).toHaveBeenCalledTimes(1)
+      })
+
+      it('should convert all bigints to strings', async () => {
+        expect(mockLogDebug.mock.calls[0][0].fulfillment).toEqual(
+          expect.objectContaining({
+            args: { _hash: log.args._hash.toString(), logIndex: log.args.logIndex.toString() },
+          }),
+        )
+      })
+
+      it('should should enque a job for every intent', async () => {
+        expect(mockQueueAdd).toHaveBeenCalledTimes(1)
+        expect(mockQueueAdd).toHaveBeenCalledWith(
+          QUEUES.INBOX.jobs.fulfillment,
+          expect.any(Object),
+          { jobId: 'watch-fulfillement-1-0' },
+        )
+      })
+    })
+  })
+})

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

@@ -0,0 +1,106 @@
+import { Injectable, Logger } from '@nestjs/common'
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import { Queue } from 'bullmq'
+import { QUEUES } from '@/common/redis/constants'
+import { InjectQueue } from '@nestjs/bullmq'
+import { getIntentJobId } from '@/common/utils/strings'
+import { IntentSource } from '@/eco-configs/eco-config.types'
+import { EcoLogMessage } from '@/common/logging/eco-log-message'
+import { MultichainPublicClientService } from '@/transaction/multichain-public-client.service'
+import { IntentCreatedLog } from '@/contracts'
+import { PublicClient } from 'viem'
+import { IntentSourceAbi } from '@eco-foundation/routes-ts'
+import { WatchEventService } from '@/watch/intent/watch-event.service'
+import * as BigIntSerializer from '@/liquidity-manager/utils/serialize'
+
+/**
+ * This service subscribes to IntentSource contracts for IntentCreated events. It subscribes on all
+ * supported chains and prover addresses. When an event is emitted, it mutates the event log, and then
+ * adds it intent queue for processing.
+ */
+@Injectable()
+export class WatchCreateIntentService extends WatchEventService<IntentSource> {
+  protected logger = new Logger(WatchCreateIntentService.name)
+
+  constructor(
+    @InjectQueue(QUEUES.SOURCE_INTENT.queue) protected readonly intentQueue: Queue,
+    protected readonly publicClientService: MultichainPublicClientService,
+    protected readonly ecoConfigService: EcoConfigService,
+  ) {
+    super(intentQueue, publicClientService, ecoConfigService)
+  }
+
+  /**
+   * Subscribes to all IntentSource contracts for IntentCreated events. It subscribes on all supported chains
+   * filtering on the prover addresses and destination chain ids. It loads a mapping of the unsubscribe events to
+   * call {@link onModuleDestroy} to close the clients.
+   */
+  async subscribe(): Promise<void> {
+    const subscribeTasks = this.ecoConfigService.getIntentSources().map(async (source) => {
+      const client = await this.publicClientService.getClient(source.chainID)
+      await this.subscribeTo(client, source)
+    })
+
+    await Promise.all(subscribeTasks)
+  }
+
+  /**
+   * Unsubscribes from all IntentSource contracts. It closes all clients in {@link onModuleDestroy}
+   */
+  async unsubscribe() {
+    super.unsubscribe()
+  }
+
+  async subscribeTo(client: PublicClient, source: IntentSource) {
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `watch create intent: subscribeToSource`,
+        properties: {
+          source,
+        },
+      }),
+    )
+    this.unwatch[source.chainID] = client.watchContractEvent({
+      onError: async (error) => {
+        await this.onError(error, client, source)
+      },
+      address: source.sourceAddress,
+      abi: IntentSourceAbi,
+      eventName: 'IntentCreated',
+      args: {
+        // // restrict by acceptable chains, chain ids must be bigints
+        // _destinationChain: solverSupportedChains,
+        prover: source.provers,
+      },
+      onLogs: this.addJob(source),
+    })
+  }
+
+  addJob(source: IntentSource) {
+    return async (logs: IntentCreatedLog[]) => {
+      for (const log of logs) {
+        log.sourceChainID = BigInt(source.chainID)
+        log.sourceNetwork = source.network
+
+        // bigint as it can't serialize to JSON
+        const createIntent = BigIntSerializer.serialize(log)
+        const jobId = getIntentJobId(
+          'watch-create-intent',
+          createIntent.args.hash,
+          createIntent.logIndex,
+        )
+        this.logger.debug(
+          EcoLogMessage.fromDefault({
+            message: `watch intent`,
+            properties: { createIntent, jobId },
+          }),
+        )
+        // add to processing queue
+        await this.intentQueue.add(QUEUES.SOURCE_INTENT.jobs.create_intent, createIntent, {
+          jobId,
+          ...this.intentJobConfig,
+        })
+      }
+    }
+  }
+}

package/src/watch/intent/watch-event.service.ts

@@ -0,0 +1,133 @@
+import { Injectable, Logger, OnApplicationBootstrap, OnModuleDestroy } from '@nestjs/common'
+import { EcoConfigService } from '../../eco-configs/eco-config.service'
+import { JobsOptions, Queue } from 'bullmq'
+import { MultichainPublicClientService } from '../../transaction/multichain-public-client.service'
+import { PublicClient, WatchContractEventReturnType } from 'viem'
+import { EcoLogMessage } from '@/common/logging/eco-log-message'
+import { EcoError } from '@/common/errors/eco-error'
+
+/**
+ * This service subscribes has hooks for subscribing and unsubscribing to a contract event.
+ */
+@Injectable()
+export abstract class WatchEventService<T extends { chainID: number }>
+  implements OnApplicationBootstrap, OnModuleDestroy
+{
+  protected logger: Logger
+  protected intentJobConfig: JobsOptions
+  protected unwatch: Record<string, WatchContractEventReturnType> = {}
+
+  constructor(
+    protected readonly queue: Queue,
+    protected readonly publicClientService: MultichainPublicClientService,
+    protected readonly ecoConfigService: EcoConfigService,
+  ) {}
+
+  async onModuleInit() {
+    this.intentJobConfig = this.ecoConfigService.getRedis().jobs.intentJobConfig
+  }
+
+  async onApplicationBootstrap() {
+    await this.subscribe()
+  }
+
+  async onModuleDestroy() {
+    // close all clients
+    this.unsubscribe()
+  }
+
+  /**
+   * Subscribes to the events. It loads a mapping of the unsubscribe events to
+   * call {@link onModuleDestroy} to close the clients.
+   */
+  abstract subscribe(): Promise<void>
+
+  /**
+   * Subscribes to a contract on a specific chain
+   * @param client the client to subscribe to
+   * @param contract the contract to subscribe to
+   */
+  abstract subscribeTo(client: PublicClient, contract: T): Promise<void>
+
+  /**
+   * Unsubscribes from all events. It closes all clients in {@link onModuleDestroy}
+   */
+  async unsubscribe(): Promise<void> {
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `watch-event: unsubscribe`,
+      }),
+    )
+    Object.values(this.unwatch).forEach((unwatch) => {
+      try {
+        unwatch()
+      } catch (e) {
+        this.logger.error(
+          EcoLogMessage.withError({
+            message: `watch-event: unsubscribe`,
+            error: EcoError.WatchEventUnsubscribeError,
+            properties: {
+              errorPassed: e,
+            },
+          }),
+        )
+      }
+    })
+  }
+
+  async onError(error: any, client: PublicClient, contract: T) {
+    this.logger.error(
+      EcoLogMessage.fromDefault({
+        message: `rpc client error`,
+        properties: {
+          error,
+        },
+      }),
+    )
+    //reset the filters as they might have expired or we might have been moved to a new node
+    //https://support.quicknode.com/hc/en-us/articles/10838914856977-Error-code-32000-message-filter-not-found
+    await this.unsubscribeFrom(contract.chainID)
+    await this.subscribeTo(client, contract)
+  }
+
+  /**
+   * Unsubscribes from a specific chain
+   * @param chainID the chain id to unsubscribe from
+   */
+  async unsubscribeFrom(chainID: number) {
+    if (this.unwatch[chainID]) {
+      this.logger.debug(
+        EcoLogMessage.fromDefault({
+          message: `watch-event: unsubscribeFrom`,
+          properties: {
+            chainID,
+          },
+        }),
+      )
+      try {
+        this.unwatch[chainID]()
+      } catch (e) {
+        this.logger.error(
+          EcoLogMessage.withError({
+            message: `watch-event: unsubscribeFrom`,
+            error: EcoError.WatchEventUnsubscribeFromError(chainID),
+            properties: {
+              chainID,
+              errorPassed: e,
+            },
+          }),
+        )
+      }
+    } else {
+      this.logger.error(
+        EcoLogMessage.withError({
+          message: `watch event: unsubscribeFrom`,
+          error: EcoError.WatchEventNoUnsubscribeError(chainID),
+          properties: {
+            chainID,
+          },
+        }),
+      )
+    }
+  }
+}