eco-solver 0.0.1-security → 1.5.1

package/src/main.ts

@@ -0,0 +1,63 @@
+import { NestFactory } from '@nestjs/core'
+import { AppModule } from './app.module'
+import { NestExpressApplication } from '@nestjs/platform-express'
+import { EcoConfigService } from './eco-configs/eco-config.service'
+import { Logger, LoggerErrorInterceptor } from 'nestjs-pino'
+import { NestApplicationOptions, ValidationPipe } from '@nestjs/common'
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger'
+import { BigIntToStringInterceptor } from '@/interceptors/big-int.interceptor'
+
+async function bootstrap() {
+  const app = await NestFactory.create<NestExpressApplication>(AppModule, getNestParams())
+  if (EcoConfigService.getStaticConfig().logger.usePino) {
+    app.useLogger(app.get(Logger))
+    app.useGlobalInterceptors(new LoggerErrorInterceptor())
+  }
+
+  //add dto validations, enable transformation
+  app.useGlobalPipes(
+    new ValidationPipe({
+      transform: true, // Enables DTO transformation for incoming requests
+    }),
+  )
+
+  //change all bigints to strings in the controller responses
+  app.useGlobalInterceptors(new BigIntToStringInterceptor())
+
+  //add swagger
+  addSwagger(app)
+
+  // Starts listening for shutdown hooks
+  app.enableShutdownHooks()
+  await app.listen(3000)
+}
+
+function getNestParams(): NestApplicationOptions {
+  let params = {
+    cors: true,
+    rawBody: true, //needed for AlchemyAuthMiddleware webhook verification
+  }
+  if (EcoConfigService.getStaticConfig().logger.usePino) {
+    params = {
+      ...params,
+      ...{
+        bufferLogs: true,
+      },
+    }
+  }
+
+  return params
+}
+
+function addSwagger(app: NestExpressApplication) {
+  const config = new DocumentBuilder()
+    .setTitle('Solver API')
+    .setDescription('The api for the solver queries')
+    .setVersion('0.1')
+    .addTag('solver')
+    .build()
+  const documentFactory = () => SwaggerModule.createDocument(app, config)
+  SwaggerModule.setup('api', app, documentFactory)
+}
+
+bootstrap()

package/src/nest-redlock/nest-redlock.config.ts

@@ -0,0 +1,14 @@
+import { ModuleMetadata, Type } from '@nestjs/common'
+import { NestRedlockConfigFactory } from './nest-redlock.interface'
+import { RedisConfig } from '../eco-configs/eco-config.types'
+
+export interface NestRedlockConfig extends RedisConfig {}
+
+export interface NestRedlockDynamicConfig extends Pick<ModuleMetadata, 'imports'> {
+  useFactory?: (...args: any[]) => Promise<NestRedlockConfig> | NestRedlockConfig
+  useClass?: Type<NestRedlockConfigFactory>
+  useExisting?: Type<NestRedlockConfigFactory>
+  inject?: any[]
+}
+
+export const NEST_REDLOCK_CONFIG = 'NEST_REDLOCK_CONFIG'

package/src/nest-redlock/nest-redlock.interface.ts

@@ -0,0 +1,5 @@
+import { NestRedlockConfig } from './nest-redlock.config'
+
+export interface NestRedlockConfigFactory {
+  createNestRedlockConfig(): Promise<NestRedlockConfig> | NestRedlockConfig
+}

package/src/nest-redlock/nest-redlock.module.ts

