eco-solver 0.0.1-security → 1.5.2

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

@@ -0,0 +1,71 @@
+import { CallDataInterface } from '@/contracts'
+import { QuoteRewardTokensDTO } from '@/quote/dto/quote.reward.data.dto'
+import { ViemAddressTransform } from '@/transforms/viem-address.decorator'
+import { RouteType } 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 { Hex } from 'viem'
+
+/**
+ * The DTO for the route data that the sender wants to make.
+ * Similar to {@link RouteType} except that it does not contain the salt field.
+ * @param source denotes the source chain id of the route
+ * @param destination denotes the destination chain id of the route
+ * @param inbox denotes the inbox address
+ * @param calls denotes the array of {@link QuoteCallDataDTO} that the sender wants to make
+ */
+export class QuoteRouteDataDTO implements QuoteRouteDataInterface {
+  @IsNotEmpty()
+  @ApiProperty()
+  @Transform(({ value }) => BigInt(value))
+  source: bigint
+
+  @IsNotEmpty()
+  @Transform(({ value }) => BigInt(value))
+  @ApiProperty()
+  destination: bigint
+
+  @ViemAddressTransform()
+  @IsNotEmpty()
+  @ApiProperty()
+  inbox: Hex
+
+  @IsArray()
+  @ArrayNotEmpty()
+  @ValidateNested()
+  @ApiProperty()
+  @Type(() => QuoteRewardTokensDTO)
+  tokens: QuoteRewardTokensDTO[]
+
+  @IsArray()
+  @ArrayNotEmpty()
+  @ValidateNested()
+  @ApiProperty()
+  @Type(() => QuoteCallDataDTO)
+  calls: QuoteCallDataDTO[]
+}
+
+/**
+ * The DTO for the call data that the sender wants to make.
+ * @param target denotes the target address of the call
+ * @param data denotes the data of the call
+ * @param value denotes the native token value of the call
+ */
+export class QuoteCallDataDTO implements CallDataInterface {
+  @ViemAddressTransform()
+  @IsNotEmpty()
+  @ApiProperty()
+  target: Hex
+
+  @IsNotEmpty()
+  @ApiProperty()
+  data: Hex
+
+  @IsNotEmpty()
+  @Transform(({ value }) => BigInt(value))
+  @ApiProperty()
+  value: bigint
+}
+
+export interface QuoteRouteDataInterface extends Omit<RouteType, 'salt'> {}

package/src/quote/dto/types.ts

@@ -0,0 +1,18 @@
+import { RewardType, RouteType } from '@eco-foundation/routes-ts'
+import { Prettify } from 'viem'
+
+/**
+ * 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 type RewardTokensType = Prettify<RewardType['tokens'][number]>
+
+/**
+ * The type for the route calls that the sender wants to make.
+ * @param target denotes the target address of the call
+ * @param data denotes the data of the call
+ * @param value denotes the native token value of the call
+ */
+export type CallDataType = RouteType['calls'][number]

package/src/quote/errors.ts

