eco-solver 0.0.1-security → 1.5.1

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

@@ -0,0 +1,167 @@
+import { createMock, DeepMocked } from '@golevelup/ts-jest'
+import { EcoConfigService } from '../../eco-configs/eco-config.service'
+import { Test, TestingModule } from '@nestjs/testing'
+import { ProofService } from '../../prover/proof.service'
+import { RetryInfeasableIntentsService } from '@/intervals/retry-infeasable-intents.service'
+import { Queue } from 'bullmq'
+import { getModelToken } from '@nestjs/mongoose'
+import { Model } from 'mongoose'
+import { IntentSourceModel } from '@/intent/schemas/intent-source.schema'
+import { BullModule, getQueueToken } from '@nestjs/bullmq'
+import { QUEUES } from '@/common/redis/constants'
+import { Proofs } from '@/contracts'
+import { Hex } from 'viem'
+
+describe('RetryInfeasableIntentsService', () => {
+  let infeasableService: RetryInfeasableIntentsService
+  let proofService: DeepMocked<ProofService>
+  let ecoConfigService: DeepMocked<EcoConfigService>
+  let intervalQueue: DeepMocked<Queue>
+  let intentQueue: DeepMocked<Queue>
+  let intentSourceModel: DeepMocked<Model<IntentSourceModel>>
+
+  const mockLogDebug = jest.fn()
+  const mockLogLog = jest.fn()
+
+  beforeEach(async () => {
+    const chainMod: TestingModule = await Test.createTestingModule({
+      providers: [
+        RetryInfeasableIntentsService,
+        {
+          provide: getModelToken(IntentSourceModel.name),
+          useValue: createMock<Model<IntentSourceModel>>(),
+        },
+        { provide: ProofService, useValue: createMock<ProofService>() },
+        { provide: EcoConfigService, useValue: createMock<EcoConfigService>() },
+      ],
+      imports: [
+        BullModule.registerQueue({
+          name: QUEUES.INTERVAL.queue,
+        }),
+        BullModule.registerQueue({
+          name: QUEUES.SOURCE_INTENT.queue,
+        }),
+      ],
+    })
+      .overrideProvider(getQueueToken(QUEUES.INTERVAL.queue))
+      .useValue(createMock<Queue>())
+      .overrideProvider(getQueueToken(QUEUES.SOURCE_INTENT.queue))
+      .useValue(createMock<Queue>())
+      .compile()
+
+    //turn off the services from logging durring testing
+    chainMod.useLogger(false)
+    infeasableService = chainMod.get(RetryInfeasableIntentsService)
+    proofService = chainMod.get(ProofService)
+    ecoConfigService = chainMod.get(EcoConfigService)
+    intentSourceModel = chainMod.get(getModelToken(IntentSourceModel.name))
+    intervalQueue = chainMod.get(getQueueToken(QUEUES.INTERVAL.queue))
+    intentQueue = chainMod.get(getQueueToken(QUEUES.SOURCE_INTENT.queue))
+
+    infeasableService['logger'].debug = mockLogDebug
+    infeasableService['logger'].log = mockLogLog
+  })
+
+  afterEach(async () => {
+    jest.restoreAllMocks()
+    mockLogDebug.mockClear()
+    mockLogLog.mockClear()
+  })
+
+  describe('on startup', () => {
+    const mockInternals = {
+      retryInfeasableIntents: {
+        repeatOpts: {
+          every: 10000,
+        },
+        jobTemplate: {
+          name: 'retry-infeasable-intents',
+          data: {},
+        },
+      },
+    }
+    beforeEach(async () => {
+      ecoConfigService.getIntervals.mockReturnValue(mockInternals as any)
+    })
+
+    it('should set intentJobConfig', async () => {
+      await infeasableService.onModuleInit()
+      expect(ecoConfigService.getIntervals).toHaveBeenCalledTimes(1)
+    })
+
+    it('should set upsertJobScheduler', async () => {
+      await infeasableService.onApplicationBootstrap()
+      expect(ecoConfigService.getIntervals).toHaveBeenCalledTimes(1)
+      expect(intervalQueue.upsertJobScheduler).toHaveBeenCalledTimes(1)
+      expect(intervalQueue.upsertJobScheduler).toHaveBeenCalledWith(
+        QUEUES.INTERVAL.jobs.RETRY_INFEASABLE_INTENTS,
+        { ...mockInternals.retryInfeasableIntents.repeatOpts, immediately: true },
+        {
+          ...mockInternals.retryInfeasableIntents.jobTemplate,
+          name: QUEUES.INTERVAL.jobs.retry_infeasable_intents,
+        },
+      )
+    })
+  })
+
+  describe('on retryInfeasableIntents', () => {
+    let mockGetInfeasableIntents = jest.fn()
+    const mockModels = [
+      { intent: { hash: 'hash1', logIndex: 1 } },
+      { intent: { hash: 'hash2', logIndex: 2 } },
+    ]
+    beforeEach(async () => {
+      infeasableService['getInfeasableIntents'] = mockGetInfeasableIntents
+      mockGetInfeasableIntents.mockResolvedValue(mockModels)
+    })
+
+    it('should log models retrieved', async () => {
+      await infeasableService.retryInfeasableIntents()
+      expect(mockLogDebug).toHaveBeenCalledTimes(1)
+      expect(mockLogDebug).toHaveBeenCalledWith({
+        msg: 'retryInfeasableIntents',
+        models: mockModels,
+      })
+    })
+
+    it('should add every model to the queue', async () => {
+      const addSpy = jest.spyOn(intentQueue, 'add')
+      await infeasableService.retryInfeasableIntents()
+      expect(addSpy).toHaveBeenCalledTimes(2)
+    })
+  })
+
+  describe('getInfeasableIntents', () => {
+    it('should fetch intents with status INFEASABLE and valid expiration for Hyperlane proofs', async () => {
+      const minDateHyper = new Date('2022-01-01')
+      const minDateStorage = new Date('2022-01-02')
+      const proverHyper: Hex[] = ['0x1a', '0x2a']
+      const proverStorage: Hex[] = ['0x3b', '0x4b']
+      const mockGetProofMinimumDate = jest
+        .spyOn(proofService, 'getProofMinimumDate')
+        .mockImplementation((proof) => (proof == Proofs.Hyperlane ? minDateHyper : minDateStorage))
+      const mockGetProvers = jest
+        .spyOn(proofService, 'getProvers')
+        .mockImplementation((proof) => (proof == Proofs.Hyperlane ? proverHyper : proverStorage))
+
+      await infeasableService['getInfeasableIntents']()
+
+      expect(intentSourceModel.find).toHaveBeenCalledWith({
+        status: 'INFEASABLE',
+        $or: [
+          {
+            'intent.expiration': { $gt: minDateHyper },
+            'intent.prover': { $in: proverHyper },
+          },
+          {
+            'intent.expiration': { $gt: minDateStorage },
+            'intent.prover': { $in: proverStorage },
+          },
+        ],
+      })
+
+      expect(mockGetProofMinimumDate).toHaveBeenCalledTimes(2)
+      expect(mockGetProvers).toHaveBeenCalledTimes(2)
+    })
+  })
+})

