eco-solver 0.0.1-security → 1.5.0

package/src/api/api.module.ts

@@ -0,0 +1,27 @@
+import { BalanceController } from '@/api/balance.controller'
+import { QuoteController } from '@/api/quote.controller'
+import { BalanceModule } from '@/balance/balance.module'
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import { QuoteModule } from '@/quote/quote.module'
+import { CacheInterceptor, CacheModule } from '@nestjs/cache-manager'
+import { Module } from '@nestjs/common'
+import { APP_INTERCEPTOR } from '@nestjs/core'
+
+@Module({
+  imports: [
+    BalanceModule,
+    CacheModule.registerAsync({
+      useFactory: async (configService: EcoConfigService) => configService.getCache(),
+      inject: [EcoConfigService],
+    }),
+    QuoteModule,
+  ],
+  controllers: [BalanceController, QuoteController],
+  providers: [
+    {
+      provide: APP_INTERCEPTOR,
+      useClass: CacheInterceptor,
+    },
+  ],
+})
+export class ApiModule {}

package/src/api/balance.controller.ts

@@ -0,0 +1,41 @@
+import { BalanceService } from '@/balance/balance.service'
+import { TokenBalance, TokenConfig } from '@/balance/types'
+import { API_ROOT, BALANCE_ROUTE } from '@/common/routes/constants'
+import { convertBigIntsToStrings } from '@/common/viem/utils'
+import { CacheInterceptor } from '@nestjs/cache-manager'
+import { Controller, Get, Query, UseInterceptors } from '@nestjs/common'
+import * as _ from 'lodash'
+
+@Controller(API_ROOT + BALANCE_ROUTE)
+@UseInterceptors(CacheInterceptor)
+export class BalanceController {
+  constructor(private readonly balanceService: BalanceService) {}
+
+  @Get()
+  async getBalances(@Query('flat') flat?: boolean) {
+    const data = await this.balanceService.getAllTokenData()
+    if (flat) {
+      return convertBigIntsToStrings(this.groupTokensByChain(data))
+    }
+    return convertBigIntsToStrings(data)
+  }
+
+  groupTokensByChain(
+    data: {
+      config: TokenConfig
+      balance: TokenBalance
+      chainId: number
+    }[],
+  ) {
+    // Group tokens by the chainId property.
+    const grouped = _.groupBy(data, 'chainId')
+
+    // For each chainId group, map the tokens to only include token address and balance.
+    return _.mapValues(grouped, (tokens) =>
+      tokens.map((token) => ({
+        address: token.balance.address,
+        balance: token.balance.balance,
+      })),
+    )
+  }
+}

package/src/api/quote.controller.ts

@@ -0,0 +1,54 @@
+import { EcoLogMessage } from '@/common/logging/eco-log-message'
+import { API_ROOT, QUOTE_ROUTE } from '@/common/routes/constants'
+import { serialize } from '@/liquidity-manager/utils/serialize'
+import { QuoteIntentDataDTO } from '@/quote/dto/quote.intent.data.dto'
+import { QuoteErrorsInterface } from '@/quote/errors'
+import { QuoteService } from '@/quote/quote.service'
+import {
+  BadRequestException,
+  Body,
+  Controller,
+  InternalServerErrorException,
+  Logger,
+  Post,
+} from '@nestjs/common'
+
+@Controller(API_ROOT + QUOTE_ROUTE)
+export class QuoteController {
+  private logger = new Logger(QuoteController.name)
+
+  constructor(private readonly quoteService: QuoteService) {}
+
+  @Post()
+  async getQuote(@Body() quoteIntentDataDTO: QuoteIntentDataDTO) {
+    this.logger.log(
+      EcoLogMessage.fromDefault({
+        message: `Received quote request:`,
+        properties: {
+          quoteIntentDataDTO,
+        },
+      }),
+    )
+    const quote = await this.quoteService.getQuote(quoteIntentDataDTO)
+    this.logger.log(
+      EcoLogMessage.fromDefault({
+        message: `Responding to quote request:`,
+        properties: {
+          quote,
+        },
+      }),
+    )
+
+    const errorStatus = (quote as QuoteErrorsInterface).statusCode
+    if (errorStatus) {
+      switch (errorStatus) {
+        case 400:
+          throw new BadRequestException(serialize(quote))
+        case 500:
+        default:
+          throw new InternalServerErrorException(serialize(quote))
+      }
+    }
+    return quote
+  }
+}

