eco-solver 0.0.1-security → 1.5.1

package/src/liquidity-manager/processors/base.processor.ts

@@ -0,0 +1,117 @@
+import { Logger } from '@nestjs/common'
+import { OnWorkerEvent, WorkerHost } from '@nestjs/bullmq'
+import { EcoLogMessage } from '@/common/logging/eco-log-message'
+import {
+  LiquidityManagerJob,
+  LiquidityManagerJobManager,
+} from '@/liquidity-manager/jobs/liquidity-manager.job'
+
+/**
+ * Abstract class representing a base processor for liquidity manager jobs.
+ * @template Job - The type of the job.
+ * @template JobType - The constructor type of the job.
+ */
+export abstract class BaseProcessor<
+  Job extends LiquidityManagerJob = LiquidityManagerJob,
+  JobManager extends LiquidityManagerJobManager<Job> = LiquidityManagerJobManager<Job>,
+> extends WorkerHost {
+  public readonly logger: Logger
+
+  /**
+   * Constructs a new BaseProcessor.
+   * @param name - The name of the processor.
+   * @param jobManagers - The array of job managers.
+   */
+  constructor(
+    protected readonly name: string,
+    protected readonly jobManagers: JobManager[],
+  ) {
+    super()
+    this.logger = new Logger(name)
+  }
+
+  /**
+   * Processes a job.
+   * @param job - The job to process.
+   * @returns The result of the job execution.
+   */
+  process(job: Job) {
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `${this.name}.process()`,
+        properties: {
+          jobName: job.name,
+        },
+      }),
+    )
+
+    return this.execute(job, 'process')
+  }
+
+  /**
+   * Hook triggered when a job is completed.
+   * @param job - The job that was completed.
+   * @returns The result of the onCompleted hook from the job type.
+   */
+  @OnWorkerEvent('completed')
+  onCompleted(job: Job) {
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `${this.name}.onComplete()`,
+        properties: {
+          jobName: job.name,
+        },
+      }),
+    )
+
+    return this.execute(job, 'onComplete')
+  }
+
+  /**
+   * Hook triggered when a job fails.
+   * @param job - The job that failed.
+   * @param error - The error that caused the job to fail.
+   * @returns The result of the onFailed hook from the job type.
+   */
+  @OnWorkerEvent('failed')
+  onFailed(job: Job, error: Error) {
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `${this.name}.onFailed()`,
+        properties: {
+          jobName: job.name,
+        },
+      }),
+    )
+
+    return this.execute(job, 'onFailed', error)
+  }
+
+  /**
+   * Executes a method on the job type that matches the given job.
+   * @param job - The job to execute the method on.
+   * @param method - The method to execute.
+   * @param params - Additional parameters for the method.
+   * @returns The result of the method execution.
+   */
+  private execute(job: Job, method: 'process' | 'onFailed' | 'onComplete', ...params: unknown[]) {
+    for (const manager of this.jobManagers) {
+      // Process the job if it matches the job type
+      if (manager.is(job)) {
+        return (manager[method] as any)(job, this, ...params)
+      }
+    }
+
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `${this.name}: Unknown job type`,
+        properties: {
+          jobName: job.name,
+          method,
+        },
+      }),
+    )
+
+    return undefined
+  }
+}

package/src/liquidity-manager/processors/eco-protocol-intents.processor.ts

@@ -0,0 +1,34 @@
+import { Injectable } from '@nestjs/common'
+import { InjectQueue, Processor } from '@nestjs/bullmq'
+import { BaseProcessor } from '@/liquidity-manager/processors/base.processor'
+import { LiquidityManagerService } from '@/liquidity-manager/services/liquidity-manager.service'
+import { RebalanceJobManager } from '@/liquidity-manager/jobs/rebalance.job'
+import { CheckBalancesCronJobManager } from '@/liquidity-manager/jobs/check-balances-cron.job'
+import {
+  LiquidityManagerQueue,
+  LiquidityManagerQueueType,
+} from '@/liquidity-manager/queues/liquidity-manager.queue'
+
+/**
+ * Processor for handling liquidity manager jobs.
+ * Extends the GroupedJobsProcessor to ensure jobs in the same group are not processed concurrently.
+ */
+@Injectable()
+@Processor(LiquidityManagerQueue.queueName)
+export class LiquidityManagerProcessor extends BaseProcessor {
+  /**
+   * Constructs a new LiquidityManagerProcessor.
+   * @param queue - The queue to process jobs from.
+   * @param liquidityManagerService - The service for managing liquidity.
+   */
+  constructor(
+    @InjectQueue(LiquidityManagerQueue.queueName)
+    protected readonly queue: LiquidityManagerQueueType,
+    public readonly liquidityManagerService: LiquidityManagerService,
+  ) {
+    super(LiquidityManagerProcessor.name, [
+      new CheckBalancesCronJobManager(),
+      new RebalanceJobManager(),
+    ])
+  }
+}

