eco-solver 0.0.1-security → 1.5.0

package/src/eco-configs/eco-config.types.ts

@@ -0,0 +1,278 @@
+import { Network } from 'alchemy-sdk'
+import { ClusterNode } from 'ioredis'
+import { Params as PinoParams } from 'nestjs-pino'
+import * as Redis from 'ioredis'
+import { Settings } from 'redlock'
+import { JobsOptions, RepeatOptions } from 'bullmq'
+import { Hex } from 'viem'
+import { LDOptions } from '@launchdarkly/node-server-sdk'
+import { CacheModuleOptions } from '@nestjs/cache-manager'
+
+// The config type that we store in json
+export type EcoConfigType = {
+  server: {
+    url: string
+  }
+  safe: SafeType
+  externalAPIs: unknown
+  redis: RedisConfig
+  intervals: IntervalConfig
+  intentConfigs: IntentConfig
+  alchemy: AlchemyConfigType
+  cache: CacheModuleOptions
+  launchDarkly: LaunchDarklyConfig
+  eth: {
+    privateKey: string
+    simpleAccount: {
+      walletAddr: Hex
+      signerPrivateKey: Hex
+      minEthBalanceWei: number
+      contracts: {
+        entryPoint: {
+          contractAddress: Hex
+        }
+        paymaster: {
+          contractAddresses: Hex[]
+        }
+        simpleAccountFactory: {
+          contractAddress: Hex
+        }
+      }
+    }
+    claimant: Hex
+    nonce: {
+      update_interval_ms: number
+    }
+    pollingInterval: number
+  }
+  fulfill: FulfillType
+  aws: AwsCredential[]
+  kms: KmsConfig
+  whitelist: WhitelistFeeRecord
+  database: {
+    auth: MongoAuthType
+    uriPrefix: string
+    uri: string
+    dbName: string
+    enableJournaling: boolean
+  }
+  intentSources: IntentSource[]
+  //chainID to Solver type mapping
+  solvers: Record<number, Solver>
+  logger: {
+    usePino: boolean
+    pinoConfig: PinoParams
+  }
+  liquidityManager: LiquidityManagerConfig
+}
+
+export type EcoConfigKeys = keyof EcoConfigType
+
+/**
+ * The config type for the launch darkly feature flagging service
+ */
+export type LaunchDarklyConfig = {
+  apiKey: string
+  options?: LDOptions
+}
+
+/**
+ * The configs for the fulfillment params
+ */
+export type FulfillType = {
+  run: 'batch' | 'single'
+}
+
+/**
+ * The config type for the safe multisig wallet
+ */
+export type SafeType = {
+  owner: Hex
+}
+
+/**
+ * The config type for the redis section
+ */
+export type RedisConfig = {
+  connection: ClusterNode | ClusterNode[]
+  options: {
+    single: Redis.RedisOptions
+    cluster: Redis.ClusterOptions
+  }
+  redlockSettings?: Partial<Settings>
+  jobs: {
+    intentJobConfig: JobsOptions
+  }
+}
+
+/**
+ * The config type for the intervals section
+ */
+export type IntervalConfig = {
+  retryInfeasableIntents: {
+    repeatOpts: Omit<RepeatOptions, 'key'>
+    jobTemplate: {
+      name?: string
+      opts: Omit<JobsOptions, 'jobId' | 'repeat' | 'delay'>
+    }
+  }
+  defaults: {
+    repeatOpts: Omit<RepeatOptions, 'key'>
+    jobTemplate?: {
+      name?: string
+      opts?: Omit<JobsOptions, 'jobId' | 'repeat' | 'delay'>
+    }
+  }
+}
+
+/**
+ * The config type for the intent section
+ */
+export type IntentConfig = {
+  defaultFee: FeeConfigType
+  proofs: {
+    storage_duration_seconds: number
+    hyperlane_duration_seconds: number
+  }
+}
+
+/**
+ * The config type for the aws credentials
+ */
+export type AwsCredential = {
+  region: string
+  secretID: string
+}
+
+/**
+ * The config type for the aws kms
+ */
+export type KmsConfig = {
+  region: string
+  keyID: string
+}
+
+/**
+ * The config type for a ERC20 transfer
+ */
+export type FeeConfigType = {
+  //the maximum amount of tokens that can be filled in a single transaction,
+  //defaults to 1000 USDC decimal 6 equivalent {@link ValidationService.DEFAULT_MAX_FILL_BASE_6}
+  limitFillBase6: bigint
+  algorithm: FeeAlgorithm
+  constants: FeeAlgorithmConfig<FeeAlgorithm>
+}
+
+/**
+ * The config type for a whitelisted address for a set of chains
+ * Chains must be explicitly listed in the chainIDs array
+ */
+export type FeeConfigDefaultType = FeeConfigType & {
+  chainIDs: number[]
+}
+
+/**
+ * The config type for fees for a whitelisted address
+ */
+export type FeeChainType = {
+  [chainID: number]: FeeConfigType
+  default?: FeeConfigDefaultType
+}
+
+/**
+ * The config type for a fee record for whitelisted addresses. A default is
+ * partial FeeConfigType, so that it can be overridden by chain specific fees.
+ */
+export type WhitelistFeeRecord = {
+  [whitelistedWalletAddress: Hex]: Partial<FeeChainType>
+}
+
+/**
+ * The config type for the auth section of the database.
+ */
+export type MongoAuthType = {
+  enabled: boolean
+  username: string
+  password: string
+  type: string
+}
+
+/**
+ * The whole config type for alchemy.
+ */
+export type AlchemyConfigType = {
+  apiKey: string
+  networks: AlchemyNetwork[]
+}
+
+export type AlchemyNetwork = {
+  name: Network
+  id: number
+}
+
+/**
+ * The config type for a single solver configuration
+ */
+export type Solver = {
+  inboxAddress: Hex
+  //target address to contract type mapping
+  targets: Record<Hex, TargetContract>
+  network: Network
+  fee: FeeConfigType
+  chainID: number
+}
+
+/**
+ * The fee algorithm types
+ */
+export type FeeAlgorithm = 'linear' | 'quadratic'
+
+/**
+ * The fee algorithm constant config types
+ */
+export type FeeAlgorithmConfig<T extends FeeAlgorithm> = T extends 'linear'
+  ? { baseFee: bigint; tranche: { unitFee: bigint; unitSize: bigint } }
+  : T extends 'quadratic'
+    ? { baseFee: bigint; quadraticFactor: bigint }
+    : never
+
+/**
+ * The config type for a supported target contract
+ */
+export interface TargetContract {
+  contractType: TargetContractType
+  selectors: string[]
+  minBalance: number
+  targetBalance: number
+}
+
+/**
+ * The types of contracts that we support
+ */
+export type TargetContractType = 'erc20' | 'erc721' | 'erc1155'
+
+/**
+ * The config type for a single prover source configuration
+ */
+export class IntentSource {
+  // The network that the prover is on
+  network: Network
+  // The chain ID of the network
+  chainID: number
+  // The address that the IntentSource contract is deployed at, we read events from this contract to fulfill
+  sourceAddress: Hex
+  // The addresses of the tokens that we support as rewards
+  tokens: Hex[]
+  // The addresses of the provers that we support
+  provers: Hex[]
+}
+
+export interface LiquidityManagerConfig {
+  // The maximum slippage around target balance for a token
+  targetSlippage: number
+  intervalDuration: number
+  thresholds: {
+    surplus: number // Percentage above target balance
+    deficit: number // Percentage below target balance
+  }
+}