@@ -0,0 +1,64 @@
+import { DynamicModule, Global, Module, Provider } from '@nestjs/common'
+import { NestRedlockConfig, NestRedlockDynamicConfig } from './nest-redlock.config'
+import { NEST_REDLOCK_CONFIG } from './nest-redlock.config'
+import { NestRedlockConfigFactory } from './nest-redlock.interface'
+import { RedlockService } from './nest-redlock.service'
+
+@Global()
+@Module({
+  imports: [],
+  providers: [RedlockService],
+  exports: [RedlockService],
+})
+export class RedlockModule {
+  static forRoot(config: NestRedlockConfig): DynamicModule {
+    return {
+      module: RedlockModule,
+      imports: [],
+      providers: [
+        {
+          provide: NEST_REDLOCK_CONFIG,
+          useValue: config,
+        },
+      ],
+      exports: [],
+    }
+  }
+
+  static forRootAsync(dynamicConfig: NestRedlockDynamicConfig): DynamicModule {
+    const providers = this.createAsyncProviders(dynamicConfig)
+
+    return {
+      module: RedlockModule,
+      imports: dynamicConfig.imports || [],
+      providers,
+      exports: [],
+    }
+  }
+
+  static createAsyncProviders(dynamicConfig: NestRedlockDynamicConfig): Provider[] {
+    if (dynamicConfig.useFactory) {
+      return [
+        {
+          provide: NEST_REDLOCK_CONFIG,
+          useFactory: dynamicConfig.useFactory,
+          inject: dynamicConfig.inject,
+        },
+      ]
+    }
+
+    if (dynamicConfig.useClass || dynamicConfig.useExisting) {
+      return [
+        {
+          provide: NEST_REDLOCK_CONFIG,
+          useFactory: async (configFactory: NestRedlockConfigFactory) => {
+            return await configFactory.createNestRedlockConfig()
+          },
+          inject: [dynamicConfig.useClass || dynamicConfig.useExisting!],
+        },
+      ]
+    }
+
+    return []
+  }
+}

package/src/nest-redlock/nest-redlock.service.ts

@@ -0,0 +1,59 @@
+import { Inject, Injectable } from '@nestjs/common'
+import Redlock, { Settings } from 'redlock'
+import { Redis as IORedisClient, Cluster as IORedisCluster } from 'ioredis'
+import { NestRedlockConfig, NEST_REDLOCK_CONFIG } from './nest-redlock.config'
+import { RedisConnectionUtils } from '../common/redis/redis-connection-utils'
+import { Lock } from 'redlock'
+
+export type RedlockRedisClient = IORedisClient | IORedisCluster
+
+@Injectable()
+export class RedlockService extends Redlock {
+  constructor(@Inject(NEST_REDLOCK_CONFIG) redlockConfig: NestRedlockConfig) {
+    const { redlockSettings } = redlockConfig
+    const redisClients = RedisConnectionUtils.getClientsForRedlock(redlockConfig)
+
+    super(redisClients, redlockSettings)
+  }
+
+  /**
+   * Executes the callback if the lock key is required, otherwise it throws an error
+   * @param key the key to lock on
+   * @param callback the callback to execute
+   * @returns
+   */
+  async lockCall(key: string, callback: () => Promise<any>): Promise<any> {
+    const lock = await this.acquireLock([key], 5000)
+    if (!lock) {
+      throw new Error('Could not acquire lock')
+    }
+
+    try {
+      return await callback()
+    } catch (e) {
+      throw e
+    } finally {
+      await lock.release()
+    }
+  }
+
+  /**
+   * Non-throwing lock aquire that returns null if the lock is not available
+   *
+   * @param resources
+   * @param duration time in ms
+   * @param settings
+   * @returns
+   */
+  async acquireLock(
+    resources: string[],
+    duration: number,
+    settings?: Partial<Settings>,
+  ): Promise<Lock | null> {
+    try {
+      return await this.acquire(resources, duration, settings)
+    } catch {
+      return null
+    }
+  }
+}

package/src/prover/proof.service.ts