package/src/liquidity-manager/processors/grouped-jobs.processor.ts

@@ -0,0 +1,103 @@
+import { Logger } from '@nestjs/common'
+import {
+  LiquidityManagerJob,
+  LiquidityManagerJobManager,
+} from '@/liquidity-manager/jobs/liquidity-manager.job'
+import { BaseProcessor } from '@/liquidity-manager/processors/base.processor'
+import { Queue } from 'bullmq'
+import { EcoLogMessage } from '@/common/logging/eco-log-message'
+import { OnWorkerEvent } from '@nestjs/bullmq'
+
+/**
+ * Abstract class representing a processor for grouped jobs.
+ * @template Job - The type of the job.
+ */
+export abstract class GroupedJobsProcessor<
+  Job extends LiquidityManagerJob = LiquidityManagerJob,
+  JobManager extends LiquidityManagerJobManager<Job> = LiquidityManagerJobManager<Job>,
+> extends BaseProcessor<Job, JobManager> {
+  public readonly logger: Logger
+  protected abstract readonly queue: Queue
+
+  protected readonly activeGroups = new Set<string>()
+
+  /**
+   * Constructs a new GroupedJobsProcessor.
+   * @param groupBy - The property to group jobs by.
+   * @param params - Additional parameters for the base processor.
+   */
+  constructor(
+    protected readonly groupBy: string,
+    ...params: ConstructorParameters<typeof BaseProcessor<Job, JobManager>>
+  ) {
+    super(...params)
+  }
+
+  /**
+   * Processes a job, ensuring that jobs in the same group are not processed concurrently.
+   * @param job - The job to process.
+   * @returns A promise that resolves to an object indicating if the job was delayed.
+   */
+  async process(job: Job) {
+    const group = job.data?.[this.groupBy] as string
+
+    if (group) {
+      if (this.activeGroups.has(group)) {
+        this.logger.debug(
+          EcoLogMessage.fromDefault({
+            message: 'Job delayed due to group concurrency',
+            properties: {
+              jobName: job.name,
+              group,
+            },
+          }),
+        )
+
+        await this.queue.add(job.name, job.data, {
+          ...job.opts,
+          delay: 5_000, // Delay for 5 seconds
+        })
+
+        return { delayed: true }
+      }
+
+      this.activeGroups.add(group)
+    }
+
+    return super.process(job)
+  }
+
+  /**
+   * Hook triggered when a job is completed.
+   * @param job - The job that was completed.
+   */
+  @OnWorkerEvent('completed')
+  onCompleted(job: Job) {
+    const returnvalue = job.returnvalue as object
+    if (returnvalue && 'delayed' in returnvalue && returnvalue.delayed) {
+      // Skip onCompleted hook if job got delayed
+      return
+    } else if (
+      this.groupBy in job.data &&
+      this.activeGroups.has(job.data[this.groupBy] as string)
+    ) {
+      this.activeGroups.delete(job.data[this.groupBy] as string)
+    }
+
+    return super.onCompleted(job)
+  }
+
+  /**
+   * Hook triggered when a job fails.
+   * @param job - The job that was completed.
+   * @param error - Error.
+   */
+  @OnWorkerEvent('failed')
+  onFailed(job: Job, error: Error) {
+    if (this.groupBy in job.data && this.activeGroups.has(job.data[this.groupBy] as string)) {
+      this.activeGroups.delete(job.data[this.groupBy] as string)
+    }
+
+    return super.onFailed(job, error)
+  }
+}

