eco-solver 0.0.1-security → 1.5.1

package/src/contracts/utils.ts

@@ -0,0 +1,31 @@
+import { Abi, AbiStateMutability, ContractFunctionName, Hex } from 'viem'
+import { TargetContractType } from '../eco-configs/eco-config.types'
+import { ERC20Abi } from './ERC20.contract'
+import { EcoError } from '../common/errors/eco-error'
+
+/**
+ * The type for a call to a contract, used for typing multicall mappings
+ */
+export type ViemCall<
+  abi extends Abi,
+  mutability extends AbiStateMutability = AbiStateMutability,
+> = {
+  address: Hex
+  abi: abi
+  functionName: ContractFunctionName<abi, mutability>
+}
+
+/**
+ * Get the ABI for the target ERC contract
+ * @param targetType
+ */
+export function getERCAbi(targetType: TargetContractType): Abi {
+  switch (targetType) {
+    case 'erc20':
+      return ERC20Abi
+    case 'erc721':
+    case 'erc1155':
+    default:
+      throw EcoError.IntentSourceUnsupportedTargetType(targetType)
+  }
+}

package/src/decoder/decoder.interface.ts

@@ -0,0 +1,3 @@
+export interface IntentDataDecoder {
+  decodeCreateIntentLog(data: string, topics: string[]): any
+}

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

@@ -0,0 +1,36 @@
+import { getSelectorHash, isHex } from '../utils'
+
+describe('Decoder Utils Test', () => {
+  const data =
+    '0xa9059cbb000000000000000000000000cd80b973e7cbb93c21cc5ac0a5f45d12a32582aa00000000000000000000000000000000000000000000000000000000000004d2'
+
+  describe('isHex', () => {
+    it('should return false if the input is not hex', () => {
+      expect(isHex('16')).toEqual(false)
+      expect(isHex('0xqw')).toEqual(false)
+    })
+
+    it('should return true if the input is hex', () => {
+      expect(isHex(data)).toEqual(true)
+      expect(isHex('0xab')).toEqual(true)
+    })
+  })
+  describe('getSelectorHash', () => {
+    it('should return throw if the input is empty', () => {
+      expect(() => getSelectorHash(undefined)).toThrow('Data is too short')
+      expect(() => getSelectorHash('')).toThrow('Data is too short')
+    })
+
+    it('should return throw if the input is not long engough', () => {
+      expect(() => getSelectorHash('0x')).toThrow('Data is too short')
+    })
+
+    it('should return throw if the input is not hex', () => {
+      expect(() => getSelectorHash('adsfasdfasdfadfccdx')).toThrow('Data is not hex encoded')
+    })
+
+    it('should return the first 4 bytes', () => {
+      expect(getSelectorHash(data)).toEqual('0xa9059cbb')
+    })
+  })
+})

package/src/decoder/utils.ts

@@ -0,0 +1,24 @@
+/**
+ * Returns the selector hash of the data, which is the first 4 bytes of the data
+ *
+ * @param data the hex encoded data
+ * @returns
+ */
+export function getSelectorHash(data: string | undefined): string {
+  if (!data || data.length < 10) {
+    throw new Error('Data is too short')
+  }
+  if (!isHex(data)) {
+    throw new Error('Data is not hex encoded')
+  }
+  return '0x' + data.slice(2, 10)
+}
+
+/**
+ * Check if a string is valid hex
+ * @param hex the string to check if it is hex
+ * @returns
+ */
+export function isHex(num: string): boolean {
+  return Boolean(num.match(/^0x[0-9a-f]+$/i))
+}

package/src/decorators/cacheable.decorator.ts

