eco-solver 0.0.1-security → 1.5.2

package/src/fee/tests/utils.spec.ts

@@ -0,0 +1,49 @@
+import { normalizeBalance } from '@/fee/utils'
+
+describe('Utils Tests', () => {
+  describe('normalizeBalance', () => {
+    it('should throw if decimals are not integers', () => {
+      expect(() => normalizeBalance({ balance: 1n, decimal: 1.5 }, 1)).toThrow(
+        new Error('Decimal values must be integers'),
+      )
+      expect(() => normalizeBalance({ balance: 1n, decimal: 1 }, 1.5)).toThrow(
+        new Error('Decimal values must be integers'),
+      )
+      expect(() => normalizeBalance({ balance: 1n, decimal: 1.5 }, 1.5)).toThrow(
+        new Error('Decimal values must be integers'),
+      )
+    })
+
+    it('should return the same value if current and target decimals are the same', () => {
+      expect(normalizeBalance({ balance: 1234n, decimal: 6 }, 6)).toEqual({
+        balance: 1234n,
+        decimal: 6,
+      })
+    })
+
+    it('should scale up', () => {
+      expect(normalizeBalance({ balance: 10_000n, decimal: 4 }, 6)).toEqual({
+        balance: 1_000_000n,
+        decimal: 6,
+      })
+    })
+
+    it('should scale down', () => {
+      expect(normalizeBalance({ balance: 1_000_000n, decimal: 6 }, 4)).toEqual({
+        balance: 10_000n,
+        decimal: 4,
+      })
+    })
+
+    it('should work with zero', () => {
+      expect(normalizeBalance({ balance: 1n, decimal: 0 }, 3)).toEqual({
+        balance: 1_000n,
+        decimal: 3,
+      })
+      expect(normalizeBalance({ balance: 100n, decimal: 2 }, 0)).toEqual({
+        balance: 1n,
+        decimal: 0,
+      })
+    })
+  })
+})

package/src/fee/types.ts

@@ -0,0 +1,44 @@
+import { TokenFetchAnalysis } from '@/balance/balance.service'
+import { RewardTokensInterface } from '@/contracts'
+import { Solver } from '@/eco-configs/eco-config.types'
+import { Hex, Prettify } from 'viem'
+/**
+ * The response quote data
+ */
+export interface QuoteData {
+  tokens: RewardTokensInterface[]
+  expiryTime: string
+}
+
+/**
+ * The normalized tokens for the quote intent
+ */
+export interface NormalizedTokens {
+  rewardTokens: RewardTokensInterface[]
+  callTokens: RewardTokensInterface[]
+}
+
+/**
+ * The normalized token type
+ */
+export type NormalizedToken = {
+  balance: bigint
+  chainID: bigint
+  address: Hex
+  decimals: number
+}
+
+/**
+ * The type for the token fetch analysis with the normalized delta
+ */
+export type DeficitDescending = Prettify<TokenFetchAnalysis & { delta: NormalizedToken }>
+
+/**
+ * The type for the calculated tokens
+ */
+export type CalculateTokensType = {
+  solver: Solver
+  rewards: NormalizedToken[]
+  calls: NormalizedToken[]
+  deficitDescending: DeficitDescending[]
+}

package/src/fee/utils.ts

@@ -0,0 +1,23 @@
+type BalanceObject = {
+  balance: bigint
+  decimal: number
+}
+
+/**
+ * Normalizes the balance to a new decimal precision.
+ */
+export function normalizeBalance(value: BalanceObject, targetDecimal: number): BalanceObject {
+  if (!Number.isInteger(value.decimal) || !Number.isInteger(targetDecimal)) {
+    throw new Error('Decimal values must be integers')
+  }
+  const scaleFactor = BigInt(10 ** Math.abs(targetDecimal - value.decimal))
+
+  let newBalance: bigint
+  if (targetDecimal > value.decimal) {
+    newBalance = value.balance * scaleFactor // Scale up
+  } else {
+    newBalance = value.balance / scaleFactor // Scale down
+  }
+
+  return { balance: newBalance, decimal: targetDecimal }
+}

package/src/flags/flags.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common'
+import { FlagService } from './flags.service'
+import { TransactionModule } from '../transaction/transaction.module'
+
+@Module({
+  imports: [TransactionModule],
+  providers: [FlagService],
+  exports: [FlagService],
+})
+export class FlagsModule {}

package/src/flags/flags.service.ts