package/src/eco-configs/interfaces/config-source.interface.ts

@@ -0,0 +1,3 @@
+export interface ConfigSource {
+  getConfig(): any
+}

package/src/eco-configs/tests/aws-config.service.spec.ts

@@ -0,0 +1,52 @@
+const mockConfigGet = jest.fn()
+import { Test, TestingModule } from '@nestjs/testing'
+import { AwsConfigService } from '../aws-config.service'
+import { merge } from 'lodash'
+
+jest.mock('config', () => {
+  return {
+    get: mockConfigGet,
+  }
+})
+
+describe('Aws Config Helper Tests', () => {
+  let awsConfigService: AwsConfigService
+  let mockLog: jest.Mock
+  let mockAwsGet: jest.Mock
+  const awsConfigSingle = { region: 'us-florida', secretID: 'secrets' }
+  const awsConfigSingleData = { key: 1, value: 'value1' }
+  const awsConfigArray = [awsConfigSingle, { region: 'us-california', secretID: 'configs' }]
+  const awsConfigArrayData = [awsConfigSingleData, { key: 3, value_second: 'value3' }]
+  beforeEach(async () => {
+    const configMod: TestingModule = await Test.createTestingModule({
+      providers: [AwsConfigService],
+    }).compile()
+
+    awsConfigService = configMod.get<AwsConfigService>(AwsConfigService)
+    mockLog = jest.fn()
+    mockAwsGet = jest.fn()
+  })
+
+  it('should read single aws credential', async () => {
+    mockConfigGet.mockReturnValue(awsConfigSingle)
+    awsConfigService['getAwsSecrets'] = mockAwsGet.mockResolvedValue(awsConfigSingleData)
+    await awsConfigService.initConfigs()
+    expect(awsConfigService.getConfig()).toEqual(awsConfigSingleData)
+  })
+
+  it('should read array of aws credentials', async () => {
+    mockConfigGet.mockReturnValue(awsConfigArray)
+    let index = 0
+    awsConfigService['getAwsSecrets'] = mockAwsGet.mockImplementation(() => {
+      return awsConfigArrayData[index++]
+    })
+    const me = {}
+    awsConfigArrayData.forEach((data) => {
+      merge(me, data)
+    })
+    merge({}, ...awsConfigArrayData)
+
+    await awsConfigService.initConfigs()
+    expect(awsConfigService.getConfig()).toEqual(me)
+  })
+})