package/src/kms/kms.module.ts

@@ -0,0 +1,12 @@
+import { KmsService } from '@/kms/kms.service'
+import { Module } from '@nestjs/common'
+
+@Module({
+  imports: [],
+  providers: [KmsService],
+  exports: [KmsService],
+})
+/**
+ * A module for dealing with the aws kms service.
+ */
+export class KmsModule {}

package/src/kms/kms.service.ts

@@ -0,0 +1,65 @@
+import { EcoError } from '@/common/errors/eco-error'
+import { EcoLogMessage } from '@/common/logging/eco-log-message'
+import { obscureCenter } from '@/common/utils/strings'
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common'
+import { Signer } from '@web3-kms-signer/core'
+import { KMSProviderAWS } from '@web3-kms-signer/kms-provider-aws'
+import { KMSWallets } from '@web3-kms-signer/kms-wallets'
+import { getAddress as viemGetAddress, Hex } from 'viem'
+
+/**
+ * A service class that initializes the kms signer and provides for signing of messages.
+ * @see {@link SignerKmsService}
+ */
+@Injectable()
+export class KmsService implements OnModuleInit {
+  private logger = new Logger(KmsService.name)
+  private keyID: string
+  wallets: KMSWallets
+  signer: Signer
+  constructor(private readonly ecoConfigService: EcoConfigService) {}
+
+  async onModuleInit() {
+    const kmsConfig = this.ecoConfigService.getKmsConfig()
+    if (!kmsConfig) {
+      throw EcoError.KmsCredentialsError(kmsConfig)
+    }
+    this.keyID = kmsConfig.keyID
+
+    const provider = new KMSProviderAWS({
+      region: kmsConfig.region,
+    })
+    this.wallets = new KMSWallets(provider)
+
+    // Dont need chainId because transactions eip1559, already hash the chainID on signature in viem
+    // Basic signs do need chainID for eip 155
+    this.signer = new Signer(this.wallets) //, chainId)
+
+    this.logger.log(
+      EcoLogMessage.fromDefault({
+        message: `KmsService initialized`,
+        properties: {
+          kmsAddress: await this.getAddress(),
+          kmsKeyId: obscureCenter(this.getKmsKeyId()),
+        },
+      }),
+    )
+  }
+
+  /**
+   * Returns the address as hex of the KMS signer.
+   * @returns the KMS eth address
+   */
+  async getAddress(): Promise<Hex> {
+    return viemGetAddress(await this.wallets.getAddressHex(this.keyID))
+  }
+
+  /**
+   * Returns the KMS key ID that this service uses to sign
+   * @returns the KMS key ID
+   */
+  getKmsKeyId(): string {
+    return this.keyID
+  }
+}