package/src/api/tests/balance.controller.spec.ts

@@ -0,0 +1,113 @@
+import { Test, TestingModule } from '@nestjs/testing'
+import { BalanceController } from '../balance.controller'
+import { BalanceService } from '@/balance/balance.service'
+import { CACHE_MANAGER } from '@nestjs/cache-manager'
+import { createMock } from '@golevelup/ts-jest'
+
+describe('BalanceController Test', () => {
+  let balanceController: BalanceController
+  let balanceService: BalanceService
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [BalanceController],
+      providers: [
+        {
+          provide: BalanceService,
+          useValue: createMock<BalanceService>(),
+        },
+        {
+          provide: CACHE_MANAGER,
+          useValue: {
+            get: jest.fn(),
+            set: jest.fn(),
+          },
+        },
+      ],
+    }).compile()
+
+    balanceController = module.get<BalanceController>(BalanceController)
+    balanceService = module.get<BalanceService>(BalanceService)
+  })
+
+  it('should be defined', () => {
+    expect(balanceController).toBeDefined()
+  })
+
+  describe('getBalances', () => {
+    it('should return an array of balances', async () => {
+      const result = []
+      jest.spyOn(balanceService, 'getAllTokenData').mockResolvedValue(result)
+
+      expect(await balanceController.getBalances()).toEqual(result)
+    })
+
+    it('should call balanceService.getAllTokenData', async () => {
+      const getAllTokenDataSpy = jest.spyOn(balanceService, 'getAllTokenData').mockResolvedValue([])
+
+      await balanceController.getBalances()
+
+      expect(getAllTokenDataSpy).toHaveBeenCalled()
+    })
+
+    it('should take the flat query param', async () => {
+      const getAllTokenDataSpy = jest.spyOn(balanceService, 'getAllTokenData').mockResolvedValue([])
+      const groupSpy = jest.spyOn(balanceController, 'groupTokensByChain')
+      await balanceController.getBalances(true)
+
+      expect(getAllTokenDataSpy).toHaveBeenCalled()
+      expect(groupSpy).toHaveBeenCalled()
+    })
+  })
+
+  describe('groupTokensByChain', () => {
+    it('should flatten', async () => {
+      const data = [
+        {
+          balance: {
+            address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+            balance: '50995350000',
+            decimals: 6,
+          },
+          chainId: 1,
+        },
+        {
+          config: {
+            address: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
+            chainId: 1,
+          },
+          balance: {
+            address: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
+            balance: '50000000000',
+            decimals: 6,
+          },
+          chainId: 1,
+        },
+        {
+          config: {
+            address: '0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9',
+            chainId: 42161,
+            type: 'erc20',
+            minBalance: 200,
+            targetBalance: 50000,
+          },
+          balance: {
+            address: '0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9',
+            balance: '25368636844',
+            decimals: 6,
+          },
+          chainId: 42161,
+        },
+      ] as any
+
+      const result = balanceController.groupTokensByChain(data)
+      expect(result).toEqual({
+        1: [
+          { address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', balance: '50995350000' },
+          { address: '0xdAC17F958D2ee523a2206206994597C13D831ec7', balance: '50000000000' },
+        ],
+        42161: [{ address: '0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9', balance: '25368636844' }],
+      })
+    })
+  })
+})

package/src/api/tests/quote.controller.spec.ts