@@ -0,0 +1,48 @@
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import { deserialize, serialize } from '@/liquidity-manager/utils/serialize'
+import { Cache } from '@nestjs/cache-manager'
+
+/**
+ * This decorator caches the result of a function for a specified time to live (ttl).
+ * Needs the calling class to have a cacheManager and configService injected.
+ *
+ * @param opts - ttl: time to live in seconds, bypassArgIndex: index of the argument to bypass cache
+ * @returns
+ */
+export function Cacheable(opts?: { ttl?: number; bypassArgIndex?: number }) {
+  return function (target: any, key: string, descriptor: PropertyDescriptor) {
+    const originalMethod = descriptor.value
+
+    descriptor.value = async function (...args: any[]) {
+      const cacheManager: Cache = this.cacheManager // Injected service
+      const configService: EcoConfigService = this.configService // Injected service
+      if (opts && !opts.ttl) {
+        opts.ttl = configService.getCache().ttl
+      } else {
+        opts = {
+          ttl: configService.getCache().ttl,
+        }
+      }
+
+      // Construct the cache key based on function arguments
+      const cacheKey = `${key}:${JSON.stringify(args)}` // Unique key for the cache
+
+      // Determine whether to bypass cache
+      const forceRefresh = opts.bypassArgIndex ? args[opts.bypassArgIndex] === true : false
+
+      if (!forceRefresh) {
+        const cachedData = await cacheManager.get(cacheKey)
+        if (cachedData && typeof cachedData == 'object') {
+          return deserialize(cachedData)
+        }
+      }
+
+      // Call the original method to fetch fresh data
+      const result = await originalMethod.apply(this, args)
+      await cacheManager.set(cacheKey, serialize(result), opts.ttl)
+      return result
+    }
+
+    return descriptor
+  }
+}

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

@@ -0,0 +1,75 @@
+import { SecretsManager } from '@aws-sdk/client-secrets-manager'
+import { AwsCredential } from './eco-config.types'
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common'
+import * as config from 'config'
+import { EcoLogMessage } from '../common/logging/eco-log-message'
+import { ConfigSource } from './interfaces/config-source.interface'
+import { EcoError } from '../common/errors/eco-error'
+import { merge } from 'lodash'
+
+/**
+ * Service to retrieve AWS secrets from AWS Secrets Manager
+ */
+@Injectable()
+export class AwsConfigService implements OnModuleInit, ConfigSource {
+  private logger = new Logger(AwsConfigService.name)
+  private _awsConfigs: Record<string, string> = {}
+  constructor() {}
+
+  async onModuleInit() {
+    await this.initConfigs()
+  }
+
+  /**
+   * @returns the aws configs
+   */
+  getConfig() {
+    return this.awsConfigs
+  }
+
+  /**
+   * Initialize the configs
+   */
+  async initConfigs() {
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `Initializing aws configs`,
+      }),
+    )
+    let awsCreds = config.get('aws') as any[]
+    if (!Array.isArray(awsCreds)) {
+      awsCreds = [awsCreds]
+    }
+    const creds = await Promise.all(
+      awsCreds.map(async (cred: AwsCredential) => {
+        return await this.getAwsSecrets(cred)
+      }),
+    )
+    merge(this._awsConfigs, ...creds)
+  }
+
+  get awsConfigs(): Record<string, string> {
+    return this._awsConfigs
+  }
+
+  /**
+   * Retrieve the AWS secrets from the AWS Secrets Manager
+   * @param awsCreds the aws credentials
+   * @returns
+   */
+  private async getAwsSecrets(awsCreds: AwsCredential): Promise<Record<string, string>> {
+    const secretsManager = new SecretsManager({
+      region: awsCreds.region,
+    })
+    try {
+      const data = await secretsManager.getSecretValue({ SecretId: awsCreds.secretID })
+      if (data.SecretString) {
+        const secret = JSON.parse(data.SecretString)
+        return secret as Record<string, string>
+      }
+    } catch (err) {
+      this.logger.error(EcoError.getErrorMessage({ message: err.message }))
+    }
+    return {}
+  }
+}

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