package/src/kms/tests/kms.service.spec.ts

@@ -0,0 +1,60 @@
+const mockGetAddress = jest.fn()
+import { Test, TestingModule } from '@nestjs/testing'
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import { EcoError } from '@/common/errors/eco-error'
+import { KMSWallets } from '@web3-kms-signer/kms-wallets'
+import { Signer } from '@web3-kms-signer/core'
+import { Logger } from '@nestjs/common'
+import { KmsService } from '@/kms/kms.service'
+import { createMock, DeepMocked } from '@golevelup/ts-jest'
+
+jest.mock('viem', () => {
+  return {
+    ...jest.requireActual('viem'),
+    getAddress: mockGetAddress,
+  }
+})
+describe('KmsService', () => {
+  let service: KmsService
+  let ecoConfigService: DeepMocked<EcoConfigService>
+  let logger: Logger
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        KmsService,
+        {
+          provide: EcoConfigService,
+          useValue: createMock<EcoConfigService>(),
+        },
+      ],
+    }).compile()
+
+    service = module.get<KmsService>(KmsService)
+    ecoConfigService = module.get(EcoConfigService)
+    logger = new Logger()
+
+    mockGetAddress.mockClear()
+  })
+
+  it('should be defined', () => {
+    expect(service).toBeDefined()
+  })
+
+  it('should throw an error if KMS config is missing', async () => {
+    jest.spyOn(ecoConfigService, 'getKmsConfig').mockReturnValue(null as any)
+    await expect(service.onModuleInit()).rejects.toThrow(EcoError.KmsCredentialsError(null as any))
+  })
+
+  it('should call viem to checksum and verify address', async () => {
+    const ma = '0x123'
+    const mockGetHex = jest.fn().mockResolvedValue(ma)
+    mockGetAddress.mockResolvedValue(ma)
+    service.wallets = {
+      getAddressHex: mockGetHex,
+    } as any
+    expect(await service.getAddress()).toBe(ma)
+    expect(mockGetAddress).toHaveBeenCalledTimes(1)
+    expect(mockGetHex).toHaveBeenCalledTimes(1)
+  })
+})

package/src/liquidity-manager/jobs/check-balances-cron.job.ts