@@ -0,0 +1,112 @@
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common'
+import { EcoConfigService } from '../eco-configs/eco-config.service'
+import * as ld from '@launchdarkly/node-server-sdk'
+import { KernelAccountClientService } from '../transaction/smart-wallets/kernel/kernel-account-client.service'
+import { EcoLogMessage } from '../common/logging/eco-log-message'
+import { waitForInitialization } from './utils'
+
+export type LaunchDarklyFlags = {
+  bendWalletOnly: boolean
+}
+
+export type FlagType = keyof LaunchDarklyFlags
+
+export const FlagVariationKeys: Record<FlagType, string> = {
+  bendWalletOnly: 'bendWalletOnly',
+}
+
+/**
+ * Service class for interacting with the Launch Darkly feature flagging service
+ */
+@Injectable()
+export class FlagService implements OnModuleInit {
+  private logger = new Logger(FlagService.name)
+  private flagsClient: ld.LDClient
+  private context: ld.LDContext
+  private flagValues: LaunchDarklyFlags = {
+    bendWalletOnly: false,
+  }
+  constructor(
+    private readonly kernelAccountService: KernelAccountClientService,
+    private readonly ecoConfigService: EcoConfigService,
+  ) {}
+
+  async onModuleInit() {
+    await this.initLaunchDarklyClient()
+    this.registerFlagListeners()
+  }
+
+  public getFlagValue<T extends FlagType>(flag: T): LaunchDarklyFlags[T] {
+    return this.flagValues[flag]
+  }
+
+  public static isSupportedFlag(flag: string): boolean {
+    return Object.keys(FlagVariationKeys).includes(flag)
+  }
+
+  /**
+   * Initializes the Launch Darkly client with the provided API key. Sets an
+   * on ready listener to initialize the flags
+   */
+  private async initLaunchDarklyClient() {
+    this.context = { kind: 'solver-pod', key: await this.kernelAccountService.getAddress() }
+    this.flagsClient = ld.init(this.ecoConfigService.getLaunchDarkly().apiKey)
+    const lock = { initialized: false }
+    this.flagsClient.on('ready', async () => {
+      await Promise.all(
+        Object.values(FlagVariationKeys).map(async (flag) => {
+          this.flagValues[flag] = await this.flagsClient.variation(
+            flag,
+            this.context,
+            this.flagValues[flag],
+          )
+        }),
+      )
+      lock.initialized = true
+      this.logger.log(
+        EcoLogMessage.fromDefault({
+          message: `FlagService ready`,
+          properties: {
+            flags: this.flagValues,
+          },
+        }),
+      )
+    })
+    // Wait for the flags to be initialized
+    await waitForInitialization(lock)
+  }
+
+  /**
+   * Registers update listeners for when flags are updated. Also occures on first init
+   */
+  private registerFlagListeners() {
+    this.flagsClient.on('update', async (param) => {
+      if (!FlagService.isSupportedFlag(param.key)) {
+        this.logger.log(
+          EcoLogMessage.fromDefault({
+            message: `FlagService update: unsupported flag`,
+            properties: {
+              flagName: param.key,
+            },
+          }),
+        )
+        return
+      }
+      const flag = param.key
+      this.flagValues[flag] = await this.flagsClient.variation(
+        flag,
+        this.context,
+        this.flagValues[flag],
+      )
+      this.logger.log(
+        EcoLogMessage.fromDefault({
+          message: `FlagService update`,
+          properties: {
+            flagName: flag,
+            flag: this.flagValues[flag],
+          },
+        }),
+      )
+    })
+  }
+}

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

@@ -0,0 +1,68 @@
+const mockInit = jest.fn()
+const mockWait = jest.fn()
+import { Test, TestingModule } from '@nestjs/testing'
+import { FlagService, FlagVariationKeys } from '../flags.service'
+import { KernelAccountClientService } from '../../transaction/smart-wallets/kernel/kernel-account-client.service'
+import { createMock } from '@golevelup/ts-jest'
+import { EcoConfigService } from '../../eco-configs/eco-config.service'
+
+jest.mock('@launchdarkly/node-server-sdk', () => {
+  return {
+    ...jest.requireActual('@launchdarkly/node-server-sdk'),
+    init: mockInit,
+  }
+})
+
+jest.mock('../utils', () => {
+  return {
+    ...jest.requireActual('../utils'),
+    waitForInitialization: mockWait,
+  }
+})
+
+describe('Flags', () => {
+  let flagService: FlagService
+  const mockLogDebug = jest.fn()
+  const mockLogLog = jest.fn()
+  const mockVariation = jest.fn()
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        FlagService,
+        { provide: EcoConfigService, useValue: createMock<EcoConfigService>() },
+        { provide: KernelAccountClientService, useValue: createMock<KernelAccountClientService>() },
+      ],
+    }).compile()
+    //turn off the services from logging durring testing
+    module.useLogger(false)
+    flagService = module.get<FlagService>(FlagService)
+
+    flagService['logger'].debug = mockLogDebug
+    flagService['logger'].log = mockLogLog
+
+    mockInit.mockReturnValue({ on: jest.fn(), variation: mockVariation })
+  })
+
+  afterEach(async () => {
+    // restore the spy created with spyOn
+    jest.restoreAllMocks()
+    mockLogDebug.mockClear()
+    mockLogLog.mockClear()
+    mockInit.mockClear()
+    mockVariation.mockClear()
+    mockWait.mockClear()
+  })
+
+  describe('onModuleInit', () => {
+    it('should init the launch darkly sdk', async () => {
+      await flagService.onModuleInit()
+      expect(mockInit).toHaveBeenCalledTimes(1)
+    })
+
+    it('should wait for initialization', async () => {
+      await flagService.onModuleInit()
+      expect(mockWait).toHaveBeenCalledTimes(1)
+    })
+  })
+})