package/src/liquidity-manager/queues/liquidity-manager.queue.ts

@@ -0,0 +1,48 @@
+import { Queue } from 'bullmq'
+import { initBullMQ, initFlowBullMQ } from '@/bullmq/bullmq.helper'
+import { CheckBalancesCronJobManager } from '@/liquidity-manager/jobs/check-balances-cron.job'
+
+export enum LiquidityManagerJobName {
+  REBALANCE = 'REBALANCE',
+  CHECK_BALANCES = 'CHECK_BALANCES',
+}
+
+export type LiquidityManagerQueueDataType = { network: string; [k: string]: unknown }
+
+export type LiquidityManagerQueueType = Queue<
+  LiquidityManagerQueueDataType,
+  unknown,
+  LiquidityManagerJobName
+>
+
+export class LiquidityManagerQueue {
+  public static readonly prefix = '{liquidity-manager}'
+  public static readonly queueName = LiquidityManagerQueue.name
+  public static readonly flowName = `flow-liquidity-manager`
+
+  constructor(private readonly queue: LiquidityManagerQueueType) {}
+
+  get name() {
+    return this.queue.name
+  }
+
+  static init() {
+    return initBullMQ(
+      { queue: this.queueName, prefix: LiquidityManagerQueue.prefix },
+      {
+        defaultJobOptions: {
+          removeOnFail: true,
+          removeOnComplete: true,
+        },
+      },
+    )
+  }
+
+  static initFlow() {
+    return initFlowBullMQ({ queue: this.flowName, prefix: LiquidityManagerQueue.prefix })
+  }
+
+  startCronJobs(interval: number) {
+    return CheckBalancesCronJobManager.start(this.queue, interval)
+  }
+}

package/src/liquidity-manager/schemas/rebalance-token.schema.ts

@@ -0,0 +1,32 @@
+import { TokenData } from '@/liquidity-manager/types/types'
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose'
+import { formatUnits, Hex } from 'viem'
+
+@Schema()
+export class RebalanceTokenModel {
+  @Prop({ required: true })
+  chainId: number
+
+  @Prop({ required: true })
+  tokenAddress: Hex
+
+  @Prop({ required: true })
+  currentBalance: number
+
+  @Prop({ required: true })
+  targetBalance: number
+
+  static fromTokenData(tokenData: TokenData): RebalanceTokenModel {
+    const currentBalance = parseFloat(
+      formatUnits(tokenData.balance.balance, tokenData.balance.decimals),
+    )
+    return {
+      chainId: tokenData.chainId,
+      tokenAddress: tokenData.config.address,
+      currentBalance,
+      targetBalance: tokenData.config.targetBalance,
+    }
+  }
+}
+
+export const RebalanceTokenSchema = SchemaFactory.createForClass(RebalanceTokenModel)

package/src/liquidity-manager/schemas/rebalance.schema.ts

@@ -0,0 +1,32 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose'
+import { RebalanceTokenModel } from './rebalance-token.schema'
+import { Strategy, StrategyContext } from '@/liquidity-manager/types/types'
+
+@Schema({ timestamps: true })
+export class RebalanceModel {
+  @Prop({ required: true })
+  tokenIn: RebalanceTokenModel
+
+  @Prop({ required: true })
+  tokenOut: RebalanceTokenModel
+
+  @Prop({ required: true })
+  amountIn: bigint
+
+  @Prop({ required: true })
+  amountOut: bigint
+
+  @Prop({ required: true })
+  slippage: number
+
+  @Prop({ required: true })
+  strategy: Strategy
+
+  @Prop({ required: false })
+  groupId?: string
+
+  @Prop({ required: true, type: Object })
+  context: StrategyContext
+}
+
+export const RebalanceSchema = SchemaFactory.createForClass(RebalanceModel)

package/src/liquidity-manager/services/liquidity-manager.service.ts