@@ -0,0 +1,229 @@
+import { Queue } from 'bullmq'
+import { formatUnits } from 'viem'
+import { table } from 'table'
+import { EcoLogMessage } from '@/common/logging/eco-log-message'
+import {
+  LiquidityManagerJob,
+  LiquidityManagerJobManager,
+} from '@/liquidity-manager/jobs/liquidity-manager.job'
+import { LiquidityManagerJobName } from '@/liquidity-manager/queues/liquidity-manager.queue'
+import { LiquidityManagerProcessor } from '@/liquidity-manager/processors/eco-protocol-intents.processor'
+import { shortAddr } from '@/liquidity-manager/utils/address'
+import { removeJobSchedulers } from '@/bullmq/utils/queue'
+import {
+  RebalanceQuote,
+  RebalanceRequest,
+  TokenDataAnalyzed,
+} from '@/liquidity-manager/types/types'
+
+/**
+ * A cron job that checks token balances, logs information, and attempts to rebalance deficits.
+ */
+export class CheckBalancesCronJobManager extends LiquidityManagerJobManager {
+  static readonly jobSchedulerName = 'job-scheduler-check-balances'
+
+  /**
+   * Starts the CheckBalancesCronJob by removing existing repeatable jobs and adding a new one to the queue.
+   * @param queue - The job queue to add the job to.
+   * @param interval - Interval duration in which the job is repeated
+   */
+  static async start(queue: Queue, interval: number): Promise<void> {
+    await removeJobSchedulers(queue, LiquidityManagerJobName.CHECK_BALANCES)
+
+    await queue.upsertJobScheduler(
+      CheckBalancesCronJobManager.jobSchedulerName,
+      { every: interval },
+      {
+        name: LiquidityManagerJobName.CHECK_BALANCES,
+        opts: {
+          removeOnComplete: true,
+        },
+      },
+    )
+  }
+
+  /**
+   * Type guard to check if the given job is an instance of CheckBalancesCronJob.
+   * @param job - The job to check.
+   * @returns True if the job is a CheckBalancesCronJob.
+   */
+  is(job: LiquidityManagerJob): boolean {
+    return job.name === LiquidityManagerJobName.CHECK_BALANCES
+  }
+
+  /**
+   * Processes the CheckBalancesCronJob by analyzing token balances, logging the results, and rebalancing deficits.
+   * @param job - The CheckBalancesCronJob instance to process.
+   * @param processor - The LiquidityManagerProcessor instance used for processing.
+   */
+  async process(job: LiquidityManagerJob, processor: LiquidityManagerProcessor): Promise<void> {
+    const { deficit, surplus, items } = await processor.liquidityManagerService.analyzeTokens()
+
+    processor.logger.log(
+      EcoLogMessage.fromDefault({
+        message: `CheckBalancesCronJob: process`,
+        properties: {
+          surplus: surplus.total,
+          deficit: deficit.total,
+        },
+      }),
+    )
+
+    processor.logger.log(this.displayTokenTable(items))
+
+    if (!deficit.total) {
+      processor.logger.log(
+        EcoLogMessage.fromDefault({
+          message: `CheckBalancesCronJob: No deficits found`,
+        }),
+      )
+      return
+    }
+
+    const rebalances: RebalanceRequest[] = []
+
+    for (const deficitToken of deficit.items) {
+      const rebalancingQuotes = await processor.liquidityManagerService.getOptimizedRebalancing(
+        deficitToken,
+        surplus.items,
+      )
+
+      if (!rebalancingQuotes) {
+        processor.logger.debug(
+          EcoLogMessage.fromDefault({
+            message: 'CheckBalancesCronJob: No rebalancing quotes found',
+            properties: {
+              deficitToken,
+            },
+          }),
+        )
+        continue
+      }
+
+      this.updateGroupBalances(processor, surplus.items, rebalancingQuotes)
+
+      const rebalanceRequest = { token: deficitToken, quotes: rebalancingQuotes }
+
+      // Store rebalance request on DB
+      await processor.liquidityManagerService.storeRebalancing(rebalanceRequest)
+
+      rebalances.push(rebalanceRequest)
+    }
+
+    processor.logger.log(this.displayRebalancingTable(rebalances))
+
+    await processor.liquidityManagerService.startRebalancing(rebalances)
+  }
+
+  /**
+   * Handles job failures by logging the error.
+   * @param job - The job that failed.
+   * @param processor - The processor handling the job.
+   * @param error - The error that occurred.
+   */
+  onFailed(job: LiquidityManagerJob, processor: LiquidityManagerProcessor, error: unknown) {
+    processor.logger.error(
+      EcoLogMessage.fromDefault({
+        message: `CheckBalancesCronJob: Failed`,
+        properties: { error: (error as any)?.message ?? error },
+      }),
+    )
+  }
+
+  /**
+   * Displays a table of token data analysis.
+   * @param items - The token data to display.
+   * @returns A formatted table as a string.
+   */
+  private displayTokenTable(items: TokenDataAnalyzed[]) {
+    const formatter = new Intl.NumberFormat('en-US', { maximumFractionDigits: 2 }).format
+
+    const header = ['Chain ID', 'Address', 'Balance', 'Target', 'Range', 'State']
+    const cells = items.map((item) => {
+      const format = (value: bigint) =>
+        formatter(parseFloat(formatUnits(value, item.balance.decimals)))
+      return [
+        item.config.chainId,
+        item.config.address,
+        format(item.analysis.balance.current),
+        format(item.analysis.balance.target),
+        `${format(item.analysis.balance.minimum)} - ${format(item.analysis.balance.maximum)}`,
+        item.analysis.state,
+      ]
+    })
+
+    return table([header, ...cells])
+  }
+
+  /**
+   * Displays a table of the rebasing data.
+   * @param items - The token data to display.
+   * @returns A formatted table as a string.
+   */
+  private displayRebalancingTable(items: RebalanceRequest[]) {
+    // Skip if no rebalancing quotes are found.
+    if (!items.length) return
+
+    const formatter = new Intl.NumberFormat('en-US', { maximumFractionDigits: 2 }).format
+    const slippageFormatter = new Intl.NumberFormat('en-US', { maximumFractionDigits: 4 }).format
+    const format = (value: bigint, decimals: number) =>
+      formatter(parseFloat(formatUnits(value, decimals)))
+
+    const header = [
+      'Token Out',
+      'Chain Out',
+      'Token In',
+      'Chain In',
+      'Current Balance',
+      'Target Balance',
+      'Strategy',
+      'Amount In',
+      'Amount Out',
+      'Slippage',
+    ]
+    const cells = items
+      .flatMap((item) => item.quotes)
+      .map((quote) => {
+        return [
+          shortAddr(quote.tokenOut.config.address),
+          quote.tokenOut.config.chainId,
+          shortAddr(quote.tokenIn.config.address),
+          quote.tokenIn.config.chainId,
+          format(quote.tokenOut.balance.balance, quote.tokenOut.balance.decimals),
+          quote.tokenOut.config.targetBalance,
+          quote.strategy,
+          format(quote.amountIn, quote.tokenIn.balance.decimals),
+          format(quote.amountOut, quote.tokenOut.balance.decimals),
+          slippageFormatter(quote.slippage * 100) + '%',
+        ]
+      })
+
+    return table([header, ...cells], { columns: [{ width: 48 }] })
+  }
+
+  /**
+   * Updates the group balances after rebalancing quotes are received.
+   * @param processor - The LiquidityManagerProcessor instance used for processing.
+   * @param items - The list of token data analyzed.
+   * @param rebalancingQuotes - The quotes received for rebalancing.
+   */
+  private updateGroupBalances(
+    processor: LiquidityManagerProcessor,
+    items: TokenDataAnalyzed[],
+    rebalancingQuotes: RebalanceQuote[],
+  ) {
+    for (const quote of rebalancingQuotes) {
+      // Iterate through each rebalancing quote.
+      const token = items.find(
+        // Find the matching token in the items list.
+        (item) =>
+          item.config.address === quote.tokenIn.config.address &&
+          item.config.chainId === quote.tokenIn.config.chainId,
+      )
+      if (!token) continue
+
+      token.balance.balance -= quote.amountIn // Deduct the amount from the balance.
+      token.analysis = processor.liquidityManagerService.analyzeToken(token) // Re-analyze the token balance.
+    }
+  }
+}