package/src/flags/utils.ts

@@ -0,0 +1,22 @@
+/**
+ * Waits for initialization to be set
+ * @param lock the lock to wait for
+ * @param interval the interval to check the variable, default 100ms
+ * @param timeout the max time to wait before throwing an error, default 10s
+ */
+export async function waitForInitialization(
+  lock: { initialized: boolean },
+  interval: number = 100,
+  timeout: number = 10000,
+) {
+  let timeSpent = 0
+  while (!lock.initialized) {
+    await new Promise((resolve) => setTimeout(resolve, interval))
+
+    if (timeSpent > timeout) {
+      throw new Error(`Timeout waiting for initialization`)
+    } else {
+      timeSpent += interval
+    }
+  }
+}

package/src/health/constants.ts

@@ -0,0 +1 @@
+export const HealthPath = '/health'

package/src/health/health.controller.ts

@@ -0,0 +1,23 @@
+import { Controller, Get, Logger } from '@nestjs/common'
+import { HealthCheck } from '@nestjs/terminus'
+import { HealthPath } from './constants'
+import { HealthService } from './health.service'
+import { API_ROOT } from '../common/routes/constants'
+import { EcoLogMessage } from '../common/logging/eco-log-message'
+
+@Controller(API_ROOT)
+export class HealthController {
+  private logger = new Logger(HealthController.name)
+  constructor(private healthService: HealthService) {}
+
+  @Get(HealthPath)
+  @HealthCheck()
+  check() {
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `HealthController`,
+      }),
+    )
+    return this.healthService.checkHealth()
+  }
+}

package/src/health/health.module.ts

@@ -0,0 +1,25 @@
+import { Module } from '@nestjs/common'
+import { TerminusModule } from '@nestjs/terminus'
+import { RedisHealthModule } from '@liaoliaots/nestjs-redis-health'
+import { TransactionModule } from '@/transaction/transaction.module'
+import { HealthController } from '@/health/health.controller'
+import { HealthService } from '@/health/health.service'
+import { BalanceHealthIndicator } from '@/health/indicators/balance.indicator'
+import { EcoRedisHealthIndicator } from '@/health/indicators/eco-redis.indicator'
+import { GitCommitHealthIndicator } from '@/health/indicators/git-commit.indicator'
+import { PermissionHealthIndicator } from '@/health/indicators/permission.indicator'
+import { MongoDBHealthIndicator } from '@/health/indicators/mongodb.indicator'
+
+@Module({
+  imports: [TransactionModule, RedisHealthModule, TerminusModule],
+  controllers: [HealthController],
+  providers: [
+    HealthService,
+    BalanceHealthIndicator,
+    EcoRedisHealthIndicator,
+    GitCommitHealthIndicator,
+    PermissionHealthIndicator,
+    MongoDBHealthIndicator,
+  ],
+})
+export class HealthModule {}

package/src/health/health.service.ts

