asset-swapper: RFQ-T firm quotes

packages/asset-swapper/package.json

@@ -53,6 +53,7 @@
         "@0x/orderbook": "^2.2.5",
         "@0x/utils": "^5.4.1",
         "@0x/web3-wrapper": "^7.0.7",
+        "axios": "^0.19.2",
         "heartbeats": "^5.0.1",
         "lodash": "^4.17.11"
     },

packages/asset-swapper/src/constants.ts

@@ -43,6 +43,8 @@ const DEFAULT_SWAP_QUOTER_OPTS: SwapQuoterOpts = {
     },
     ...DEFAULT_ORDER_PRUNER_OPTS,
     samplerGasLimit: 250e6,
+    rfqtTakerApiKeyWhitelist: [],
+    rfqtMakerEndpoints: [],
 };
 
 const DEFAULT_FORWARDER_EXTENSION_CONTRACT_OPTS: ForwarderExtensionContractOpts = {

packages/asset-swapper/src/index.ts

@@ -42,6 +42,7 @@ export {
     GetExtensionContractTypeOpts,
     LiquidityForTakerMakerAssetDataPair,
     MarketBuySwapQuote,
+    MarketOperation,
     MarketSellSwapQuote,
     SwapQuote,
     SwapQuoteConsumerBase,
@@ -64,3 +65,4 @@ export {
 } from './utils/market_operation_utils/types';
 export { affiliateFeeUtils } from './utils/affiliate_fee_utils';
 export { ProtocolFeeUtils } from './utils/protocol_fee_utils';
+export { QuoteRequestor } from './utils/quote_requestor';

packages/asset-swapper/src/swap_quoter.ts

@@ -27,6 +27,7 @@ import { DexOrderSampler } from './utils/market_operation_utils/sampler';
 import { orderPrunerUtils } from './utils/order_prune_utils';
 import { OrderStateUtils } from './utils/order_state_utils';
 import { ProtocolFeeUtils } from './utils/protocol_fee_utils';
+import { QuoteRequestor } from './utils/quote_requestor';
 import { sortingUtils } from './utils/sorting_utils';
 import { SwapQuoteCalculator } from './utils/swap_quote_calculator';
 
@@ -36,12 +37,15 @@ export class SwapQuoter {
     public readonly expiryBufferMs: number;
     public readonly chainId: number;
     public readonly permittedOrderFeeTypes: Set<OrderPrunerPermittedFeeTypes>;
+    public readonly rfqtTakerApiKeyWhitelist: string[];
+    public readonly rfqtMakerEndpoints: string[];
     private readonly _contractAddresses: ContractAddresses;
     private readonly _protocolFeeUtils: ProtocolFeeUtils;
     private readonly _swapQuoteCalculator: SwapQuoteCalculator;
     private readonly _devUtilsContract: DevUtilsContract;
     private readonly _marketOperationUtils: MarketOperationUtils;
     private readonly _orderStateUtils: OrderStateUtils;
+    private readonly _quoteRequestor: QuoteRequestor;
 
     /**
      * Instantiates a new SwapQuoter instance given existing liquidity in the form of orders and feeOrders.
@@ -144,7 +148,12 @@ export class SwapQuoter {
      *
      * @return  An instance of SwapQuoter
      */
-    constructor(supportedProvider: SupportedProvider, orderbook: Orderbook, options: Partial<SwapQuoterOpts> = {}) {
+    constructor(
+        supportedProvider: SupportedProvider,
+        orderbook: Orderbook,
+        options: Partial<SwapQuoterOpts> = {},
+        quoteRequestor?: QuoteRequestor,
+    ) {
         const {
             chainId,
             expiryBufferMs,
@@ -161,10 +170,13 @@ export class SwapQuoter {
         this.orderbook = orderbook;
         this.expiryBufferMs = expiryBufferMs;
         this.permittedOrderFeeTypes = permittedOrderFeeTypes;
+        this.rfqtTakerApiKeyWhitelist = options.rfqtTakerApiKeyWhitelist || [];
+        this.rfqtMakerEndpoints = options.rfqtMakerEndpoints || [];
         this._contractAddresses = options.contractAddresses || getContractAddressesForChainOrThrow(chainId);
         this._devUtilsContract = new DevUtilsContract(this._contractAddresses.devUtils, provider);
         this._protocolFeeUtils = new ProtocolFeeUtils(constants.PROTOCOL_FEE_UTILS_POLLING_INTERVAL_IN_MS);
         this._orderStateUtils = new OrderStateUtils(this._devUtilsContract);
+        this._quoteRequestor = quoteRequestor || new QuoteRequestor(this.rfqtMakerEndpoints);
         const sampler = new DexOrderSampler(
             new IERC20BridgeSamplerContract(this._contractAddresses.erc20BridgeSampler, this.provider, {
                 gas: samplerGasLimit,
@@ -523,10 +535,29 @@ export class SwapQuoter {
             gasPrice = await this._protocolFeeUtils.getGasPriceEstimationOrThrowAsync();
         }
         // get the relevant orders for the makerAsset
-        let prunedOrders = await this._getSignedOrdersAsync(makerAssetData, takerAssetData);
+        let orders = await this._getSignedOrdersAsync(makerAssetData, takerAssetData);
+        if (options.intentOnFilling && options.apiKey) {
+            if (!this.rfqtTakerApiKeyWhitelist.includes(options.apiKey)) {
+                throw new Error('API key not permissioned for RFQ-T');
+            }
+            if (!options.takerAddress || options.takerAddress === '0x0000000000000000000000000000000000000000') {
+                throw new Error('RFQ-T requests must specify a taker address');
+            }
+            orders = orders.concat(
+                await this._quoteRequestor.requestRfqtFirmQuotesAsync(
+                    makerAssetData,
+                    takerAssetData,
+                    assetFillAmount,
+                    marketOperation,
+                    options.intentOnFilling,
+                    options.apiKey,
+                    options.takerAddress,
+                ),
+            );
+        }
         // if no native orders, pass in a dummy order for the sampler to have required metadata for sampling
-        if (prunedOrders.length === 0) {
-            prunedOrders = [
+        if (orders.length === 0) {
+            orders = [
                 createDummyOrderForSampler(makerAssetData, takerAssetData, this._contractAddresses.uniswapBridge),
             ];
         }
@@ -535,14 +566,14 @@ export class SwapQuoter {
 
         if (marketOperation === MarketOperation.Buy) {
             swapQuote = await this._swapQuoteCalculator.calculateMarketBuySwapQuoteAsync(
-                prunedOrders,
+                orders,
                 assetFillAmount,
                 gasPrice,
                 calculateSwapQuoteOpts,
             );
         } else {
             swapQuote = await this._swapQuoteCalculator.calculateMarketSellSwapQuoteAsync(
-                prunedOrders,
+                orders,
                 assetFillAmount,
                 gasPrice,
                 calculateSwapQuoteOpts,

packages/asset-swapper/src/types.ts

@@ -192,6 +192,10 @@ export interface SwapQuoteOrdersBreakdown {
  */
 export interface SwapQuoteRequestOpts extends CalculateSwapQuoteOpts {
     gasPrice?: BigNumber;
+    takerAddress?: string;
+    apiKey?: string;
+    enableRfqt?: boolean;
+    intentOnFilling?: boolean;
 }
 
 /**
@@ -213,6 +217,8 @@ export interface SwapQuoterOpts extends OrderPrunerOpts {
     contractAddresses?: ContractAddresses;
     samplerGasLimit?: number;
     liquidityProviderRegistryAddress?: string;
+    rfqtTakerApiKeyWhitelist: string[];
+    rfqtMakerEndpoints?: string[];
 }
 
 /**

packages/asset-swapper/src/utils/quote_requestor.ts

@@ -0,0 +1,99 @@
+import { assetDataUtils, SignedOrder } from '@0x/order-utils';
+import { ERC20AssetData } from '@0x/types';
+import { BigNumber, logUtils } from '@0x/utils';
+import Axios, { AxiosResponse } from 'axios';
+
+import { MarketOperation } from '../types';
+
+/**
+ * Request quotes from RFQ-T providers
+ */
+export class QuoteRequestor {
+    private readonly _rfqtMakerEndpoints: string[];
+
+    constructor(rfqtMakerEndpoints: string[]) {
+        this._rfqtMakerEndpoints = rfqtMakerEndpoints;
+    }
+
+    public async requestRfqtFirmQuotesAsync(
+        makerAssetData: string,
+        takerAssetData: string,
+        assetFillAmount: BigNumber,
+        marketOperation: MarketOperation,
+        intentOnFilling: boolean,
+        takerApiKey: string,
+        takerAddress: string,
+    ): Promise<SignedOrder[]> {
+        const makerEndpointMaxResponseTimeMs = 1000;
+
+        const getTokenAddressOrThrow = (assetData: string): string => {
+            const decodedAssetData = assetDataUtils.decodeAssetDataOrThrow(assetData);
+            if (decodedAssetData.hasOwnProperty('tokenAddress')) {
+                // type cast necessary here as decodeAssetDataOrThrow returns
+                // an AssetData object, which doesn't necessarily contain a
+                // token address.  (it could possibly be a StaticCallAssetData,
+                // which lacks an address.)  so we'll just assume it's a token
+                // here.  should be safe, with the enclosing guard condition
+                // and subsequent error.
+                // tslint:disable-next-line:no-unnecessary-type-assertion
+                return (decodedAssetData as ERC20AssetData).tokenAddress;
+            } else {
+                throw new Error(
+                    `Decoded asset data (${JSON.stringify(decodedAssetData)}) does not contain a token address`,
+                );
+            }
+        };
+
+        const buyToken = getTokenAddressOrThrow(makerAssetData);
+        const sellToken = getTokenAddressOrThrow(takerAssetData);
+
+        // create an array of promises for quote responses, using "undefined"
+        // as a placeholder for failed requests.
+
+        const responsePromises: Array<Promise<AxiosResponse<SignedOrder> | undefined>> = [];
+        for (const rfqtMakerEndpoint of this._rfqtMakerEndpoints) {
+            responsePromises.push(
+                Axios.get(`${rfqtMakerEndpoint}/quote`, {
+                    headers: { '0x-api-key': takerApiKey },
+                    params: {
+                        sellToken,
+                        buyToken,
+                        buyAmount: marketOperation === MarketOperation.Buy ? assetFillAmount.toString() : undefined,
+                        sellAmount: marketOperation === MarketOperation.Sell ? assetFillAmount.toString() : undefined,
+                        takerAddress,
+                    },
+                    timeout: makerEndpointMaxResponseTimeMs,
+                }).catch(err => {
+                    logUtils.warn(
+                        `Failed to get RFQ-T quote from market maker endpoint ${rfqtMakerEndpoint} for API key ${takerApiKey} for taker address ${takerAddress}: ${JSON.stringify(
+                            err,
+                        )}`,
+                    );
+                    return undefined;
+                }),
+            );
+        }
+
+        const responsesIfDefined: Array<AxiosResponse<SignedOrder> | undefined> = await Promise.all(responsePromises);
+
+        const responses: Array<AxiosResponse<SignedOrder>> = responsesIfDefined.filter(
+            (respIfDefd): respIfDefd is AxiosResponse<SignedOrder> => respIfDefd !== undefined,
+        );
+
+        const ordersWithStringInts = responses.map(response => response.data); // not yet BigNumber
+
+        const orders: SignedOrder[] = ordersWithStringInts.map(orderWithStringInts => {
+            return {
+                ...orderWithStringInts,
+                makerAssetAmount: new BigNumber(orderWithStringInts.makerAssetAmount),
+                takerAssetAmount: new BigNumber(orderWithStringInts.takerAssetAmount),
+                makerFee: new BigNumber(orderWithStringInts.makerFee),
+                takerFee: new BigNumber(orderWithStringInts.takerFee),
+                expirationTimeSeconds: new BigNumber(orderWithStringInts.expirationTimeSeconds),
+                salt: new BigNumber(orderWithStringInts.salt),
+            };
+        });
+
+        return orders;
+    }
+}