@@ -0,0 +1,44 @@
+import { DynamicModule, FactoryProvider, Global, Module, Provider } from '@nestjs/common'
+import { EcoConfigService } from './eco-config.service'
+import { AwsConfigService } from './aws-config.service'
+
+@Global()
+@Module({
+  providers: [EcoConfigModule.createBaseProvider(), AwsConfigService],
+  exports: [EcoConfigService, AwsConfigService],
+})
+export class EcoConfigModule {
+  static withAWS(): DynamicModule {
+    return {
+      global: true,
+      module: EcoConfigModule,
+      providers: [EcoConfigModule.createAwsProvider()],
+      exports: [EcoConfigService],
+    }
+  }
+
+  static base(): DynamicModule {
+    return {
+      global: true,
+      module: EcoConfigModule,
+      providers: [EcoConfigModule.createBaseProvider()],
+      exports: [EcoConfigService],
+    }
+  }
+
+  static createAwsProvider(): Provider {
+    const dynamicConfig: FactoryProvider<EcoConfigService> = {
+      provide: EcoConfigService,
+      useFactory: async (awsConfigService: AwsConfigService) => {
+        await awsConfigService.initConfigs()
+        return new EcoConfigService([awsConfigService])
+      },
+      inject: [AwsConfigService],
+    }
+    return dynamicConfig
+  }
+
+  static createBaseProvider(): Provider {
+    return EcoConfigService
+  }
+}

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