package/src/liquidity-manager/jobs/liquidity-manager.job.ts

@@ -0,0 +1,52 @@
+/* eslint @typescript-eslint/no-unused-vars: 0 */
+
+import { Job } from 'bullmq'
+import {
+  LiquidityManagerQueueDataType,
+  LiquidityManagerJobName,
+} from '@/liquidity-manager/queues/liquidity-manager.queue'
+
+export type LiquidityManagerJob<
+  NameType extends LiquidityManagerJobName = LiquidityManagerJobName,
+  DataType extends LiquidityManagerQueueDataType = LiquidityManagerQueueDataType,
+> = Job<DataType, unknown, NameType>
+
+export abstract class LiquidityManagerJobManager<
+  Job extends LiquidityManagerJob = LiquidityManagerJob,
+> {
+  /**
+   * Checks if the given job is of the specific type.
+   * @param job - The job to check.
+   * @returns A boolean indicating if the job is of the specific type.
+   */
+  is(job: Job): boolean {
+    throw new Error('Unimplemented function')
+  }
+
+  /**
+   * Processes the given job.
+   * @param job - The job to process.
+   * @param processor - The processor handling the job.
+   */
+  process(job: Job, processor: unknown): Promise<void> {
+    throw new Error('Unimplemented function')
+  }
+
+  /**
+   * Hook triggered when a job is completed.
+   * @param job - The job to process.
+   * @param processor - The processor handling the job.
+   */
+  onComplete(job: Job, processor: unknown): void {
+    // Placeholder method implementation
+  }
+
+  /**
+   * Hook triggered when a job fails.
+   * @param job - The job to process.
+   * @param processor - The processor handling the job.
+   */
+  onFailed(job: Job, processor: unknown, error: unknown): void {
+    // Placeholder method implementation
+  }
+}