@@ -0,0 +1,83 @@
+import { Test, TestingModule } from '@nestjs/testing'
+import { CACHE_MANAGER } from '@nestjs/cache-manager'
+import { createMock } from '@golevelup/ts-jest'
+import { QuoteController } from '@/api/quote.controller'
+import { QuoteService } from '@/quote/quote.service'
+import { InternalSaveError, SolverUnsupported } from '@/quote/errors'
+import { BadRequestException, InternalServerErrorException } from '@nestjs/common'
+import { serialize } from '@/liquidity-manager/utils/serialize'
+
+describe('QuoteController Test', () => {
+  let quoteController: QuoteController
+  let quoteService: QuoteService
+  const mockLogLog = jest.fn()
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [QuoteController],
+      providers: [
+        {
+          provide: QuoteService,
+          useValue: createMock<QuoteService>(),
+        },
+        {
+          provide: CACHE_MANAGER,
+          useValue: {
+            get: jest.fn(),
+            set: jest.fn(),
+          },
+        },
+      ],
+    }).compile()
+
+    quoteController = module.get(QuoteController)
+    quoteService = module.get(QuoteService)
+
+    quoteController['logger'].log = mockLogLog
+  })
+
+  afterEach(async () => {
+    // restore the spy created with spyOn
+    jest.restoreAllMocks()
+    mockLogLog.mockClear()
+  })
+
+  it('should be defined', () => {
+    expect(quoteController).toBeDefined()
+  })
+
+  describe('getQuote', () => {
+    const quote = {
+      tokens: [
+        {
+          address: '0x123',
+          amount: 100n,
+        },
+      ],
+      expiryTime: 0,
+    }
+    it('should return a 400 on bad request', async () => {
+      jest.spyOn(quoteService, 'getQuote').mockResolvedValue(SolverUnsupported)
+      await expect(quoteController.getQuote({} as any)).rejects.toThrow(
+        new BadRequestException(serialize(SolverUnsupported)),
+      )
+    })
+
+    it('should return a 500 on server error', async () => {
+      jest.spyOn(quoteService, 'getQuote').mockResolvedValue(InternalSaveError(quote as any))
+      jest.spyOn(quoteService, 'storeQuoteIntentData').mockResolvedValue(quote as any)
+      await expect(quoteController.getQuote({} as any)).rejects.toThrow(
+        new InternalServerErrorException(InternalSaveError(quote as any)),
+      )
+    })
+
+    it('should log and return a quote', async () => {
+      jest.spyOn(quoteService, 'getQuote').mockResolvedValue(quote as any)
+
+      const result = await quoteController.getQuote({} as any)
+      expect(result).toEqual(quote)
+      expect(quoteService.getQuote).toHaveBeenCalled()
+      expect(mockLogLog).toHaveBeenCalledTimes(2)
+    })
+  })
+})

package/src/app.module.ts

@@ -0,0 +1,74 @@
+import { Module } from '@nestjs/common'
+import { LoggerModule } from 'nestjs-pino'
+import { MongooseModule } from '@nestjs/mongoose'
+import { LiquidityManagerModule } from '@/liquidity-manager/liquidity-manager.module'
+import { ApiModule } from '@/api/api.module'
+import { WatchModule } from '@/watch/watch.module'
+import { IntervalModule } from '@/intervals/interval.module'
+import { QuoteModule } from '@/quote/quote.module'
+import { FeeModule } from '@/fee/fee.module'
+import { KmsModule } from '@/kms/kms.module'
+import { BalanceModule } from '@/balance/balance.module'
+import { ChainMonitorModule } from '@/chain-monitor/chain-monitor.module'
+import { EcoConfigModule } from '@/eco-configs/eco-config.module'
+import { FlagsModule } from '@/flags/flags.module'
+import { HealthModule } from '@/health/health.module'
+import { IntentModule } from '@/intent/intent.module'
+import { SignModule } from '@/sign/sign.module'
+import { ProcessorModule } from '@/bullmq/processors/processor.module'
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import { ProverModule } from '@/prover/prover.module'
+import { SolverModule } from '@/solver/solver.module'
+
+@Module({
+  imports: [
+    ApiModule,
+    BalanceModule,
+    ChainMonitorModule,
+    EcoConfigModule.withAWS(),
+    FeeModule,
+    FlagsModule,
+    HealthModule,
+    IntentModule,
+    KmsModule,
+    SignModule,
+    IntervalModule,
+    ProcessorModule,
+    MongooseModule.forRootAsync({
+      inject: [EcoConfigService],
+      useFactory: async (configService: EcoConfigService) => {
+        const uri = configService.getMongooseUri()
+        return {
+          uri,
+        }
+      },
+    }),
+    ProverModule,
+    QuoteModule,
+    SolverModule,
+    LiquidityManagerModule,
+    WatchModule,
+    ...getPino(),
+  ],
+  controllers: [],
+})
+export class AppModule {}
+
+/**
+ * Returns the Pino module if the configs have it on ( its off in dev )
+ */
+function getPino() {
+  return EcoConfigService.getStaticConfig().logger.usePino
+    ? [
+        LoggerModule.forRootAsync({
+          inject: [EcoConfigService],
+          useFactory: async (configService: EcoConfigService) => {
+            const loggerConfig = configService.getLoggerConfig()
+            return {
+              pinoHttp: loggerConfig.pinoConfig.pinoHttp,
+            }
+          },
+        }),
+      ]
+    : []
+}

package/src/balance/balance.module.ts