@@ -0,0 +1,40 @@
+import { Injectable, Logger } from '@nestjs/common'
+
+import { HealthCheckService } from '@nestjs/terminus'
+
+import { BalanceHealthIndicator } from './indicators/balance.indicator'
+import { EcoRedisHealthIndicator } from './indicators/eco-redis.indicator'
+import { MongoDBHealthIndicator } from './indicators/mongodb.indicator'
+import { EcoLogMessage } from '../common/logging/eco-log-message'
+import { GitCommitHealthIndicator } from './indicators/git-commit.indicator'
+
+@Injectable()
+export class HealthService {
+  private logger = new Logger(HealthService.name)
+
+  constructor(
+    private readonly health: HealthCheckService,
+    private readonly balanceIndicator: BalanceHealthIndicator,
+    private readonly gitCommitHealthIndicator: GitCommitHealthIndicator,
+    private readonly mongoDBHealthIndicator: MongoDBHealthIndicator,
+    private readonly redisIndicator: EcoRedisHealthIndicator,
+  ) {}
+
+  async checkHealth() {
+    const healthCheck = await this.health.check([
+      () => this.gitCommitHealthIndicator.gitCommit(),
+      () => this.redisIndicator.checkRedis(),
+      () => this.mongoDBHealthIndicator.checkMongoDB(),
+      () => this.balanceIndicator.checkBalances(),
+    ])
+    this.logger.log(
+      EcoLogMessage.fromDefault({
+        message: `HealthService.checkHealth()`,
+        properties: {
+          healthCheck: healthCheck,
+        },
+      }),
+    )
+    return healthCheck
+  }
+}

package/src/health/indicators/balance.indicator.ts

