Add relay unit tests and e2e

lib/entities/quote/ClassicQuote.ts

@@ -160,7 +160,9 @@ export class ClassicQuote implements IQuote {
       : BigNumber.from(this.quoteData.amount);
   }
 
-  public get gasUseEstimateGasToken(): BigNumber | undefined {
+  public get gasUseEstimateGasToken(): BigNumber {
+    if (!this.quoteData.gasUseEstimateGasToken) throw new Error('No gasUseEstimateGasToken in ClassicQuote');
+
     return BigNumber.from(this.quoteData.gasUseEstimateGasToken);
   }
 

lib/entities/request/index.ts

@@ -1,3 +1,4 @@
+import { Protocol } from '@uniswap/router-sdk';
 import { TradeType } from '@uniswap/sdk-core';
 import { BigNumber } from 'ethers';
 
@@ -144,3 +145,16 @@ export function defaultRequestKey(request: QuoteRequest): string {
     type: info.type,
   });
 }
+
+export function parseProtocol(protocol: string): Protocol {
+  switch (protocol.toLowerCase()) {
+    case 'v2':
+      return Protocol.V2;
+    case 'v3':
+      return Protocol.V3;
+    case 'mixed':
+      return Protocol.MIXED;
+    default:
+      throw new Error(`Invalid protocol: ${protocol}`);
+  }
+}

lib/handlers/quote/handler.ts

@@ -18,6 +18,7 @@
   QuoteRequest,
   QuoteRequestBodyJSON,
   QuoteRequestInfo,
+  RelayQuote,
   RequestSource,
 } from '../../entities';
 import { TokenFetcher } from '../../fetchers/TokenFetcher';
@@ -339,8 +340,8 @@
 
   protected afterResponseHook(event: APIGatewayProxyEvent, _context: Context, response: APIGatewayProxyResult): void {
     const { statusCode } = response;
     const responseBody = JSON.parse(response.body!);
     const rawBody = JSON.parse(event.body!);
 
     if (statusCode != 200 && responseBody.errorCode == ErrorCode.ValidationError) {
       metrics.putMetric(`QuoteRequestValidationError`, 1);
@@ -451,27 +452,57 @@
   }, null);
 }
 
-// compares two quotes of any type and returns the best one based on tradeType
-export function compareQuotes(lhs: Quote, rhs: Quote, tradeType: TradeType): boolean {
+export const QuoteComparisonOverrides = {
+  relayAndClassic(lhs: Quote, rhs: Quote): boolean {
+    return (
+      (lhs.routingType === RoutingType.CLASSIC && rhs.routingType === RoutingType.RELAY) ||
+      (rhs.routingType === RoutingType.CLASSIC && lhs.routingType === RoutingType.RELAY)
+    );
+  },
+
+  breakTie(lhs: Quote, rhs: Quote): boolean {
+    // Prefer relay over classic if requested together
+    if (QuoteComparisonOverrides.relayAndClassic(lhs, rhs)) return lhs.routingType === RoutingType.RELAY;
+    // Otherwise, we default to keeping rhs in the case of a tie
+    return false;
+  },
+};
+
+// Compare quotes, returning true if lhs is better than rhs
+// Applies any overrides before the default comparision logic using quoted amount
+export const compareQuotes = (lhs: Quote, rhs: Quote, tradeType: TradeType): boolean => {
+  if (getQuotedAmount(lhs, tradeType).eq(getQuotedAmount(rhs, tradeType))) {
+    return QuoteComparisonOverrides.breakTie(lhs, rhs);
+  }
+
+  // Default comparison if no overrides apply
   if (tradeType === TradeType.EXACT_INPUT) {
     return getQuotedAmount(lhs, tradeType).gt(getQuotedAmount(rhs, tradeType));
   } else {
     // EXACT_OUTPUT
     return getQuotedAmount(lhs, tradeType).lt(getQuotedAmount(rhs, tradeType));
   }
-}
+};
 
 const getQuotedAmount = (quote: Quote, tradeType: TradeType) => {
   if (tradeType === TradeType.EXACT_INPUT) {
     if (quote.routingType === RoutingType.CLASSIC) {
       return (quote as ClassicQuote).amountOutGasAndPortionAdjusted;
+    } else if (quote.routingType === RoutingType.DUTCH_LIMIT) {
+      return (quote as DutchQuote).amountOutGasAndPortionAdjusted;
+    } else if (quote.routingType === RoutingType.RELAY) {
+      return (quote as RelayQuote).classicQuote.amountOutGasAndPortionAdjusted;
     }
-    return (quote as DutchQuote).amountOutGasAndPortionAdjusted;
+    throw new Error(`Invalid routing type: ${quote}`);
   } else {
     if (quote.routingType === RoutingType.CLASSIC) {
       return (quote as ClassicQuote).amountInGasAndPortionAdjusted;
+    } else if (quote.routingType === RoutingType.DUTCH_LIMIT) {
+      return (quote as DutchQuote).amountInGasAndPortionAdjusted;
+    } else if (quote.routingType === RoutingType.RELAY) {
+      return (quote as RelayQuote).classicQuote.amountInGasAndPortionAdjusted;
     }
-    return (quote as DutchQuote).amountInGasAndPortionAdjusted;
+    throw new Error(`Invalid routing type: ${quote}`);
   }
 };
 