package/src/eco-configs/tests/eco-config.service.spec.ts

@@ -0,0 +1,137 @@
+const mockgetChainConfig = jest.fn()
+import { DeepMocked, createMock } from '@golevelup/ts-jest'
+import { Test, TestingModule } from '@nestjs/testing'
+import { EcoConfigService } from '../eco-config.service'
+import { AwsConfigService } from '../aws-config.service'
+
+jest.mock('../utils', () => {
+  return {
+    ...jest.requireActual('../utils'),
+    getChainConfig: mockgetChainConfig,
+  }
+})
+
+describe('Eco Config Helper Tests', () => {
+  let ecoConfigService: EcoConfigService
+  let awsConfigService: DeepMocked<AwsConfigService>
+  let mockLog: jest.Mock
+  const awsConfig = { aws: { faceAws: 'asdf', region: 'not-a-region' } }
+  beforeEach(async () => {
+    awsConfigService = createMock<AwsConfigService>()
+    awsConfigService.getConfig = jest.fn().mockReturnValue(awsConfig)
+    const configMod: TestingModule = await Test.createTestingModule({
+      providers: [
+        {
+          provide: EcoConfigService,
+          useFactory: async (awsConfigService: AwsConfigService) => {
+            await awsConfigService.initConfigs()
+            return new EcoConfigService([awsConfigService])
+          },
+          inject: [AwsConfigService],
+        },
+        { provide: AwsConfigService, useValue: awsConfigService },
+      ],
+    }).compile()
+
+    ecoConfigService = configMod.get<EcoConfigService>(EcoConfigService)
+    mockLog = jest.fn()
+  })
+
+  it('should merge configs correctly', async () => {
+    const oldConfig = ecoConfigService.get('aws') as any
+    ecoConfigService.onModuleInit()
+    expect(ecoConfigService.get('aws')).toEqual({
+      ...awsConfig.aws,
+      ...oldConfig,
+    })
+  })
+
+  describe('on getIntentSources', () => {
+    const mockIS = {
+      chainID: 1,
+      tokens: ['0x12346817e7F6210A5b320F1A0bC96FfCf713A9b9'],
+    }
+    const mockChainConfig = {
+      IntentSource: 'source',
+      Prover: 'prover',
+      HyperProver: 'hyperprover',
+    }
+
+    beforeEach(() => {
+      jest.spyOn(ecoConfigService, 'get').mockReturnValue([mockIS])
+    })
+
+    it('should throw if not a correct address', () => {
+      ecoConfigService.get = jest.fn().mockReturnValue([
+        {
+          chainID: 1,
+          tokens: ['not-an-address'],
+        },
+      ])
+      expect(() => ecoConfigService.getIntentSources()).toThrow()
+    })
+
+    it("should throw if chain config doesn't have a chain for that source", () => {
+      mockgetChainConfig.mockReturnValue(undefined)
+      expect(() => ecoConfigService.getIntentSources()).toThrow()
+      expect(mockgetChainConfig).toHaveBeenCalled()
+    })
+
+    it('should return the intent sources', () => {
+      mockgetChainConfig.mockReturnValue(mockChainConfig)
+      ecoConfigService.get = jest.fn().mockReturnValue([mockIS])
+      const result = ecoConfigService.getIntentSources()
+      expect(result).toEqual([
+        {
+          ...mockIS,
+          sourceAddress: mockChainConfig.IntentSource,
+          provers: [mockChainConfig.HyperProver], // removed per audit warn =>  , mockChainConfig.Prover
+        },
+      ])
+      expect(mockgetChainConfig).toHaveBeenCalled()
+      expect(mockgetChainConfig).toHaveBeenCalledWith(mockIS.chainID)
+    })
+  })
+
+  describe('on getSolvers', () => {
+    const mockSolver = {
+      chainID: 1,
+      targets: {
+        '0x12346817e7F6210A5b320F1A0bC96FfCf713A9b9': '0x12346817e7F6210A5b320F1A0bC96FfCf713A9b9',
+      },
+    }
+    const mockChainConfig = {
+      Inbox: 'inbox',
+    }
+
+    beforeEach(() => {
+      jest.spyOn(ecoConfigService, 'get').mockReturnValue({ 1: mockSolver })
+    })
+
+    it('should throw if not a correct address', () => {
+      mockgetChainConfig.mockReturnValue(mockChainConfig)
+      ecoConfigService.get = jest.fn().mockReturnValue([
+        {
+          ...mockSolver,
+          targets: { adf: 'not-an-address' },
+        },
+      ])
+      expect(() => ecoConfigService.getSolvers()).toThrow()
+    })
+
+    it("should throw if chain config doesn't have a chain for that solver", () => {
+      mockgetChainConfig.mockReturnValue(undefined)
+      expect(() => ecoConfigService.getSolvers()).toThrow()
+      expect(mockgetChainConfig).toHaveBeenCalled()
+    })
+
+    it('should return the solvers', () => {
+      mockgetChainConfig.mockReturnValue(mockChainConfig)
+      ecoConfigService.get = jest.fn().mockReturnValue([mockSolver])
+      const result = ecoConfigService.getSolvers()
+      expect(result).toEqual([{ ...mockSolver, inboxAddress: mockChainConfig.Inbox }])
+      expect(mockgetChainConfig).toHaveBeenCalled()
+      expect(mockgetChainConfig).toHaveBeenCalledWith(mockSolver.chainID)
+    })
+  })
+})