@@ -0,0 +1,188 @@
+import { Model } from 'mongoose'
+import { InjectModel } from '@nestjs/mongoose'
+import { InjectFlowProducer, InjectQueue } from '@nestjs/bullmq'
+import { FlowProducer } from 'bullmq'
+import { Injectable, OnApplicationBootstrap } from '@nestjs/common'
+import { groupBy } from 'lodash'
+import { v4 as uuid } from 'uuid'
+import { BalanceService } from '@/balance/balance.service'
+import { TokenState } from '@/liquidity-manager/types/token-state.enum'
+import {
+  analyzeToken,
+  analyzeTokenGroup,
+  getGroupTotal,
+  getSortGroupByDiff,
+} from '@/liquidity-manager/utils/token'
+import {
+  LiquidityManagerQueue,
+  LiquidityManagerQueueType,
+} from '@/liquidity-manager/queues/liquidity-manager.queue'
+import { RebalanceJobData, RebalanceJobManager } from '@/liquidity-manager/jobs/rebalance.job'
+import { LiquidityProviderService } from '@/liquidity-manager/services/liquidity-provider.service'
+import { deserialize } from '@/liquidity-manager/utils/serialize'
+import { LiquidityManagerConfig } from '@/eco-configs/eco-config.types'
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import { RebalanceModel } from '@/liquidity-manager/schemas/rebalance.schema'
+import { RebalanceTokenModel } from '@/liquidity-manager/schemas/rebalance-token.schema'
+import {
+  RebalanceQuote,
+  RebalanceRequest,
+  TokenData,
+  TokenDataAnalyzed,
+} from '@/liquidity-manager/types/types'
+
+@Injectable()
+export class LiquidityManagerService implements OnApplicationBootstrap {
+  private config: LiquidityManagerConfig
+  private readonly liquidityManagerQueue: LiquidityManagerQueue
+
+  constructor(
+    @InjectQueue(LiquidityManagerQueue.queueName)
+    queue: LiquidityManagerQueueType,
+    @InjectFlowProducer(LiquidityManagerQueue.flowName)
+    protected liquidityManagerFlowProducer: FlowProducer,
+    @InjectModel(RebalanceModel.name)
+    private readonly rebalanceModel: Model<RebalanceModel>,
+    public readonly balanceService: BalanceService,
+    private readonly ecoConfigService: EcoConfigService,
+    public readonly liquidityProviderManager: LiquidityProviderService,
+  ) {
+    this.liquidityManagerQueue = new LiquidityManagerQueue(queue)
+  }
+
+  onApplicationBootstrap() {
+    this.config = this.ecoConfigService.getLiquidityManager()
+    return this.liquidityManagerQueue.startCronJobs(this.config.intervalDuration)
+  }
+
+  async analyzeTokens() {
+    const tokens: TokenData[] = await this.balanceService.getAllTokenData()
+    const analysis: TokenDataAnalyzed[] = tokens.map((item) => ({
+      ...item,
+      analysis: this.analyzeToken(item),
+    }))
+
+    const groups = groupBy(analysis, (item) => item.analysis.state)
+    return {
+      items: analysis,
+      surplus: analyzeTokenGroup(groups[TokenState.SURPLUS] ?? []),
+      inrange: analyzeTokenGroup(groups[TokenState.IN_RANGE] ?? []),
+      deficit: analyzeTokenGroup(groups[TokenState.DEFICIT] ?? []),
+    }
+  }
+
+  analyzeToken(token: TokenData) {
+    return analyzeToken(token.config, token.balance, {
+      up: this.config.thresholds.surplus,
+      down: this.config.thresholds.deficit,
+      targetSlippage: this.config.targetSlippage,
+    })
+  }
+
+  /**
+   * Gets the optimized rebalancing for the deficit and surplus tokens.
+   * @dev The rebalancing is more efficient if done within the same chain.
+   *      If it's not possible, other chains are considered.
+   * @param deficitToken
+   * @param surplusTokens
+   */
+  async getOptimizedRebalancing(
+    deficitToken: TokenDataAnalyzed,
+    surplusTokens: TokenDataAnalyzed[],
+  ) {
+    const swapQuotes = await this.getSwapQuotes(deficitToken, surplusTokens)
+
+    // Continue with swap quotes if possible
+    if (swapQuotes.length) return swapQuotes
+
+    return this.getRebalancingQuotes(deficitToken, surplusTokens)
+  }
+
+  startRebalancing(rebalances: RebalanceRequest[]) {
+    const jobs = rebalances.map((rebalance) =>
+      RebalanceJobManager.createJob(rebalance, this.liquidityManagerQueue.name),
+    )
+    return this.liquidityManagerFlowProducer.add({
+      name: 'rebalance-batch',
+      queueName: this.liquidityManagerQueue.name,
+      children: jobs,
+    })
+  }
+
+  async executeRebalancing(rebalanceData: RebalanceJobData) {
+    for (const quote of rebalanceData.rebalance.quotes) {
+      await this.liquidityProviderManager.execute(deserialize(quote))
+    }
+  }
+
+  async storeRebalancing(request: RebalanceRequest) {
+    const groupId = uuid()
+    for (const quote of request.quotes) {
+      await this.rebalanceModel.create({
+        groupId,
+        amountIn: quote.amountIn,
+        amountOut: quote.amountOut,
+        slippage: quote.slippage,
+        strategy: quote.strategy,
+        context: quote.context,
+        tokenIn: RebalanceTokenModel.fromTokenData(quote.tokenIn),
+        tokenOut: RebalanceTokenModel.fromTokenData(quote.tokenOut),
+      })
+    }
+  }
+
+  /**
+   * Checks if a swap is possible between the deficit and surplus tokens.
+   * @dev swaps are possible if the deficit is compensated by the surplus of tokens in the same chain.
+   * @param deficitToken
+   * @param surplusTokens
+   * @private
+   */
+  private async getSwapQuotes(deficitToken: TokenDataAnalyzed, surplusTokens: TokenDataAnalyzed[]) {
+    const surplusTokensSameChain = surplusTokens.filter(
+      (token) => token.config.chainId === deficitToken.config.chainId,
+    )
+
+    return this.getRebalancingQuotes(deficitToken, surplusTokensSameChain)
+  }
+
+  /**
+   * Checks if a rebalancing is possible between the deficit and surplus tokens.
+   * @param deficitToken
+   * @param surplusTokens
+   * @private
+   */
+  private async getRebalancingQuotes(
+    deficitToken: TokenDataAnalyzed,
+    surplusTokens: TokenDataAnalyzed[],
+  ) {
+    const sortedSurplusTokens = getSortGroupByDiff(surplusTokens)
+    const surplusTokensTotal = getGroupTotal(sortedSurplusTokens)
+
+    if (deficitToken.analysis.diff > surplusTokensTotal) {
+      // Not enough surplus tokens to rebalance
+      return []
+    }
+
+    const quotes: RebalanceQuote[] = []
+    let currentBalance = deficitToken.analysis.balance.current
+
+    for (const surplusToken of sortedSurplusTokens) {
+      // Calculate the amount to swap
+      const swapAmount = Math.min(deficitToken.analysis.diff, surplusToken.analysis.diff)
+
+      const quote = await this.liquidityProviderManager.getQuote(
+        surplusToken,
+        deficitToken,
+        swapAmount,
+      )
+
+      quotes.push(quote)
+      currentBalance += quote.amountOut
+
+      if (currentBalance >= deficitToken.analysis.targetSlippage.min) break
+    }
+
+    return quotes
+  }
+}

package/src/liquidity-manager/services/liquidity-provider.service.ts

@@ -0,0 +1,25 @@
+import { Injectable } from '@nestjs/common'
+import { LiFiProviderService } from '@/liquidity-manager/services/liquidity-providers/LiFi/lifi-provider.service'
+import { RebalanceQuote, TokenData } from '@/liquidity-manager/types/types'
+
+@Injectable()
+export class LiquidityProviderService {
+  constructor(protected readonly liFiProvider: LiFiProviderService) {}
+
+  async getQuote(
+    tokenIn: TokenData,
+    tokenOut: TokenData,
+    swapAmount: number,
+  ): Promise<RebalanceQuote> {
+    return this.liFiProvider.getQuote(tokenIn, tokenOut, swapAmount)
+  }
+
+  async execute(quote: RebalanceQuote) {
+    switch (quote.strategy) {
+      case 'LiFi':
+        return this.liFiProvider.execute(quote)
+      default:
+        throw new Error(`Strategy not supported: ${quote.strategy}`)
+    }
+  }
+}