@@ -0,0 +1,184 @@
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common'
+import { addSeconds, compareAsc } from 'date-fns'
+import { MultichainPublicClientService } from '../transaction/multichain-public-client.service'
+import { Hex } from 'viem'
+import {
+  PROOF_HYPERLANE,
+  PROOF_STORAGE,
+  ProofCall,
+  ProofType,
+  ProverInterfaceAbi,
+} from '../contracts'
+import { entries } from 'lodash'
+import { EcoConfigService } from '../eco-configs/eco-config.service'
+import { EcoLogMessage } from '../common/logging/eco-log-message'
+
+/**
+ * Service class for getting information about the provers and their configurations.
+ */
+@Injectable()
+export class ProofService implements OnModuleInit {
+  private logger = new Logger(ProofService.name)
+
+  /**
+   * Variable storing the proof type for each prover address. Used to determine
+   * what function to call on the Inbox contract
+   */
+  private proofContracts: Record<Hex, ProofType> = {}
+
+  constructor(
+    private readonly publicClient: MultichainPublicClientService,
+    private readonly ecoConfigService: EcoConfigService,
+  ) {}
+
+  async onModuleInit() {
+    await this.loadProofTypes()
+  }
+
+  /**
+   * Returns the proof type for a given prover address
+   *
+   * @param proverAddress
+   * @returns the proof type, defaults to {@link PROOF_STORAGE}
+   */
+  getProofType(proverAddress: Hex): ProofType {
+    return this.proofContracts[proverAddress]
+  }
+
+  /**
+   * Checks if the prover is a hyperlane prover
+   * @param proverAddress the prover address
+   * @returns
+   */
+  isHyperlaneProver(proverAddress: Hex): boolean {
+    return this.getProofType(proverAddress) === PROOF_HYPERLANE
+  }
+
+  /**
+   * Checks if the prover is a storage prover
+   * @param proverAddress the prover address
+   * @returns
+   */
+  isStorageProver(proverAddress: Hex): boolean {
+    return this.getProofType(proverAddress) === PROOF_STORAGE
+  }
+
+  /**
+   * Returns all the prover addresses for a given proof type
+   * @param proofType the proof type
+   * @returns
+   */
+  getProvers(proofType: ProofType): Hex[] {
+    return entries(this.proofContracts)
+      .filter(([, type]) => type === proofType)
+      .map(([address]) => address as Hex)
+  }
+
+  /**
+   * Returns the prover type for a given prover address
+   * @param prover the prover address
+   * @returns
+   */
+  getProverType(prover: Hex): ProofType {
+    return this.proofContracts[prover]
+  }
+
+  /**
+   * Loads the proof types for each prover address into memory.
+   * Assume all provers must have the same proof type if their
+   * hex address is the same.
+   */
+  private async loadProofTypes() {
+    const proofPromises = this.ecoConfigService.getIntentSources().map(async (source) => {
+      return await this.getProofTypes(source.chainID, source.provers)
+    })
+
+    // get the proof types for each prover address from on chain
+    const proofs = await Promise.all(proofPromises)
+
+    // reduce the array of proof objects into a single object, removing duplicates
+    proofs.reduce((acc, proof) => {
+      entries(proof).forEach(([proverAddress, proofType]) => {
+        acc[proverAddress] = proofType
+      })
+      return acc
+    }, this.proofContracts)
+
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `loadProofTypes loaded all the proof types`,
+        properties: {
+          proofs: this.proofContracts,
+        },
+      }),
+    )
+  }
+
+  /**
+   * Fetches all the proof types for the provers on a given chain using {@link ViemMultichainClientService#multicall}
+   *
+   * @param chainID the chain id
+   * @param provers the prover addresses
+   * @returns
+   */
+  private async getProofTypes(chainID: number, provers: Hex[]): Promise<Record<Hex, ProofType>> {
+    const client = await this.publicClient.getClient(Number(chainID))
+    const proofCalls: ProofCall[] = provers.map((proverAddress) => {
+      return {
+        address: proverAddress,
+        abi: ProverInterfaceAbi,
+        functionName: 'getProofType',
+      }
+    })
+
+    const proofs = (await client.multicall({
+      contracts: proofCalls.flat(),
+    })) as any
+    let proof: ProofType = 0,
+      i = 0
+    const proofObj: Record<Hex, ProofType> = {}
+    while (proofs.length > 0 && ([{ result: proof }] = [proofs.shift()])) {
+      proofObj[provers[i]] = proof
+      i++
+    }
+
+    return proofObj
+  }
+
+  /**
+   * Check to see if the expiration of an intent is after the minimum proof time from now.
+   *
+   * @param prover the address of the prover
+   * @param expirationDate the expiration date
+   * @returns true if the intent can be proven before the minimum proof time, false otherwise
+   */
+  isIntentExpirationWithinProofMinimumDate(prover: Hex, expirationDate: Date): boolean {
+    return compareAsc(expirationDate, this.getProofMinimumDate(this.proofContracts[prover])) == 1
+  }
+
+  /**
+   * Gets the minimum date that a proof can be generated for a given chain id.
+   * @param chainID  the chain id
+   * @returns
+   */
+  getProofMinimumDate(prover: ProofType): Date {
+    return addSeconds(new Date(), this.getProofMinimumDurationSeconds(prover))
+  }
+
+  /**
+   * The minimum duration that a proof can be generated for a given prover
+   *
+   * @param prover the address of the prover
+   * @returns
+   */
+  private getProofMinimumDurationSeconds(prover: ProofType): number {
+    const proofs = this.ecoConfigService.getIntentConfigs().proofs
+    switch (prover) {
+      case PROOF_HYPERLANE:
+        return proofs.hyperlane_duration_seconds
+      case PROOF_STORAGE:
+      default:
+        return proofs.storage_duration_seconds
+    }
+  }
+}