package/src/eco-configs/tests/utils.spec.ts

@@ -0,0 +1,84 @@
+const mockRoutes = {
+  EcoProtocolAddresses: {
+    '10': { name: 'prod' },
+    '10-pre': { name: 'preprod' },
+    '84523': { name: 'staging' },
+    '84523-pre': { name: 'development' },
+  },
+}
+import { getNodeEnv, isPreEnv, getChainConfig, NodeEnv, ChainPrefix } from '../utils'
+import { EcoError } from '../../common/errors/eco-error'
+import * as config from 'config'
+
+jest.mock('config')
+
+jest.mock('@eco-foundation/routes-ts', () => mockRoutes)
+
+describe('config utils tests', () => {
+  describe('on getNodeEnv', () => {
+    it('should return the correct NodeEnv value', () => {
+      config.util.getEnv = jest.fn().mockReturnValue('production')
+      expect(getNodeEnv()).toBe(NodeEnv.production)
+
+      config.util.getEnv = jest.fn().mockReturnValue('preproduction')
+      expect(getNodeEnv()).toBe(NodeEnv.preproduction)
+
+      config.util.getEnv = jest.fn().mockReturnValue('staging')
+      expect(getNodeEnv()).toBe(NodeEnv.staging)
+
+      config.util.getEnv = jest.fn().mockReturnValue('development')
+      expect(getNodeEnv()).toBe(NodeEnv.development)
+
+      config.util.getEnv = jest.fn().mockReturnValue('unknown')
+      expect(getNodeEnv()).toBe(NodeEnv.development)
+    })
+  })
+
+  describe('on isPreEnv', () => {
+    it('should return true if the environment is pre', () => {
+      config.util.getEnv = jest.fn().mockReturnValue('preproduction')
+      expect(isPreEnv()).toBe(true)
+
+      config.util.getEnv = jest.fn().mockReturnValue('development')
+      expect(isPreEnv()).toBe(true)
+    })
+
+    it('should return false if the environment is not pre', () => {
+      config.util.getEnv = jest.fn().mockReturnValue('production')
+      expect(isPreEnv()).toBe(false)
+
+      config.util.getEnv = jest.fn().mockReturnValue('staging')
+      expect(isPreEnv()).toBe(false)
+    })
+  })
+
+  describe('on getChainConfig', () => {
+    it('should return the correct chain configuration', () => {
+      config.util.getEnv = jest.fn().mockReturnValue('production')
+      expect(getChainConfig(10)).toEqual(mockRoutes.EcoProtocolAddresses['10'])
+
+      config.util.getEnv = jest.fn().mockReturnValue('preproduction')
+      expect(getChainConfig(10)).toEqual(mockRoutes.EcoProtocolAddresses['10-pre'])
+
+      config.util.getEnv = jest.fn().mockReturnValue('staging')
+      expect(getChainConfig(84523)).toEqual(mockRoutes.EcoProtocolAddresses['84523'])
+
+      config.util.getEnv = jest.fn().mockReturnValue('development')
+      expect(getChainConfig(84523)).toEqual(mockRoutes.EcoProtocolAddresses['84523-pre'])
+    })
+
+    it('should throw an error if the chain configuration is not found', () => {
+      config.util.getEnv = jest.fn().mockReturnValue('production')
+      expect(() => getChainConfig(3)).toThrow(EcoError.ChainConfigNotFound('3'))
+
+      config.util.getEnv = jest.fn().mockReturnValue('preproduction')
+      expect(() => getChainConfig(4)).toThrow(EcoError.ChainConfigNotFound('4-pre'))
+
+      config.util.getEnv = jest.fn().mockReturnValue('staging')
+      expect(() => getChainConfig(3)).toThrow(EcoError.ChainConfigNotFound('3'))
+
+      config.util.getEnv = jest.fn().mockReturnValue('development')
+      expect(() => getChainConfig(4)).toThrow(EcoError.ChainConfigNotFound('4-pre'))
+    })
+  })
+})