@@ -0,0 +1,215 @@
+import { EcoError } from '@/common/errors/eco-error'
+import { FeeAlgorithm } from '@/eco-configs/eco-config.types'
+import { ValidationChecks } from '@/intent/validation.sevice'
+import { Hex } from 'viem'
+
+/**
+ * Errors that can be thrown by the quote service
+ */
+export interface QuoteErrorsInterface {
+  statusCode: number
+  message: string
+  code: number
+  [key: string]: any
+}
+
+export type Quote400 = QuoteErrorsInterface & {
+  statusCode: 400
+}
+
+export type Quote500 = QuoteErrorsInterface & {
+  statusCode: 500
+}
+
+// The solver does not supoort the request prover
+export const ProverUnsupported: Quote400 = {
+  statusCode: 400,
+  message: 'Bad Request: The prover selected is not supported.',
+  code: 1,
+}
+
+// The quote does not have a reward structure that would be accepted by solver
+export const RewardInvalid: Quote400 = {
+  statusCode: 400,
+  message: "Bad Request: The reward structure is invalid. Solver doesn't accept the reward.",
+  code: 2,
+}
+
+// The quote does not support some of the callData
+export const CallsUnsupported: Quote400 = {
+  statusCode: 400,
+  message: 'Bad Request: Some callData in calls are not supported.',
+  code: 3,
+}
+
+// The quote does not support some of the callData
+export const SolverUnsupported: Quote400 = {
+  statusCode: 400,
+  message: "Bad Request: The solver doesn't support that chain.",
+  code: 4,
+}
+
+// The quote intent is deemed invalid by the validation service
+export function InvalidQuoteIntent(validations: ValidationChecks): Quote400 {
+  return {
+    statusCode: 400,
+    message: 'Bad Request: The quote was deemed invalid.',
+    code: 4,
+    properties: {
+      validations,
+    },
+  }
+}
+
+/**
+ * The quote intent cannot be fulfilled because it doesn't have a
+ * reward hight enough to cover the ask
+ *
+ * @param totalAsk the total amount of the ask
+ * @param totalRewardAmount the total amount of the reward
+ * @returns
+ */
+export function InsufficientBalance(totalAsk: bigint, totalFulfillmentAmount: bigint): Quote400 {
+  return {
+    statusCode: 400,
+    message:
+      'Bad Request: The quote intent balance was insufficient for fulfillment. TotalAsk > TotalFulfillmentAmount',
+    code: 5,
+    properties: {
+      totalAsk,
+      totalFulfillmentAmount,
+    },
+  }
+}
+
+// The quote is deemed infeasible by the feasibility service
+export function InfeasibleQuote(error: Error): Quote400 {
+  return {
+    statusCode: 400,
+    message: 'Bad Request: The quote was deemed infeasible.',
+    code: 6,
+    error,
+  }
+}
+
+// The quote is deemed invalid by the feasibility service
+export function InvalidQuote(
+  results: (
+    | false
+    | {
+        solvent: boolean
+        profitable: boolean
+      }
+    | undefined
+  )[],
+): Quote400 {
+  return {
+    statusCode: 400,
+    message: 'Bad Request: The quote was deemed invalid.',
+    code: 7,
+    results,
+  }
+}
+// The quote is deemed to be insolvent or unprofitable by the feasibility service
+export function InsolventUnprofitableQuote(
+  results: (
+    | false
+    | {
+        solvent: boolean
+        profitable: boolean
+      }
+    | undefined
+  )[],
+): Quote400 {
+  return {
+    statusCode: 400,
+    message: 'Bad Request: The quote was deemed to be insolvent or unprofitable.',
+    code: 8,
+    results,
+  }
+}
+
+/////////////
+
+/**
+ * The server failed to save to db
+ * @param error  the error that was thrown
+ * @returns
+ */
+export function InternalSaveError(error: Error): Quote500 {
+  return {
+    statusCode: 500,
+    message: 'Internal Server Error: Failed to save quote intent.',
+    code: 1,
+    error,
+  }
+}
+
+/**
+ * The server failed to generate the quote
+ * @returns
+ */
+export function InternalQuoteError(error?: Error): Quote500 {
+  return {
+    statusCode: 500,
+    message: 'Internal Server Error: Failed generate quote.',
+    code: 2,
+    error,
+  }
+}
+
+export class QuoteError extends Error {
+  static InvalidSolverAlgorithm(destination: bigint, algorithm: FeeAlgorithm) {
+    return new EcoError(
+      `The solver for destination chain ${destination} did not return a valid algorithm : ${algorithm} `,
+    )
+  }
+
+  static NoSolverForDestination(destination: bigint) {
+    return new EcoError(`No solver found for destination chain ${destination}`)
+  }
+
+  static NoIntentSourceForSource(source: bigint) {
+    return new EcoError(`No intent source found for source chain ${source}`)
+  }
+
+  static FetchingRewardTokensFailed(chainID: bigint) {
+    return new EcoError(`Error occured when fetching reward tokens for ${chainID}`)
+  }
+
+  static FetchingCallTokensFailed(chainID: bigint) {
+    return new EcoError(`Error occured when fetching call tokens for ${chainID}`)
+  }
+
+  static NonERC20TargetInCalls() {
+    return new EcoError(`One or more targets not erc20s`)
+  }
+
+  static SolverLacksLiquidity(
+    chainID: number,
+    target: Hex,
+    requested: bigint,
+    available: bigint,
+    normMinBalance: bigint,
+  ) {
+    return new EcoError(
+      `The solver on chain ${chainID} lacks liquidity for ${target} requested ${requested} available ${available} with a normMinBalance of ${normMinBalance}`,
+    )
+  }
+
+  static RouteIsInfeasable(ask: bigint, reward: bigint) {
+    return new EcoError(
+      `The route is not infeasable: the reward ${reward} is less than the ask ${ask}`,
+    )
+  }
+
+  static MultiFulfillRoute() {
+    return new EcoError(`A route with more than 1 erc20 target is not supported`)
+  }
+
+  static FailedToFetchTarget(chainID: bigint, target: Hex) {
+    return new EcoError(
+      `Cannot resolve the decimals of a call target ${target} on chain ${chainID}`,
+    )
+  }
+}