lib/handlers/quote/schema.ts

@@ -10,8 +10,13 @@
   amount: FieldValidator.amount.required(),
   type: FieldValidator.tradeType.required(),
   configs: Joi.array()
-    .items(FieldValidator.classicConfig, FieldValidator.dutchLimitConfig, FieldValidator.dutchV2Config)
+    .items(
+      FieldValidator.classicConfig,
+      FieldValidator.dutchLimitConfig,
+      FieldValidator.dutchV2Config,
+      FieldValidator.relayConfig
+    )
     .unique((a: any, b: any) => {
       return a.routingType === b.routingType;
     })
     .required()

lib/util/validator.ts

@@ -38,7 +38,7 @@ export class FieldValidator {
 
   public static readonly tradeType = Joi.string().valid('EXACT_INPUT', 'EXACT_OUTPUT');
 
-  public static readonly routingType = Joi.string().valid('CLASSIC', 'DUTCH_LIMIT', 'DUTCH_V2').messages({
+  public static readonly routingType = Joi.string().valid('CLASSIC', 'DUTCH_LIMIT', 'DUTCH_V2', 'RELAY').messages({
     'any.only': 'Invalid routingType',
   });
 
@@ -110,6 +110,18 @@ export class FieldValidator {
     useSyntheticQuotes: Joi.boolean().optional(),
   });
 
+  // extends a classic request config, but requires a gasToken and has optional parameters for the fee auction
+  public static readonly relayConfig = this.classicConfig.keys({
+    routingType: Joi.string().valid('RELAY'),
+    gasToken: FieldValidator.address.required(),
+    swapper: FieldValidator.address.optional(),
+    startTimeBufferSecs: FieldValidator.positiveNumber.optional(),
+    auctionPeriodSecs: FieldValidator.positiveNumber.optional(),
+    deadlineBufferSecs: FieldValidator.positiveNumber.optional(),
+    slippageTolerance: FieldValidator.slippageTolerance.optional(),
+    amountInGasTokenStartOverride: FieldValidator.amount.optional(),
+  });
+
   public static readonly dutchV2Config = Joi.object({
     routingType: Joi.string().valid('DUTCH_V2'),
     swapper: FieldValidator.address.optional(),

test/constants.ts

@@ -1,3 +1,4 @@
+import { Protocol } from '@uniswap/router-sdk';
 import { ChainId, Currency, Ether, WETH9 } from '@uniswap/sdk-core';
 import { DAI_MAINNET, USDC_MAINNET, WBTC_MAINNET } from '@uniswap/smart-order-router';
 import { UNIVERSAL_ROUTER_ADDRESS } from '@uniswap/universal-router-sdk';
@@ -49,7 +50,15 @@ export const DUTCH_V2_CONFIG = {
 
 export const CLASSIC_CONFIG = {
   routingType: RoutingType.CLASSIC,
-  protocols: ['V2', 'V3', 'MIXED'],
+  protocols: [Protocol.V2, Protocol.V3, Protocol.MIXED],
+};
+
+export const RELAY_CONFIG = {
+  routingType: RoutingType.RELAY,
+  protocols: [Protocol.V2, Protocol.V3, Protocol.MIXED],
+  swapper: SWAPPER,
+  auctionPeriodSecs: 60,
+  gasToken: TOKEN_IN,
 };
 
 export const PERMIT2_USED = {

test/integ/base.test.ts

@@ -11,7 +11,7 @@ import {
   WBTC_MAINNET,
   WETH9,
 } from '@uniswap/smart-order-router';
-import { DutchOrder } from '@uniswap/uniswapx-sdk';
+import { DutchOrder, RelayOrder } from '@uniswap/uniswapx-sdk';
 import {
   PERMIT2_ADDRESS,
   UNIVERSAL_ROUTER_ADDRESS as UNIVERSAL_ROUTER_ADDRESS_BY_CHAIN,
@@ -20,7 +20,7 @@ import { fail } from 'assert';
 import axiosStatic, { AxiosRequestConfig, AxiosResponse } from 'axios';
 import axiosRetry from 'axios-retry';
 import { expect } from 'chai';
-import { BigNumber, providers } from 'ethers';
+import { BigNumber, Contract, ContractFactory, providers } from 'ethers';
 import hre from 'hardhat';
 import _ from 'lodash';
 import NodeCache from 'node-cache';
@@ -29,7 +29,7 @@ import { ClassicQuoteDataJSON } from '../../lib/entities/quote';
 import { QuoteRequestBodyJSON } from '../../lib/entities/request';
 import { Portion, PortionFetcher } from '../../lib/fetchers/PortionFetcher';
 import { QuoteResponseJSON } from '../../lib/handlers/quote/handler';
-import { ExclusiveDutchOrderReactor__factory, Permit2__factory } from '../../lib/types/ext';
+import { ExclusiveDutchOrderReactor__factory, Permit2__factory, RelayOrderReactor__factory } from '../../lib/types/ext';
 import { resetAndFundAtBlock } from '../utils/forkAndFund';
 import { getBalance, getBalanceAndApprove } from '../utils/getBalanceAndApprove';
 import { agEUR_MAINNET, BULLET, getAmount, UNI_MAINNET, XSGD_MAINNET } from '../utils/tokens';
@@ -291,17 +291,65 @@ export class BaseIntegrationTestSuite {
     };
   };
 
+  executeRelaySwap = async (
+    swapper: SignerWithAddress,
+    filler: SignerWithAddress,
+    order: RelayOrder,
+    currencyIn: Currency,
+    currencyGasToken: Currency,
+    currencyOut: Currency
+  ): Promise<{
+    tokenInAfter: CurrencyAmount<Currency>;
+    tokenInBefore: CurrencyAmount<Currency>;
+    gasTokenAfter: CurrencyAmount<Currency>;
+    gasTokenBefore: CurrencyAmount<Currency>;
+    tokenOutAfter: CurrencyAmount<Currency>;
+    tokenOutBefore: CurrencyAmount<Currency>;
+  }> => {
+    const reactor = RelayOrderReactor__factory.connect(order.info.reactor, filler);
+
+    // Approve Permit2 for Alice
+    // Note we pass in currency.wrapped, since reactor does not support native ETH in
+    const tokenInBefore = await getBalanceAndApprove(swapper, PERMIT2_ADDRESS, currencyIn.wrapped);
+    const tokenOutBefore = await getBalance(swapper, currencyOut);
+    const gasTokenBefore = await getBalanceAndApprove(swapper, PERMIT2_ADDRESS, currencyGasToken.wrapped);
+
+    const { domain, types, values } = order.permitData();
+    const signature = await swapper._signTypedData(domain, types, values);
+
+    const transactionResponse = await reactor['execute((bytes,bytes),address)'](
+      { order: order.serialize(), sig: signature },
+      filler.address
+    );
+    await transactionResponse.wait();
+
+    const tokenInAfter = await getBalance(swapper, currencyIn.wrapped);
+    const tokenOutAfter = await getBalance(swapper, currencyOut);
+    const gasTokenAfter = await getBalance(swapper, currencyGasToken.wrapped);
+
+    return {
+      tokenInAfter,
+      tokenInBefore,
+      tokenOutAfter,
+      tokenOutBefore,
+      gasTokenAfter,
+      gasTokenBefore,
+    };
+  };
+
   before = async () => {
-    const [alice, filler] = await ethers.getSigners();
+    let alice: SignerWithAddress;
+    let filler: SignerWithAddress;
+    [alice, filler] = await ethers.getSigners();
 
     // Make a dummy call to the API to get a block number to fork from.
     const quoteReq: QuoteRequestBodyJSON = {
       requestId: 'id',
       tokenIn: 'USDC',
       tokenInChainId: 1,
-      tokenOut: 'USDT',
+      tokenOut: 'DAI',
       tokenOutChainId: 1,
-      amount: await getAmount(1, 'EXACT_INPUT', 'USDC', 'USDT', '100'),
+      amount: await getAmount(1, 'EXACT_INPUT', 'USDC', 'DAI', '100'),
       type: 'EXACT_INPUT',
       configs: [
         {
@@ -318,7 +366,7 @@ export class BaseIntegrationTestSuite {
 
     this.block = parseInt(blockNumber) - 10;
 
-    await resetAndFundAtBlock(alice, this.block, [
+    alice = await resetAndFundAtBlock(alice, this.block, [
       parseAmount('80000000', USDC_MAINNET),
       parseAmount('50000000', USDT_MAINNET),
       parseAmount('100', WBTC_MAINNET),
@@ -337,4 +385,10 @@ export class BaseIntegrationTestSuite {
 
     return [alice, filler];
   };
+
+  deployContract = async (factory: ContractFactory, args: any[]): Promise<Contract> => {
+    const contract = await factory.deploy(...args);
+    await contract.deployed();
+    return contract;
+  };
 }