@@ -0,0 +1,220 @@
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common'
+import * as _ from 'lodash'
+import * as config from 'config'
+import { EcoLogMessage } from '@/common/logging/eco-log-message'
+import { ConfigSource } from './interfaces/config-source.interface'
+import {
+  AwsCredential,
+  KmsConfig,
+  EcoConfigType,
+  IntentSource,
+  Solver,
+  SafeType,
+} from './eco-config.types'
+import { entries } from 'lodash'
+import { getAddress } from 'viem'
+import { addressKeys, getRpcUrl } from '@/common/viem/utils'
+import { ChainsSupported } from '@/common/chains/supported'
+import { getChainConfig } from './utils'
+
+/**
+ * Service class for getting configs for the app
+ */
+@Injectable()
+export class EcoConfigService implements OnModuleInit {
+  private logger = new Logger(EcoConfigService.name)
+  private externalConfigs: any = {}
+  private ecoConfig: config.IConfig
+
+  constructor(private readonly sources: ConfigSource[]) {
+    this.sources.reduce((prev, curr) => {
+      return config.util.extendDeep(prev, curr.getConfig())
+    }, this.externalConfigs)
+
+    this.ecoConfig = config
+    this.initConfigs()
+  }
+
+  async onModuleInit() {}
+
+  /**
+   * Returns the static configs  for the app, from the 'config' package
+   * @returns the configs
+   */
+  static getStaticConfig(): EcoConfigType {
+    return config as unknown as EcoConfigType
+  }
+
+  // Initialize the configs
+  initConfigs() {
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `Initializing eco configs`,
+      }),
+    )
+
+    // Merge the secrets with the existing config, the external configs will be overwritten by the internal ones
+    this.ecoConfig = config.util.extendDeep(this.externalConfigs, this.ecoConfig)
+  }
+
+  // Generic getter for key/val of config object
+  get<T>(key: string): T {
+    return this.ecoConfig.get<T>(key)
+  }
+
+  // Returns the alchemy configs
+  getAlchemy(): EcoConfigType['alchemy'] {
+    return this.get('alchemy')
+  }
+
+  // Returns the aws configs
+  getAwsConfigs(): AwsCredential[] {
+    return this.get('aws')
+  }
+
+  // Returns the cache configs
+  getCache(): EcoConfigType['cache'] {
+    return this.get('cache')
+  }
+
+  // Returns the fulfill configs
+  getFulfill(): EcoConfigType['fulfill'] {
+    return this.get('fulfillment')
+  }
+
+  // Returns the source intents config
+  getIntentSources(): EcoConfigType['intentSources'] {
+    const intents = this.get<IntentSource[]>('intentSources').map((intent: IntentSource) => {
+      intent.tokens = intent.tokens.map((token: string) => {
+        return getAddress(token)
+      })
+      const config = getChainConfig(intent.chainID)
+      intent.sourceAddress = config.IntentSource
+      intent.provers = [config.HyperProver]
+      //removing storage prover per audit for hyperlane beta release
+      // if (config.Prover) {
+      //   intent.provers.push(config.Prover)
+      // }
+      return intent
+    })
+    return intents
+  }
+
+  // Returns the intent source for a specific chain or undefined if its not supported
+  getIntentSource(chainID: number): IntentSource | undefined {
+    return this.getIntentSources().find((intent) => intent.chainID === chainID)
+  }
+
+  // Returns the aws configs
+  getKmsConfig(): KmsConfig {
+    return this.get('kms')
+  }
+
+  // Returns the safe multisig configs
+  getSafe(): SafeType {
+    const safe = this.get<SafeType>('safe')
+    // validate and checksum the owner address, throws if invalid/not-set
+    safe.owner = getAddress(safe.owner)
+    return safe
+  }
+
+  // Returns the solvers config
+  getSolvers(): EcoConfigType['solvers'] {
+    const solvers = this.get<Record<number, Solver>>('solvers')
+    entries(solvers).forEach(([, solver]: [string, Solver]) => {
+      const config = getChainConfig(solver.chainID)
+      solver.inboxAddress = config.Inbox
+      solver.targets = addressKeys(solver.targets) ?? {}
+    })
+    return solvers
+  }
+
+  // Returns the solver for a specific chain or undefined if its not supported
+  getSolver(chainID: number | bigint): Solver | undefined {
+    chainID = typeof chainID === 'bigint' ? Number(chainID) : chainID
+    return this.getSolvers()[chainID]
+  }
+
+  // Get the launch darkly configs
+  getLaunchDarkly(): EcoConfigType['launchDarkly'] {
+    return this.get('launchDarkly')
+  }
+
+  getDatabaseConfig(): EcoConfigType['database'] {
+    return this.get('database')
+  }
+
+  // Returns the eth configs
+  getEth(): EcoConfigType['eth'] {
+    return this.get('eth')
+  }
+
+  // Returns the intervals config, sets defaults for repeatOpts and jobTemplate if not set
+  getIntervals(): EcoConfigType['intervals'] {
+    const configs = this.get('intervals') as EcoConfigType['intervals']
+    for (const [, value] of Object.entries(configs)) {
+      _.merge(value, configs.defaults, value)
+    }
+    return configs
+  }
+
+  // Returns the intent configs
+  getIntentConfigs(): EcoConfigType['intentConfigs'] {
+    return this.get('intentConfigs')
+  }
+
+  // Returns the external APIs config
+  getExternalAPIs(): EcoConfigType['externalAPIs'] {
+    return this.get('externalAPIs')
+  }
+
+  getLoggerConfig(): EcoConfigType['logger'] {
+    return this.get('logger')
+  }
+
+  getMongooseUri() {
+    const config = this.getDatabaseConfig()
+    return config.auth.enabled
+      ? `${config.uriPrefix}${config.auth.username}:${config.auth.password}@${config.uri}/${config.dbName}`
+      : `${config.uriPrefix}${config.uri}/${config.dbName}`
+  }
+
+  // Returns the redis configs
+  getRedis(): EcoConfigType['redis'] {
+    return this.get('redis')
+  }
+
+  // Returns the server configs
+  getServer(): EcoConfigType['server'] {
+    return this.get('server')
+  }
+
+  // Returns the liquidity manager config
+  getLiquidityManager(): EcoConfigType['liquidityManager'] {
+    return this.get('liquidityManager')
+  }
+
+  // Returns the liquidity manager config
+  getWhitelist(): EcoConfigType['whitelist'] {
+    return this.get('whitelist')
+  }
+
+  getChainRPCs() {
+    const { apiKey, networks } = this.getAlchemy()
+    const supportedAlchemyChainIds = _.map(networks, 'id')
+
+    const entries = ChainsSupported.map((chain) => {
+      const rpcApiKey = supportedAlchemyChainIds.includes(chain.id) ? apiKey : undefined
+      return [chain.id, getRpcUrl(chain, rpcApiKey).url]
+    })
+    return Object.fromEntries(entries) as Record<number, string>
+  }
+
+  /**
+   * Checks to see what networks we have inbox contracts for
+   * @returns the supported chains for the event
+   */
+  getSupportedChains(): bigint[] {
+    return entries(this.getSolvers()).map(([, solver]) => BigInt(solver.chainID))
+  }
+}