package/src/prover/prover.module.ts

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

package/src/prover/tests/proof.service.spec.ts

@@ -0,0 +1,154 @@
+import { createMock, DeepMocked } from '@golevelup/ts-jest'
+import { EcoConfigService } from '../../eco-configs/eco-config.service'
+import { Test, TestingModule } from '@nestjs/testing'
+import { ProofService } from '../../prover/proof.service'
+import { PROOF_HYPERLANE, PROOF_STORAGE, ProofType } from '../../contracts'
+import { Hex } from 'viem'
+import { MultichainPublicClientService } from '../../transaction/multichain-public-client.service'
+import { addSeconds } from 'date-fns'
+
+describe('ProofService', () => {
+  let proofService: ProofService
+  let multichainPublicClientService: DeepMocked<MultichainPublicClientService>
+  let ecoConfigService: DeepMocked<EcoConfigService>
+
+  const mockLogDebug = jest.fn()
+  const mockLogLog = jest.fn()
+
+  beforeEach(async () => {
+    const chainMod: TestingModule = await Test.createTestingModule({
+      providers: [
+        ProofService,
+        {
+          provide: MultichainPublicClientService,
+          useValue: createMock<MultichainPublicClientService>(),
+        },
+        { provide: EcoConfigService, useValue: createMock<EcoConfigService>() },
+      ],
+    }).compile()
+
+    proofService = chainMod.get(ProofService)
+    multichainPublicClientService = chainMod.get(MultichainPublicClientService)
+    ecoConfigService = chainMod.get(EcoConfigService)
+
+    proofService['logger'].debug = mockLogDebug
+    proofService['logger'].log = mockLogLog
+  })
+
+  afterEach(async () => {
+    jest.restoreAllMocks()
+    mockLogDebug.mockClear()
+    mockLogLog.mockClear()
+  })
+
+  describe('on startup', () => {
+    it('should call loadProofTypes', async () => {
+      const mockLoad = jest.fn()
+      proofService['loadProofTypes'] = mockLoad
+      await proofService.onModuleInit()
+      expect(mockLoad).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('on loadProofTypes', () => {
+    const mockGetProofTypes = jest.fn()
+    const intentSources = [
+      { chainID: 1, provers: ['0x123', '0x456'] },
+      { chainID: 2, provers: ['0x123', '0x777'] },
+    ]
+    const proofContracts = {
+      [intentSources[0].provers[0]]: PROOF_HYPERLANE,
+      [intentSources[0].provers[1]]: PROOF_HYPERLANE,
+      [intentSources[1].provers[1]]: PROOF_STORAGE,
+    }
+    const proof1: Record<Hex, ProofType> = {}
+    const proof2: Record<Hex, ProofType> = {}
+    beforeEach(async () => {
+      intentSources[0].provers.forEach((s) => {
+        proof1[s] = PROOF_HYPERLANE
+      })
+      intentSources[1].provers.forEach((s) => {
+        if (s === intentSources[0].provers[0]) {
+          proof2[s] = PROOF_HYPERLANE
+          return
+        }
+        proof2[s] = PROOF_STORAGE
+      })
+      proofService['getProofTypes'] = mockGetProofTypes.mockImplementation(
+        async (chainID: number) => {
+          switch (chainID) {
+            case 1:
+              return proof1
+            case 2:
+              return proof2
+          }
+        },
+      )
+      ecoConfigService.getIntentSources = jest.fn().mockReturnValue(intentSources)
+      await proofService.onModuleInit()
+    })
+
+    afterEach(() => {
+      mockGetProofTypes.mockClear()
+    })
+
+    it('should call getProofTypes for all source intents', async () => {
+      expect(mockGetProofTypes).toHaveBeenCalledTimes(intentSources.length)
+    })
+
+    it('should set the proofContracts', async () => {
+      expect(proofService['proofContracts']).toEqual(proofContracts)
+    })
+
+    it('should should log', async () => {
+      expect(mockLogDebug).toHaveBeenCalledTimes(1)
+      expect(mockLogDebug).toHaveBeenCalledWith({
+        msg: 'loadProofTypes loaded all the proof types',
+        proofs: proofContracts,
+      })
+    })
+  })
+
+  describe('on utility methods', () => {
+    const intentConfigs = {
+      proofs: {
+        storage_duration_seconds: 10,
+        hyperlane_duration_seconds: 20,
+      },
+    }
+    beforeEach(async () => {
+      ecoConfigService.getIntentConfigs = jest.fn().mockReturnValue(intentConfigs)
+    })
+    it('should correctly check if its a hyperlane prover', async () => {
+      jest.spyOn(proofService, 'getProofType').mockReturnValue(PROOF_HYPERLANE)
+      expect(proofService.isHyperlaneProver('0x123')).toBe(true)
+      expect(proofService.isStorageProver('0x123')).toBe(false)
+    })
+
+    it('should correctly check if its a storage prover', async () => {
+      jest.spyOn(proofService, 'getProofType').mockReturnValue(PROOF_STORAGE)
+      expect(proofService.isHyperlaneProver('0x123')).toBe(false)
+      expect(proofService.isStorageProver('0x123')).toBe(true)
+    })
+
+    it('should return the correct minimum proof time', async () => {
+      expect(proofService['getProofMinimumDurationSeconds'](PROOF_HYPERLANE)).toBe(
+        intentConfigs.proofs.hyperlane_duration_seconds,
+      )
+
+      expect(proofService['getProofMinimumDurationSeconds'](PROOF_STORAGE)).toBe(
+        intentConfigs.proofs.storage_duration_seconds,
+      )
+    })
+
+    it('should return whether the intent expires too soon', async () => {
+      const seconds = 100
+      const expires = addSeconds(new Date(), seconds)
+      proofService['getProofMinimumDurationSeconds'] = jest.fn().mockReturnValue(seconds / 2)
+      expect(proofService.isIntentExpirationWithinProofMinimumDate('0x123', expires)).toBe(true)
+
+      proofService['getProofMinimumDurationSeconds'] = jest.fn().mockReturnValue(seconds * 2)
+      expect(proofService.isIntentExpirationWithinProofMinimumDate('0x123', expires)).toBe(false)
+    })
+  })
+})

package/src/quote/dto/quote.intent.data.dto.ts

@@ -0,0 +1,35 @@
+import { QuoteRewardDataDTO, QuoteRewardDataType } from '@/quote/dto/quote.reward.data.dto'
+import { QuoteRouteDataDTO, QuoteRouteDataInterface } from '@/quote/dto/quote.route.data.dto'
+import { ApiProperty } from '@nestjs/swagger'
+import { Type } from 'class-transformer'
+import { IsNotEmpty, ValidateNested } from 'class-validator'
+
+/**
+ * The DTO for the intent data. Similar to {@link IntentType} except modified to
+ * include options for the solver to select fulfillment conditions, and with the
+ * on-chain data fields removed.
+ */
+export class QuoteIntentDataDTO implements QuoteIntentDataInterface {
+  @IsNotEmpty()
+  @ApiProperty()
+  dAppID: string
+
+  @IsNotEmpty()
+  @ApiProperty()
+  @ValidateNested()
+  @Type(() => QuoteRouteDataDTO)
+  route: QuoteRouteDataDTO
+
+  @IsNotEmpty()
+  @ApiProperty()
+  @ValidateNested()
+  @Type(() => QuoteRewardDataDTO)
+  reward: QuoteRewardDataDTO
+}
+
+export interface QuoteIntentDataInterface {
+  // The dApp ID of the intent, optional so schema can be shared for onchain intents and offchain quotes
+  dAppID?: string
+  route: QuoteRouteDataInterface
+  reward: QuoteRewardDataType
+}

package/src/quote/dto/quote.reward.data.dto.ts

@@ -0,0 +1,67 @@
+import { RewardTokensInterface } from '@/contracts'
+import { ViemAddressTransform } from '@/transforms/viem-address.decorator'
+import { RewardType } from '@eco-foundation/routes-ts'
+import { ApiProperty } from '@nestjs/swagger'
+import { Transform, Type } from 'class-transformer'
+import { ArrayNotEmpty, IsArray, IsNotEmpty, ValidateNested } from 'class-validator'
+import { getAddress, Hex } from 'viem'
+
+/**
+ * The DTO for the intent reward data. Similar to {@link RewardType} except
+ * that it does not contain the creator and tokens fields. Also has a modified
+ * tokens field that is an array of {@link QuoteRewardTokensDTO} which include the
+ * sender's willing token balance to use for the reward.
+ * @param prover denotes the prover address
+ * @param deadline denotes the deadline for the reward
+ * @param nativeValue denotes the native token value of the reward
+ * @param tokens denotes the array of {@link QuoteRewardTokensDTO} that the sender has
+ */
+export class QuoteRewardDataDTO implements QuoteRewardDataType {
+  @ViemAddressTransform()
+  @IsNotEmpty()
+  @ApiProperty()
+  creator: Hex
+
+  @ViemAddressTransform()
+  @IsNotEmpty()
+  @ApiProperty()
+  prover: Hex
+
+  @IsNotEmpty()
+  @Transform(({ value }) => BigInt(value))
+  @ApiProperty()
+  deadline: bigint
+
+  @IsNotEmpty()
+  @Transform(({ value }) => BigInt(value))
+  @ApiProperty()
+  nativeValue: bigint
+
+  @IsArray()
+  @ArrayNotEmpty()
+  @ValidateNested()
+  @ApiProperty()
+  @Type(() => QuoteRewardTokensDTO)
+  tokens: QuoteRewardTokensDTO[]
+}
+
+/**
+ * The DTO for the reward tokens that the sender has and wants to send.
+ * @param token denotes the token address
+ * @param amount denotes the amount of tokens the caller wants to send
+ * @param balance denotes the amount of tokens the caller can send
+ */
+export class QuoteRewardTokensDTO implements RewardTokensInterface {
+  @ViemAddressTransform()
+  @IsNotEmpty()
+  @ApiProperty()
+  @Transform(({ value }) => getAddress(value))
+  token: Hex
+
+  @IsNotEmpty()
+  @Transform(({ value }) => BigInt(value))
+  @ApiProperty()
+  amount: bigint
+}
+type QuoteRewardType = RewardType
+export type QuoteRewardDataType = QuoteRewardType