package/src/eco-configs/utils.ts

@@ -0,0 +1,49 @@
+import { EcoChainConfig, EcoProtocolAddresses } from '@eco-foundation/routes-ts'
+import * as config from 'config'
+import { EcoError } from '../common/errors/eco-error'
+
+/**
+ * The prefix for non-production deploys on a chain
+ */
+export const ChainPrefix = 'pre'
+
+export enum NodeEnv {
+  production = 'production',
+  preproduction = 'preproduction',
+  staging = 'staging',
+  development = 'development',
+}
+
+/**
+ * Returns the NodeEnv enum value from the string node env, defaults to Development
+ *
+ * @param env the string node env
+ * @returns
+ */
+export function getNodeEnv(): NodeEnv {
+  const env: string = config.util.getEnv('NODE_ENV')
+  const normalizedEnv = env.toLowerCase() as keyof typeof NodeEnv
+  return NodeEnv[normalizedEnv] || NodeEnv.development
+}
+
+/**
+ * @returns true if the node env is preproduction or development
+ */
+export function isPreEnv(): boolean {
+  return getNodeEnv() === NodeEnv.preproduction || getNodeEnv() === NodeEnv.development
+}
+
+/**
+ * Gets the chain configuration for the given chain id from the
+ * eco protocol addresses library
+ * @param chainID the chain id
+ * @returns
+ */
+export function getChainConfig(chainID: number | string): EcoChainConfig {
+  const id = isPreEnv() ? `${chainID}-${ChainPrefix}` : chainID.toString()
+  const config = EcoProtocolAddresses[id]
+  if (config === undefined) {
+    throw EcoError.ChainConfigNotFound(id)
+  }
+  return config
+}

package/src/fee/fee.module.ts

@@ -0,0 +1,10 @@
+import { BalanceModule } from '@/balance/balance.module'
+import { FeeService } from '@/fee/fee.service'
+import { Module } from '@nestjs/common'
+
+@Module({
+  imports: [BalanceModule],
+  providers: [FeeService],
+  exports: [FeeService],
+})
+export class FeeModule {}