@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common'
+import { BalanceService } from './balance.service'
+import { initBullMQ } from '../bullmq/bullmq.helper'
+import { QUEUES } from '../common/redis/constants'
+import { BalanceWebsocketService } from './balance.ws.service'
+import { TransactionModule } from '../transaction/transaction.module'
+import { CacheModule } from '@nestjs/cache-manager'
+
+@Module({
+  imports: [TransactionModule, initBullMQ(QUEUES.ETH_SOCKET), CacheModule.register()],
+  providers: [BalanceService, BalanceWebsocketService],
+  exports: [BalanceService],
+})
+export class BalanceModule {}

package/src/balance/balance.service.ts

@@ -0,0 +1,230 @@
+import { Inject, Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common'
+import { groupBy, zipWith } from 'lodash'
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import { getDestinationNetworkAddressKey } from '@/common/utils/strings'
+import { EcoLogMessage } from '@/common/logging/eco-log-message'
+import { erc20Abi, Hex, MulticallParameters, MulticallReturnType } from 'viem'
+import { ViemEventLog } from '@/common/events/viem'
+import { decodeTransferLog, isSupportedTokenType } from '@/contracts'
+import { KernelAccountClientService } from '@/transaction/smart-wallets/kernel/kernel-account-client.service'
+import { TokenBalance, TokenConfig } from '@/balance/types'
+import { EcoError } from '@/common/errors/eco-error'
+import { Cache, CACHE_MANAGER } from '@nestjs/cache-manager'
+import { Cacheable } from '@/decorators/cacheable.decorator'
+
+/**
+ * Composite data from fetching the token balances for a chain
+ */
+export type TokenFetchAnalysis = {
+  config: TokenConfig
+  token: TokenBalance
+  chainId: number
+}
+
+/**
+ * Service class for getting configs for the app
+ */
+@Injectable()
+export class BalanceService implements OnApplicationBootstrap {
+  private logger = new Logger(BalanceService.name)
+
+  private readonly tokenBalances: Map<string, TokenBalance> = new Map()
+
+  constructor(
+    @Inject(CACHE_MANAGER) private cacheManager: Cache,
+    private readonly configService: EcoConfigService,
+    private readonly kernelAccountClientService: KernelAccountClientService,
+  ) {}
+
+  async onApplicationBootstrap() {
+    // iterate over all tokens
+    await Promise.all(this.getInboxTokens().map((token) => this.loadTokenBalance(token)))
+  }
+
+  /**
+   * Get the token balance of the solver
+   * @returns
+   */
+  async getTokenBalance(chainID: number, tokenAddress: Hex) {
+    return (
+      this.tokenBalances.get(getDestinationNetworkAddressKey(chainID, tokenAddress)) ?? {
+        balance: 0n,
+        decimals: 0n,
+      }
+    )
+  }
+
+  /**
+   * Updates the token balance of the solver, called from {@link EthWebsocketProcessor}
+   * @returns
+   */
+  updateBalance(balanceEvent: ViemEventLog) {
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `updateBalance ${balanceEvent.transactionHash}`,
+        properties: {
+          intentHash: balanceEvent.transactionHash,
+        },
+      }),
+    )
+
+    const intent = decodeTransferLog(balanceEvent.data, balanceEvent.topics)
+    const key = getDestinationNetworkAddressKey(balanceEvent.sourceChainID, balanceEvent.address)
+    const balanceObj = this.tokenBalances.get(key)
+    if (balanceObj) {
+      balanceObj.balance = balanceObj.balance + intent.args.value
+    }
+  }
+
+  /**
+   * Gets the tokens that are in the solver wallets
+   * @returns List of tokens that are supported by the solver
+   */
+  getInboxTokens(): TokenConfig[] {
+    return Object.values(this.configService.getSolvers()).flatMap((solver) => {
+      return Object.entries(solver.targets)
+        .filter(([, targetContract]) => isSupportedTokenType(targetContract.contractType))
+        .map(([tokenAddress, targetContract]) => ({
+          address: tokenAddress as Hex,
+          chainId: solver.chainID,
+          type: targetContract.contractType,
+          minBalance: targetContract.minBalance,
+          targetBalance: targetContract.targetBalance,
+        }))
+    })
+  }
+
+  /**
+   * Fetches the balances of the kernel account client of the solver for the given tokens
+   * @param chainID the chain id
+   * @param tokenAddresses the tokens to fetch balances for
+   * @returns
+   */
+  @Cacheable()
+  async fetchTokenBalances(
+    chainID: number,
+    tokenAddresses: Hex[],
+  ): Promise<Record<Hex, TokenBalance>> {
+    const client = await this.kernelAccountClientService.getClient(chainID)
+    const walletAddress = client.kernelAccount.address
+
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `fetchTokenBalances`,
+        properties: {
+          chainID,
+          tokenAddresses,
+          walletAddress,
+        },
+      }),
+    )
+
+    const results = (await client.multicall({
+      contracts: tokenAddresses.flatMap((tokenAddress): MulticallParameters['contracts'] => [
+        {
+          abi: erc20Abi,
+          address: tokenAddress,
+          functionName: 'balanceOf',
+          args: [walletAddress],
+        },
+        {
+          abi: erc20Abi,
+          address: tokenAddress,
+          functionName: 'decimals',
+        },
+      ]),
+      allowFailure: false,
+    })) as MulticallReturnType
+
+    const tokenBalances: Record<Hex, TokenBalance> = {}
+
+    tokenAddresses.forEach((tokenAddress, index) => {
+      const [balance = 0n, decimals = 0] = [results[index * 2], results[index * 2 + 1]]
+      //throw if we suddenly start supporting tokens with not 6 decimals
+      //audit conversion of validity to see its support
+      if ((decimals as number) != 6) {
+        throw EcoError.BalanceServiceInvalidDecimals(tokenAddress)
+      }
+      tokenBalances[tokenAddress] = {
+        address: tokenAddress,
+        balance: balance as bigint,
+        decimals: decimals as number,
+      }
+    })
+    return tokenBalances
+  }
+
+  @Cacheable()
+  async fetchTokenBalance(chainID: number, tokenAddress: Hex): Promise<TokenBalance> {
+    const result = await this.fetchTokenBalances(chainID, [tokenAddress])
+    return result[tokenAddress]
+  }
+
+  @Cacheable()
+  async fetchTokenBalancesForChain(
+    chainID: number,
+  ): Promise<Record<Hex, TokenBalance> | undefined> {
+    const intentSource = this.configService.getIntentSource(chainID)
+    if (!intentSource) {
+      return undefined
+    }
+    return this.fetchTokenBalances(chainID, intentSource.tokens)
+  }
+
+  @Cacheable()
+  async fetchTokenData(chainID: number): Promise<TokenFetchAnalysis[]> {
+    const tokenConfigs = groupBy(this.getInboxTokens(), 'chainId')[chainID]
+    const tokenAddresses = tokenConfigs.map((token) => token.address)
+    const tokenBalances = await this.fetchTokenBalances(chainID, tokenAddresses)
+    return zipWith(tokenConfigs, Object.values(tokenBalances), (config, token) => ({
+      config,
+      token,
+      chainId: chainID,
+    }))
+  }
+
+  @Cacheable()
+  async getAllTokenData() {
+    const tokens = this.getInboxTokens()
+    const tokensByChainId = groupBy(tokens, 'chainId')
+    const chainIds = Object.keys(tokensByChainId)
+
+    const balancesPerChainIdPromise = chainIds.map(async (chainId) => {
+      const configs = tokensByChainId[chainId]
+      const tokenAddresses = configs.map((token) => token.address)
+      const balances = await this.fetchTokenBalances(parseInt(chainId), tokenAddresses)
+      return zipWith(configs, Object.values(balances), (config, balance) => ({
+        config,
+        balance,
+        chainId: parseInt(chainId),
+      }))
+    })
+
+    return Promise.all(balancesPerChainIdPromise).then((result) => result.flat())
+  }
+
+  /**
+   * Loads the token balance of the solver
+   * @returns
+   */
+  private async loadTokenBalance(token: TokenConfig) {
+    switch (token.type) {
+      case 'erc20':
+        return this.loadERC20TokenBalance(token.chainId, token.address)
+      default:
+        throw EcoError.IntentSourceUnsupportedTargetType(token.type)
+    }
+  }
+
+  private async loadERC20TokenBalance(
+    chainID: number,
+    tokenAddress: Hex,
+  ): Promise<TokenBalance | undefined> {
+    const key = getDestinationNetworkAddressKey(chainID, tokenAddress)
+    if (!this.tokenBalances.has(key)) {
+      const tokenBalance = await this.fetchTokenBalance(chainID, tokenAddress)
+      this.tokenBalances.set(key, tokenBalance)
+    }
+    return this.tokenBalances.get(key)
+  }
+}