package/src/liquidity-manager/jobs/rebalance.job.ts

@@ -0,0 +1,61 @@
+import { FlowChildJob, Job } from 'bullmq'
+import { EcoLogMessage } from '@/common/logging/eco-log-message'
+import {
+  LiquidityManagerJob,
+  LiquidityManagerJobManager,
+} from '@/liquidity-manager/jobs/liquidity-manager.job'
+import { LiquidityManagerJobName } from '@/liquidity-manager/queues/liquidity-manager.queue'
+import { LiquidityManagerProcessor } from '@/liquidity-manager/processors/eco-protocol-intents.processor'
+import { serialize, Serialize } from '@/liquidity-manager/utils/serialize'
+import { RebalanceRequest } from '@/liquidity-manager/types/types'
+
+export type RebalanceJobData = {
+  network: string
+  rebalance: Serialize<RebalanceRequest>
+}
+
+type RebalanceJob = Job<RebalanceJobData, unknown, LiquidityManagerJobName.REBALANCE>
+
+export class RebalanceJobManager extends LiquidityManagerJobManager<RebalanceJob> {
+  /**
+   * Type guard to check if the given job is an instance of RebalanceJob.
+   * @param job - The job to check.
+   * @returns True if the job is a RebalanceJob.
+   */
+  is(job: LiquidityManagerJob): job is RebalanceJob {
+    return job.name === LiquidityManagerJobName.REBALANCE
+  }
+
+  static createJob(rebalance: RebalanceRequest, queueName: string): FlowChildJob {
+    const data: RebalanceJobData = {
+      network: rebalance.token.config.chainId.toString(),
+      rebalance: serialize(rebalance),
+    }
+    return {
+      queueName,
+      data,
+      name: LiquidityManagerJobName.REBALANCE,
+    }
+  }
+
+  async process(job: LiquidityManagerJob, processor: LiquidityManagerProcessor): Promise<void> {
+    if (this.is(job)) {
+      return processor.liquidityManagerService.executeRebalancing(job.data)
+    }
+  }
+
+  /**
+   * Handles job failures by logging the error.
+   * @param job - The job that failed.
+   * @param processor - The processor handling the job.
+   * @param error - The error that occurred.
+   */
+  onFailed(job: LiquidityManagerJob, processor: LiquidityManagerProcessor, error: Error) {
+    processor.logger.error(
+      EcoLogMessage.fromDefault({
+        message: `RebalanceJob: Failed`,
+        properties: { error: error.message },
+      }),
+    )
+  }
+}

package/src/liquidity-manager/liquidity-manager.module.ts

@@ -0,0 +1,29 @@
+import { Module } from '@nestjs/common'
+import { MongooseModule } from '@nestjs/mongoose'
+import { BalanceModule } from '@/balance/balance.module'
+import { TransactionModule } from '@/transaction/transaction.module'
+import { LiquidityManagerQueue } from '@/liquidity-manager/queues/liquidity-manager.queue'
+import { LiquidityManagerService } from '@/liquidity-manager/services/liquidity-manager.service'
+import { LiquidityManagerProcessor } from '@/liquidity-manager/processors/eco-protocol-intents.processor'
+import { LiquidityProviderService } from '@/liquidity-manager/services/liquidity-provider.service'
+import { LiFiProviderService } from '@/liquidity-manager/services/liquidity-providers/LiFi/lifi-provider.service'
+import { RebalanceModel, RebalanceSchema } from '@/liquidity-manager/schemas/rebalance.schema'
+
+@Module({
+  imports: [
+    BalanceModule,
+    TransactionModule,
+    LiquidityManagerQueue.init(),
+    LiquidityManagerQueue.initFlow(),
+
+    MongooseModule.forFeature([{ name: RebalanceModel.name, schema: RebalanceSchema }]),
+  ],
+  providers: [
+    LiquidityManagerService,
+    LiquidityManagerProcessor,
+    LiquidityProviderService,
+    LiFiProviderService,
+  ],
+  exports: [LiquidityManagerService],
+})
+export class LiquidityManagerModule {}