@@ -0,0 +1,196 @@
+import { Injectable, Logger } from '@nestjs/common'
+import { HealthCheckError, HealthIndicator, HealthIndicatorResult } from '@nestjs/terminus'
+import { EcoConfigService } from '../../eco-configs/eco-config.service'
+import { erc20Abi, Hex } from 'viem'
+import { Network } from 'alchemy-sdk'
+import { entries } from 'lodash'
+import { TargetContract } from '../../eco-configs/eco-config.types'
+import { KernelAccountClientService } from '../../transaction/smart-wallets/kernel/kernel-account-client.service'
+
+type TokenType = { decimal: string; value: string; minBalances?: number }
+@Injectable()
+export class BalanceHealthIndicator extends HealthIndicator {
+  private logger = new Logger(BalanceHealthIndicator.name)
+  constructor(
+    private readonly kernelAccountClientService: KernelAccountClientService,
+    private readonly configService: EcoConfigService,
+  ) {
+    super()
+  }
+  async checkBalances(): Promise<HealthIndicatorResult> {
+    const minEthBalanceWei = this.configService.getEth().simpleAccount.minEthBalanceWei
+    const [accounts, solvers, sources] = await Promise.all([
+      this.getAccount(),
+      this.getSolvers(),
+      this.getSources(),
+    ])
+    let isHealthy = solvers.balances.every((solver) => {
+      const tokens = solver.tokens
+      return Object.values(tokens).every((token) => {
+        if (!token.minBalances) {
+          return true
+        }
+        const minBalanceDecimal = BigInt(token.minBalances) * BigInt(token.decimal) * 10n
+        return BigInt(token.value) >= minBalanceDecimal
+      })
+    })
+
+    isHealthy =
+      isHealthy &&
+      accounts.every((bal) => {
+        return BigInt(bal.balance) >= minEthBalanceWei
+      })
+    const results = this.getStatus('balances', isHealthy, {
+      totalBalance: solvers.totalTokenBalance,
+      accounts,
+      solvers: solvers.balances,
+      sources,
+    })
+    if (isHealthy) {
+      return results
+    }
+    throw new HealthCheckError('Balances failed', results)
+  }
+  private async getAccount(): Promise<any[]> {
+    const minEthBalanceWei = this.configService.getEth().simpleAccount.minEthBalanceWei
+    const accountBalance: {
+      kernelAddress: `0x${string}`
+      eocAddress: `0x${string}`
+      chainID: number
+      balance: string
+      minEthBalanceWei: number
+    }[] = []
+    const solvers = this.configService.getSolvers()
+    const balanceTasks = entries(solvers).map(async ([, solver]) => {
+      const clientKernel = await this.kernelAccountClientService.getClient(solver.chainID)
+      const kernelAddress = clientKernel.kernelAccount?.address
+      const eocAddress = clientKernel.account?.address
+
+      if (eocAddress && kernelAddress) {
+        const bal = await clientKernel.getBalance({ address: eocAddress })
+        accountBalance.push({
+          kernelAddress,
+          eocAddress,
+          chainID: solver.chainID,
+          balance: '        ' + BigInt(bal).toString(), //makes comparing easier in json
+          minEthBalanceWei,
+        })
+      }
+    })
+    await Promise.all(balanceTasks)
+
+    return accountBalance.reverse()
+  }
+
+  private async getSources(): Promise<any[]> {
+    const sources: Array<{
+      accountAddress: `0x${string}` | undefined
+      tokens: Record<string, TokenType>
+      network: Network
+      chainID: number
+      sourceAddress: Hex
+      provers: Hex[]
+    }> = []
+    const IntentSources = this.configService.getIntentSources()
+    for (const IntentSource of IntentSources) {
+      const client = await this.kernelAccountClientService.getClient(IntentSource.chainID)
+      const accountAddress = client.kernelAccountAddress
+
+      const balances = await this.getBalanceCalls(IntentSource.chainID, IntentSource.tokens)
+
+      const sourceBalancesString = this.joinBalance(balances, IntentSource.tokens)
+      sources.push({ ...IntentSource, accountAddress, tokens: sourceBalancesString })
+    }
+    sources.reverse()
+    return sources
+  }
+
+  private async getSolvers(): Promise<{
+    balances: { tokens: Record<string, TokenType> }[]
+    totalTokenBalance: number
+  }> {
+    const solverBalances: Array<{
+      accountAddress: `0x${string}` | undefined
+      tokens: Record<string, TokenType>
+      inboxAddress: Hex
+      network: Network
+      chainID: number
+    }> = []
+    let totalTokenBalance = 0
+    const solverConfig = this.configService.getSolvers()
+    await Promise.all(
+      Object.entries(solverConfig).map(async ([, solver]) => {
+        const client = await this.kernelAccountClientService.getClient(solver.chainID)
+        const accountAddress = client.kernelAccountAddress
+        const tokens = Object.keys(solver.targets) as Hex[]
+        const balances = await this.getBalanceCalls(solver.chainID, tokens)
+        const mins = Object.values(solver.targets).map((target) => target.minBalance)
+        const sourceBalancesString = this.joinBalance(balances, tokens, mins)
+        entries(solver.targets).forEach((target) => {
+          ;(target[1] as TargetContract & { balance: object }).balance =
+            sourceBalancesString[target[0]]
+          totalTokenBalance += parseInt(sourceBalancesString[target[0]].value)
+        })
+
+        solverBalances.push({
+          ...solver,
+          accountAddress,
+          tokens: sourceBalancesString,
+        })
+      }),
+    )
+    return { balances: solverBalances, totalTokenBalance }
+  }
+
+  private async getBalanceCalls(chainID: number, tokens: Hex[]) {
+    const client = await this.kernelAccountClientService.getClient(chainID)
+    const accountAddress = client.kernelAccountAddress
+
+    const balanceCalls = tokens.map((token) => {
+      return [
+        {
+          address: token,
+          abi: erc20Abi,
+          functionName: 'balanceOf',
+          args: [accountAddress],
+        },
+        {
+          address: token,
+          abi: erc20Abi,
+          functionName: 'decimals',
+        },
+      ]
+    })
+
+    return await client.multicall({
+      contracts: balanceCalls.flat(),
+    })
+  }
+
+  private joinBalance(
+    balances: any,
+    tokens: string[],
+    minBalances: number[] = [],
+  ): Record<string, TokenType> {
+    let decimal = 0n,
+      value = 0n,
+      i = 0
+    const sourceBalancesString: Record<string, TokenType> = {}
+
+    while (
+      balances.length > 0 &&
+      ([{ result: value as unknown }, { result: decimal as unknown }] = [
+        balances.shift(),
+        balances.shift(),
+      ])
+    ) {
+      sourceBalancesString[tokens[i]] = {
+        decimal: BigInt(decimal).toString(),
+        value: BigInt(value).toString(),
+        ...(minBalances ? { minBalances: minBalances[i] } : {}),
+      }
+      i++
+    }
+    return sourceBalancesString
+  }
+}

package/src/health/indicators/eco-redis.indicator.ts

@@ -0,0 +1,23 @@
+import { Injectable, Logger } from '@nestjs/common'
+import { HealthIndicatorResult } from '@nestjs/terminus'
+import { RedisHealthIndicator } from '@liaoliaots/nestjs-redis-health'
+import { EcoConfigService } from '../../eco-configs/eco-config.service'
+import { RedisConnectionUtils } from '../../common/redis/redis-connection-utils'
+
+@Injectable()
+export class EcoRedisHealthIndicator extends RedisHealthIndicator {
+  private logger = new Logger(EcoRedisHealthIndicator.name)
+  private readonly redis: any
+  constructor(private readonly configService: EcoConfigService) {
+    super()
+    const serviceConfig = configService.getRedis()
+    this.redis = RedisConnectionUtils.getRedisConnection(serviceConfig)
+  }
+  async checkRedis(): Promise<HealthIndicatorResult> {
+    return this.checkHealth('redis', {
+      type: 'redis',
+      client: this.redis,
+      timeout: 1000,
+    })
+  }
+}