package/src/quote/quote.module.ts

@@ -0,0 +1,17 @@
+import { Module } from '@nestjs/common'
+import { QuoteService } from './quote.service'
+import { MongooseModule } from '@nestjs/mongoose'
+import { QuoteIntentModel, QuoteIntentSchema } from '@/quote/schemas/quote-intent.schema'
+import { IntentModule } from '@/intent/intent.module'
+import { FeeModule } from '@/fee/fee.module'
+
+@Module({
+  imports: [
+    FeeModule,
+    IntentModule,
+    MongooseModule.forFeature([{ name: QuoteIntentModel.name, schema: QuoteIntentSchema }]),
+  ],
+  providers: [QuoteService],
+  exports: [QuoteService],
+})
+export class QuoteModule {}

package/src/quote/quote.service.ts

@@ -0,0 +1,299 @@
+import { EcoLogMessage } from '@/common/logging/eco-log-message'
+import { RewardTokensInterface } from '@/contracts'
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import { validationsSucceeded, ValidationService } from '@/intent/validation.sevice'
+import { QuoteIntentDataDTO, QuoteIntentDataInterface } from '@/quote/dto/quote.intent.data.dto'
+import {
+  InfeasibleQuote,
+  InsufficientBalance,
+  InternalQuoteError,
+  InternalSaveError,
+  InvalidQuoteIntent,
+  Quote400,
+  Quote500,
+  SolverUnsupported,
+} from '@/quote/errors'
+import { QuoteIntentModel } from '@/quote/schemas/quote-intent.schema'
+import { Mathb } from '@/utils/bigint'
+import { Injectable, Logger } from '@nestjs/common'
+import { InjectModel } from '@nestjs/mongoose'
+import { Model } from 'mongoose'
+import * as dayjs from 'dayjs'
+import { Hex } from 'viem'
+import { FeeService } from '@/fee/fee.service'
+import { CalculateTokensType } from '@/fee/types'
+
+/**
+ * Service class for getting configs for the app
+ */
+@Injectable()
+export class QuoteService {
+  private logger = new Logger(QuoteService.name)
+
+  constructor(
+    @InjectModel(QuoteIntentModel.name) private quoteIntentModel: Model<QuoteIntentModel>,
+    private readonly feeService: FeeService,
+    private readonly validationService: ValidationService,
+    private readonly ecoConfigService: EcoConfigService,
+  ) {}
+
+  /**
+   * Generates a quote for the quote intent data.
+   * The network quoteIntentDataDTO is stored in the db.
+   *
+   * @param quoteIntentDataDTO the quote intent data
+   * @returns
+   */
+  async getQuote(quoteIntentDataDTO: QuoteIntentDataDTO) {
+    this.logger.log(
+      EcoLogMessage.fromDefault({
+        message: `Getting quote for intent`,
+        properties: {
+          quoteIntentDataDTO,
+        },
+      }),
+    )
+    const quoteIntent = await this.storeQuoteIntentData(quoteIntentDataDTO)
+    if (quoteIntent instanceof Error) {
+      return InternalSaveError(quoteIntent)
+    }
+    const res = await this.validateQuoteIntentData(quoteIntent)
+    if (res) {
+      return res
+    }
+
+    let quoteRes:
+      | Quote400
+      | Quote500
+      | {
+          tokens: RewardTokensInterface[]
+          expiryTime: string
+        }
+      | Error
+    try {
+      quoteRes = await this.generateQuote(quoteIntent)
+    } catch (e) {
+      quoteRes = InternalQuoteError(e)
+    } finally {
+      await this.updateQuoteDb(quoteIntent, quoteRes!)
+    }
+
+    return quoteRes
+  }
+
+  /**
+   * Stores the quote into the db
+   * @param quoteIntentDataDTO the quote intent data
+   * @returns the stored record or an error
+   */
+  async storeQuoteIntentData(
+    quoteIntentDataDTO: QuoteIntentDataDTO,
+  ): Promise<QuoteIntentModel | Error> {
+    try {
+      const record = await this.quoteIntentModel.create(quoteIntentDataDTO)
+      this.logger.log(
+        EcoLogMessage.fromDefault({
+          message: `Recorded quote intent`,
+          properties: {
+            record,
+          },
+        }),
+      )
+      return record
+    } catch (e) {
+      this.logger.error(
+        EcoLogMessage.fromDefault({
+          message: `Error in storeQuoteIntentData`,
+          properties: {
+            quoteIntentDataDTO,
+            error: e,
+          },
+        }),
+      )
+      return e
+    }
+  }
+
+  /**
+   * Validates that the quote intent data is valid.
+   * Checks that there is a solver, that the assert validations pass,
+   * and that the quote intent is feasible.
+   * @param quoteIntentModel the model to validate
+   * @returns an res 400, or undefined if the quote intent is valid
+   */
+  async validateQuoteIntentData(quoteIntentModel: QuoteIntentModel): Promise<Quote400 | undefined> {
+    const solver = this.ecoConfigService.getSolver(quoteIntentModel.route.destination)
+    if (!solver) {
+      this.logger.log(
+        EcoLogMessage.fromDefault({
+          message: `validateQuoteIntentData: No solver found for destination : ${quoteIntentModel.route.destination}`,
+          properties: {
+            quoteIntentModel,
+          },
+        }),
+      )
+      await this.updateQuoteDb(quoteIntentModel, { error: SolverUnsupported })
+      return SolverUnsupported
+    }
+
+    const validations = await this.validationService.assertValidations(quoteIntentModel, solver)
+    if (!validationsSucceeded(validations)) {
+      this.logger.log(
+        EcoLogMessage.fromDefault({
+          message: `validateQuoteIntentData: Some validations failed`,
+          properties: {
+            quoteIntentModel,
+            validations,
+          },
+        }),
+      )
+      await this.updateQuoteDb(quoteIntentModel, { error: InvalidQuoteIntent(validations) })
+      return InvalidQuoteIntent(validations)
+    }
+
+    const { error } = await this.feeService.isRouteFeasible(quoteIntentModel)
+
+    if (error) {
+      const quoteError = InfeasibleQuote(error)
+      this.logger.log(
+        EcoLogMessage.fromDefault({
+          message: `validateQuoteIntentData: quote intent is not feasable ${quoteIntentModel._id}`,
+          properties: {
+            quoteIntentModel,
+            feasable: false,
+            error: quoteError,
+          },
+        }),
+      )
+      await this.updateQuoteDb(quoteIntentModel, { error: quoteError })
+      return quoteError
+    }
+    return
+  }
+
+  /**
+   * Generates a quote for the quote intent model. The quote is generated by:
+   * 1. Converting the call and reward tokens to a standard reserve value for comparisons
+   * 2. Adding a fee to the ask of the normalized call tokens
+   * 3. Fulfilling the ask with the reward tokens starting with any deficit tokens the solver
+   * has on the source chain
+   * 4. If there are any remaining tokens, they are used to fulfill the solver token
+   * starting with the smallest delta(minBalance - balance) tokens
+   * @param quoteIntentModel the quote intent model
+   * @returns the quote or an error 400 for insufficient reward to generate the quote
+   */
+  async generateQuote(quoteIntentModel: QuoteIntentDataInterface) {
+    const { calculated, error } = await this.feeService.calculateTokens(quoteIntentModel)
+    if (error || !calculated) {
+      return InternalQuoteError(error)
+    }
+
+    const { deficitDescending: fundable, calls, rewards } = calculated as CalculateTokensType
+
+    const totalFulfill = calls.reduce((acc, call) => acc + call.balance, 0n)
+    const totalAsk = this.feeService.getAsk(totalFulfill, quoteIntentModel)
+    const totalAvailableRewardAmount = rewards.reduce((acc, reward) => acc + reward.balance, 0n)
+    if (totalAsk > totalAvailableRewardAmount) {
+      return InsufficientBalance(totalAsk, totalAvailableRewardAmount)
+    }
+    let filled = 0n
+    const quoteRecord: Record<Hex, RewardTokensInterface> = {}
+    for (const deficit of fundable) {
+      if (filled >= totalAsk) {
+        break
+      }
+      const left = totalAsk - filled
+      //Only fill defits first pass
+      if (deficit.delta.balance < 0n) {
+        const reward = rewards.find((r) => r.address === deficit.delta.address)
+        if (reward) {
+          const amount = Mathb.min(
+            Mathb.min(Mathb.abs(deficit.delta.balance), reward.balance),
+            left,
+          )
+          if (amount > 0n) {
+            deficit.delta.balance += amount
+            reward.balance -= amount
+            filled += amount
+            //add to quote record
+            const tokenToFund = quoteRecord[deficit.delta.address] || {
+              token: deficit.delta.address,
+              amount: 0n,
+            }
+            tokenToFund.amount += this.feeService.deconvertNormalize(amount, deficit.delta).balance
+            quoteRecord[deficit.delta.address] = tokenToFund
+          }
+        }
+      }
+    }
+    //resort fundable to reflect first round of fills
+    fundable.sort((a, b) => Mathb.compare(a.delta.balance, b.delta.balance))
+
+    //if remaining funds, for those with smallest deltas
+    if (filled < totalAsk) {
+      for (const deficit of fundable) {
+        if (filled >= totalAsk) {
+          break
+        }
+        const left = totalAsk - filled
+        const reward = rewards.find((r) => r.address === deficit.delta.address)
+        if (reward) {
+          const amount = Mathb.min(left, reward.balance)
+          if (amount > 0n) {
+            deficit.delta.balance += amount
+            reward.balance -= amount
+            filled += amount
+            //add to quote record
+            const tokenToFund = quoteRecord[deficit.delta.address] || {
+              token: deficit.delta.address,
+              amount: 0n,
+            }
+            tokenToFund.amount += Mathb.abs(
+              this.feeService.deconvertNormalize(amount, deficit.delta).balance,
+            )
+            quoteRecord[deficit.delta.address] = tokenToFund
+          }
+        }
+      }
+    }
+
+    //todo save quote to record
+    return {
+      tokens: Object.values(quoteRecord),
+      expiryTime: this.getQuoteExpiryTime(),
+    }
+  }
+
+  /**
+   * @returns the expiry time of the quote
+   */
+  getQuoteExpiryTime(): string {
+    //todo implement expiry time logic
+    return dayjs().add(5, 'minutes').unix().toString()
+  }
+
+  /**
+   * Updates the quote intent model in the db
+   * @param quoteIntentModel the model to update
+   * @returns
+   */
+  async updateQuoteDb(quoteIntentModel: QuoteIntentModel, receipt?: any) {
+    try {
+      if (receipt) {
+        quoteIntentModel.receipt = receipt
+      }
+      await this.quoteIntentModel.updateOne({ _id: quoteIntentModel._id }, quoteIntentModel)
+    } catch (e) {
+      this.logger.error(
+        EcoLogMessage.fromDefault({
+          message: `Error in updateQuoteDb`,
+          properties: {
+            quoteIntentModel,
+            error: e,
+          },
+        }),
+      )
+      return e
+    }
+  }
+}

