HardQuoteRequest.ts

import { TradeType } from '@uniswap/sdk-core';
import { OrderType, UnsignedV2DutchOrder, UnsignedV3DutchOrder } from '@uniswap/uniswapx-sdk';
import { BigNumber, ethers, utils } from 'ethers';
import { v4 as uuidv4 } from 'uuid';

import { QuoteRequest, QuoteRequestDataJSON } from '.';
import { HardQuoteRequestBody } from '../handlers/hard-quote';
import { ProtocolVersion } from '../providers';

export class HardQuoteRequest {
  public order: UnsignedV2DutchOrder | UnsignedV3DutchOrder;
  private data: HardQuoteRequestBody;
  private readonly _protocol: ProtocolVersion;

  public static fromHardRequestBody(body: HardQuoteRequestBody, orderType: OrderType): HardQuoteRequest {
    return new HardQuoteRequest(body, orderType);
  }

  constructor(_data: HardQuoteRequestBody, orderType: OrderType) {
    this.data = {
      ..._data,
      requestId: _data.quoteId ?? uuidv4(),
    };
    if (orderType === OrderType.Dutch_V2) {
      this.order = UnsignedV2DutchOrder.parse(_data.encodedInnerOrder, _data.tokenInChainId);
      this._protocol = ProtocolVersion.V2;
    } else if (orderType === OrderType.Dutch_V3) {
      this.order = UnsignedV3DutchOrder.parse(_data.encodedInnerOrder, _data.tokenInChainId);
      this._protocol = ProtocolVersion.V3;
    } else {
      throw new Error('Unsupported order type');
    }
  }

  public toCleanJSON(): QuoteRequestDataJSON {
    return {
      tokenInChainId: this.tokenInChainId,
      tokenOutChainId: this.tokenOutChainId,
      swapper: ethers.constants.AddressZero,
      requestId: this.requestId,
      tokenIn: this.tokenIn,
      tokenOut: this.tokenOut,
      amount: this.amount.toString(),
      type: TradeType[this.type],
      numOutputs: this.numOutputs,
      ...(this.quoteId && { quoteId: this.quoteId }),
      protocol: this.protocol,
    };
  }

  // return an opposing quote request,
  // i.e. quoting the other side of the trade
  public toOpposingCleanJSON(): QuoteRequestDataJSON {
    const type = this.type === TradeType.EXACT_INPUT ? TradeType.EXACT_OUTPUT : TradeType.EXACT_INPUT;
    return {
      ...this.toCleanJSON(),
      // switch tokenIn/tokenOut
      tokenIn: utils.getAddress(this.tokenOut),
      tokenOut: utils.getAddress(this.tokenIn),
      amount: this.amount.toString(),
      // switch tradeType
      type: TradeType[type],
    };
  }

  // transforms into a quote request that can be used to query quoters
  public toQuoteRequest(): QuoteRequest {
    return new QuoteRequest({
      ...this.toCleanJSON(),
      swapper: this.swapper,
      amount: this.amount,
      type: this.type,
    });
  }

  public get requestId(): string {
    return this.data.requestId;
  }

  public get tokenInChainId(): number {
    return this.data.tokenInChainId;
  }

  // See the matching note in QuoteRequest: this getter previously returned the tokenIn chain
  // id. Value-identical today because HardQuoteRequestBodyJoi pins tokenOutChainId to
  // Joi.ref('tokenInChainId').
  public get tokenOutChainId(): number {
    return this.data.tokenOutChainId;
  }

  public get swapper(): string {
    return this.order.info.swapper;
  }

  public get tokenIn(): string {
    return utils.getAddress(this.order.info.input.token);
  }

  public get tokenOut(): string {
    return utils.getAddress(this.order.info.outputs[0].token);
  }

  /**
   * Whether every output pays outputs[0].token.
   *
   * `totalOutputAmountStart` below sums the outputs as raw integers, and `toCleanJSON`
   * sends quoters that one scalar alongside a single `tokenOut` taken from outputs[0].
   * Both are only meaningful when the outputs agree on a token: otherwise the amount
   * mixes assets of different denominations, and the quoter prices something the order
   * does not contain. Multi-output orders are the normal case, since fee outputs use the
   * swapper output's token.
   */
  public get hasUniformOutputTokens(): boolean {
    const tokenOut = this.tokenOut;
    for (const output of this.order.info.outputs) {
      if (utils.getAddress(output.token) !== tokenOut) {
        return false;
      }
    }

    return true;
  }

  public get outputTokens(): string[] {
    const tokens: string[] = [];
    for (const output of this.order.info.outputs) {
      tokens.push(utils.getAddress(output.token));
    }

    return tokens;
  }

  public get totalOutputAmountStart(): BigNumber {
    let amount = BigNumber.from(0);
    for (const output of this.order.info.outputs) {
      amount = amount.add(output.startAmount);
    }

    return amount;
  }

  public get totalInputAmountStart(): BigNumber {
    return this.order.info.input.startAmount;
  }

  public get amount(): BigNumber {
    if (this.type === TradeType.EXACT_INPUT) {
      return this.totalInputAmountStart;
    } else {
      return this.totalOutputAmountStart;
    }
  }

  public get type(): TradeType {
    if (this.order instanceof UnsignedV2DutchOrder) {
      return this.order.info.input.startAmount.eq(this.order.info.input.endAmount)
        ? TradeType.EXACT_INPUT
        : TradeType.EXACT_OUTPUT;
    } else if (this.order instanceof UnsignedV3DutchOrder) {
      // If curve doesn't exist OR has all relative amounts are zero, then it's EXACT_INPUT
      return !this.order.info.input.curve ||
        !this.order.info.input.curve.relativeAmounts.some((relativeAmount) => relativeAmount !== BigInt(0))
        ? TradeType.EXACT_INPUT
        : TradeType.EXACT_OUTPUT;
    } else {
      throw new Error('Unsupported order type');
    }
  }

  public get numOutputs(): number {
    return this.order.info.outputs.length;
  }

  public get protocol(): ProtocolVersion {
    return this._protocol;
  }

  public get cosigner(): string {
    return this.order.info.cosigner;
  }

  public get innerSig(): string {
    return this.data.innerSig;
  }

  public get quoteId(): string | undefined {
    return this.data.quoteId;
  }

  public set quoteId(quoteId: string | undefined) {
    this.data.quoteId = quoteId;
  }
}