package/src/quote/schemas/quote-call.schema.ts

@@ -0,0 +1,16 @@
+import { CallDataInterface } from '@/contracts'
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose'
+import { Hex } from 'viem'
+
+@Schema({ timestamps: true })
+export class QuoteRouteCallDataModel implements CallDataInterface {
+  @Prop({ required: true, type: String })
+  target: Hex
+  @Prop({ required: true, type: String })
+  data: Hex
+  @Prop({ required: true, type: BigInt })
+  value: bigint
+}
+
+export const QuoteRouteCallDataSchema = SchemaFactory.createForClass(QuoteRouteCallDataModel)
+QuoteRouteCallDataSchema.index({ token: 1 }, { unique: false })

package/src/quote/schemas/quote-intent.schema.ts

@@ -0,0 +1,27 @@
+import { QuoteIntentDataInterface } from '@/quote/dto/quote.intent.data.dto'
+import { QuoteRewardDataModel, QuoteRewardDataSchema } from '@/quote/schemas/quote-reward.schema'
+import { QuoteRouteDataModel, QuoteRouteDataSchema } from '@/quote/schemas/quote-route.schema'
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose'
+import { Types } from 'mongoose'
+
+@Schema({ timestamps: true })
+export class QuoteIntentModel implements QuoteIntentDataInterface {
+  _id: Types.ObjectId
+
+  @Prop({ required: true, type: String })
+  dAppID: string
+
+  @Prop({ required: true, type: QuoteRouteDataSchema })
+  route: QuoteRouteDataModel
+
+  @Prop({ required: true, type: QuoteRewardDataSchema })
+  reward: QuoteRewardDataModel
+
+  @Prop({ type: Object })
+  receipt: any
+}
+
+export const QuoteIntentSchema = SchemaFactory.createForClass(QuoteIntentModel)
+QuoteIntentSchema.index({ dAppID: 1 }, { unique: false })
+QuoteIntentSchema.index({ 'route.source': 1 }, { unique: false })
+QuoteIntentSchema.index({ 'route.destination': 1 }, { unique: false })

package/src/quote/schemas/quote-reward.schema.ts

@@ -0,0 +1,24 @@
+import { QuoteRewardDataType } from '@/quote/dto/quote.reward.data.dto'
+import {
+  QuoteRewardTokenDataModel,
+  QuoteRewardTokenDataSchema,
+} from '@/quote/schemas/quote-token.schema'
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose'
+import { Hex } from 'viem'
+
+@Schema({ timestamps: true })
+export class QuoteRewardDataModel implements QuoteRewardDataType {
+  @Prop({ required: true, type: String })
+  creator: Hex
+  @Prop({ required: true, type: String })
+  prover: Hex
+  @Prop({ required: true, type: BigInt })
+  deadline: bigint
+  @Prop({ required: true, type: BigInt })
+  nativeValue: bigint
+  @Prop({ required: true, type: [QuoteRewardTokenDataSchema] })
+  tokens: QuoteRewardTokenDataModel[]
+}
+
+export const QuoteRewardDataSchema = SchemaFactory.createForClass(QuoteRewardDataModel)
+QuoteRewardDataSchema.index({ prover: 1 }, { unique: false })