feat: use automatic routing

core/src/auctions.ts

@@ -6,6 +6,7 @@ import type {
     TakeEvent,
     MarketData,
     ExchangeFees,
+    Pool,
 } from './types';
 import BigNumber from './bignumber';
 import fetchAuctionsByCollateralType, {
@@ -128,6 +129,9 @@ export const enrichMarketDataRecordsWithValues = async function (
             ...enrichedMarketDataRecords,
             [marketId]: { ...marketData },
         };
+        if (marketData) {
+
+        }
     }
     return enrichedMarketDataRecords;
 };
@@ -335,10 +339,11 @@ export const bidWithCallee = async function (
     auction: Auction,
     marketId: string,
     profitAddress: string,
+    pools?: Pool[],
     notifier?: Notifier
 ): Promise<string> {
     const calleeAddress = getCalleeAddressByCollateralType(network, auction.collateralType, marketId);
-    const calleeData = await getCalleeData(network, auction.collateralType, marketId, profitAddress);
+    const calleeData = await getCalleeData(network, auction.collateralType, marketId, profitAddress, pools);
     const contractName = getClipperNameByCollateralType(auction.collateralType);
     const contractParameters = [
         convertNumberTo32Bytes(auction.index),

core/src/calleeFunctions/CurveLpTokenUniv3Callee.ts

@@ -1,4 +1,4 @@
-import type { CalleeFunctions, CollateralConfig } from '../types';
+import type { CalleeFunctions, CollateralConfig, Pool } from '../types';
 import { ethers } from 'ethers';
 import BigNumber from '../bignumber';
 import { getContractAddressByName, getJoinNameByCollateralType } from '../contracts';
@@ -11,10 +11,12 @@ const getCalleeData = async function (
     network: string,
     collateral: CollateralConfig,
     marketId: string,
-    profitAddress: string
+    profitAddress: string,
+    _pools?: Pool[]
 ): Promise<string> {
     const marketData = collateral.exchanges[marketId];
-    if (marketData?.callee !== 'CurveLpTokenUniv3Callee') {
+    const isAutorouted = 'automaticRouter' in marketData;
+    if (marketData?.callee !== 'CurveLpTokenUniv3Callee' || isAutorouted) {
         throw new Error(`Can not encode route for the "${collateral.ilk}"`);
     }
     const route = await encodeRoute(network, marketData.route);

core/src/calleeFunctions/UniswapV2CalleeDai.ts

@@ -1,4 +1,4 @@
-import type { CalleeFunctions, CollateralConfig } from '../types';
+import type { CalleeFunctions, CollateralConfig, Pool } from '../types';
 import { ethers } from 'ethers';
 import BigNumber from '../bignumber';
 import { getContractAddressByName, getJoinNameByCollateralType } from '../contracts';
@@ -8,7 +8,8 @@ const getCalleeData = async function (
     network: string,
     collateral: CollateralConfig,
     marketId: string,
-    profitAddress: string
+    profitAddress: string,
+    _pools?: Pool[]
 ): Promise<string> {
     const marketData = collateral.exchanges[marketId];
     if (marketData?.callee !== 'UniswapV2CalleeDai') {

core/src/calleeFunctions/UniswapV2LpTokenCalleeDai.ts

@@ -1,4 +1,4 @@
-import type { CalleeFunctions, CollateralConfig } from '../types';
+import type { CalleeFunctions, CollateralConfig, Pool } from '../types';
 import { ethers } from 'ethers';
 import BigNumber from '../bignumber';
 import { getContractAddressByName, getJoinNameByCollateralType } from '../contracts';
@@ -14,7 +14,8 @@ const getCalleeData = async function (
     network: string,
     collateral: CollateralConfig,
     marketId: string,
-    profitAddress: string
+    profitAddress: string,
+    _pools?: Pool[]
 ): Promise<string> {
     const marketData = collateral.exchanges[marketId];
     if (marketData?.callee !== 'UniswapV2LpTokenCalleeDai') {

core/src/calleeFunctions/UniswapV3Callee.ts

@@ -1,22 +1,27 @@
-import type { CalleeFunctions, CollateralConfig } from '../types';
+import type { CalleeFunctions, CollateralConfig, Pool } from '../types';
 import { ethers } from 'ethers';
 import BigNumber from '../bignumber';
 import { getContractAddressByName, getJoinNameByCollateralType } from '../contracts';
-import { convertCollateralToDaiUsingRoute, encodeRoute } from './helpers/uniswapV3';
+import { convertCollateralToDaiUsingRoute, encodePools } from './helpers/uniswapV3';
 
 const getCalleeData = async function (
     network: string,
     collateral: CollateralConfig,
     marketId: string,
-    profitAddress: string
+    profitAddress: string,
+    pools?: Pool[]
 ): Promise<string> {
     const marketData = collateral.exchanges[marketId];
     if (marketData?.callee !== 'UniswapV3Callee') {
         throw new Error(`getCalleeData called with invalid collateral type "${collateral.ilk}"`);
     }
+    if (!pools) {
+        throw new Error(`getCalleeData called with invalid pools`);
+    }
     const joinAdapterAddress = await getContractAddressByName(network, getJoinNameByCollateralType(collateral.ilk));
     const minProfit = 1;
-    const uniswapV3route = await encodeRoute(network, [collateral.symbol, ...marketData.route]);
+    const uniswapV3route = await encodePools(pools);
+    console.log('uniswapV3route', uniswapV3route);
     const typesArray = ['address', 'address', 'uint256', 'bytes', 'address'];
     return ethers.utils.defaultAbiCoder.encode(typesArray, [
         profitAddress,

core/src/calleeFunctions/WstETHCurveUniv3Callee.ts

@@ -1,4 +1,4 @@
-import type { CalleeFunctions, CollateralConfig } from '../types';
+import type { CalleeFunctions, CollateralConfig, Pool } from '../types';
 import { ethers } from 'ethers';
 import BigNumber from '../bignumber';
 import { getContractAddressByName, getJoinNameByCollateralType } from '../contracts';
@@ -10,7 +10,8 @@ const getCalleeData = async function (
     network: string,
     collateral: CollateralConfig,
     _marketId: string,
-    profitAddress: string
+    profitAddress: string,
+    _pools?: Pool[]
 ): Promise<string> {
     const joinAdapterAddress = await getContractAddressByName(network, getJoinNameByCollateralType(collateral.ilk));
     const minProfit = 1;

core/src/calleeFunctions/helpers/pools.ts

@@ -0,0 +1,20 @@
+import { getTokenAddressByNetworkAndSymbol } from "../../tokens";
+import { Pool } from "../../types";
+
+const getRouteSteps = (route: string[]) => {
+    const routeSteps = [];
+    for (let i = 0; i < route.length - 1; i++) {
+        routeSteps.push([route[i], route[i + 1]]);
+    }
+    return routeSteps;
+};
+
+export const routeToPool = async (network: string, route: string[], fee: number): Promise<Pool[]> => {
+    const routeSteps = getRouteSteps(route);
+    return await Promise.all(
+        routeSteps.map(async step => ({
+            addresses: await Promise.all(step.map(symbol => getTokenAddressByNetworkAndSymbol(network, symbol))),
+            fee,
+        }))
+    );
+};

core/src/calleeFunctions/helpers/uniswapAutoRouter.ts

@@ -57,17 +57,25 @@ export const fetchAutoRouteInformation = async function (
     try {
         const token = await getUniswapTokenBySymbol(network, collateralSymbol);
         const autoRouteData = await getUniswapAutoRoute(network, collateralSymbol, inputAmount, walletAddress);
-        const routes = autoRouteData.route[0].tokenPath.map(p => p.symbol);
+        const route = autoRouteData.route[0].tokenPath.map(p => {
+            if (!p.symbol) {
+                throw new Error(`Could not get symbol for token "${p.address}".`);
+            }
+            return p.symbol;
+        });
+        const quote = new BigNumber(autoRouteData.quote.toFixed());
 
         return {
             totalPrice: new BigNumber(autoRouteData.quote.toFixed(token.decimals)),
-            routes,
+            route,
+            quote,
             errorMessage: undefined,
         };
     } catch (error: any) {
         return {
             totalPrice: undefined,
-            routes: undefined,
+            route: undefined,
+            quote: undefined,
             errorMessage: error.toString(),
         };
     }

core/src/calleeFunctions/helpers/uniswapV2.ts

@@ -19,7 +19,10 @@ const EXCHANGE_RATE_CACHE = 20 * 1000;
 
 const getCalleeConfig = function (collateral: CollateralConfig, marketId: string): RegularCalleeConfig {
     const marketData = collateral.exchanges[marketId];
-    if (marketData?.callee === 'UniswapV2CalleeDai' || marketData?.callee === 'UniswapV3Callee') {
+    const isUniswapTokenNonAutoRouted =
+        (marketData?.callee === 'UniswapV2CalleeDai' || marketData?.callee === 'UniswapV3Callee') &&
+        !('automaticRouter' in marketData);
+    if (isUniswapTokenNonAutoRouted) {
         return marketData;
     }
     throw new Error(`"${collateral.symbol}" is not an UniSwap token`);

core/src/calleeFunctions/helpers/uniswapV3.ts

@@ -6,6 +6,7 @@ import { getContractAddressByName } from '../../contracts';
 import { DAI_NUMBER_OF_DIGITS, MKR_NUMBER_OF_DIGITS } from '../../constants/UNITS';
 import { getCollateralConfigBySymbol } from '../../constants/COLLATERALS';
 import { getTokenAddressByNetworkAndSymbol } from '../../tokens';
+import { Pool } from '../../types';
 
 const UNISWAP_V3_QUOTER_ADDRESS = '0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6';
 export const UNISWAP_FEE = 3000; // denominated in hundredths of a bip
@@ -15,6 +16,23 @@ const getUniswapV3quoterContract = async function (network: string): Promise<eth
     return new ethers.Contract(UNISWAP_V3_QUOTER_ADDRESS, UNISWAP_V3_QUOTER_ABI, provider);
 };
 
+export const encodePools = async function (pools: Pool[]): Promise<string> {
+    const types = [] as string[];
+    const values = [] as Array<string | number>;
+
+    types.push('address');
+    values.push(pools[0].addresses[0]);
+    for (const pool of pools) {
+        types.push('address');
+        values.push(pool.addresses[1]);
+
+        types.push('uint24');
+        values.push(pool.fee);
+    }
+
+    return ethers.utils.solidityPack(types, values);
+};
+
 export const encodeRoute = async function (network: string, collateralSymbols: string[]): Promise<string> {
     const types = [] as string[];
     const values = [] as Array<string | number>;
@@ -40,7 +58,8 @@ export const convertCollateralToDaiUsingRoute = async function (
 ): Promise<BigNumber> {
     const collateral = getCollateralConfigBySymbol(collateralSymbol);
     const marketData = collateral.exchanges[marketId];
-    if (marketData?.callee !== 'UniswapV3Callee') {
+    const isAutorouted = 'automaticRouter' in marketData;
+    if (marketData?.callee !== 'UniswapV3Callee' || isAutorouted) {
         throw new Error(`getCalleeData called with invalid collateral type "${collateral.ilk}"`);
     }
     const collateralIntegerAmount = collateralAmount.shiftedBy(collateral.decimals).toFixed(0);

core/src/calleeFunctions/index.ts

@@ -1,4 +1,4 @@
-import type { CalleeNames, CalleeFunctions, MarketData, CollateralConfig } from '../types';
+import type { CalleeNames, CalleeFunctions, MarketData, CollateralConfig, CollateralSymbol, CalleeConfig, Pool, MarketDataUniswapV2LpToken, MarketDataRegular, MarketDataUniswapV3Automatic } from '../types';
 import memoizee from 'memoizee';
 import BigNumber from '../bignumber';
 import UniswapV2CalleeDai from './UniswapV2CalleeDai';
@@ -8,6 +8,9 @@ import CurveLpTokenUniv3Callee from './CurveLpTokenUniv3Callee';
 import UniswapV3Callee from './UniswapV3Callee';
 import rETHCurveUniv3Callee from './rETHCurveUniv3Callee';
 import { getCollateralConfigByType, getCollateralConfigBySymbol } from '../constants/COLLATERALS';
+import { routeToPool } from './helpers/pools';
+import { fetchAutoRouteInformation } from './helpers/uniswapAutoRouter';
+import { UNISWAP_FEE } from './helpers/uniswapV3';
 
 const MARKET_PRICE_CACHE_MS = 10 * 1000;
 
@@ -24,15 +27,44 @@ export const getCalleeData = async function (
     network: string,
     collateralType: string,
     marketId: string,
-    profitAddress: string
+    profitAddress: string,
+    pools?: Pool[]
 ): Promise<string> {
     const collateral = getCollateralConfigByType(collateralType);
     const marketData = collateral.exchanges[marketId];
     if (!marketData || !marketData.callee || !allCalleeFunctions[marketData.callee]) {
         throw new Error(`Unsupported collateral type "${collateralType}"`);
     }
-    return await allCalleeFunctions[marketData.callee].getCalleeData(network, collateral, marketId, profitAddress);
+    return await allCalleeFunctions[marketData.callee].getCalleeData(network, collateral, marketId, profitAddress, pools);
 };
+const getCalleeAutoRoute = async (
+    network: string,
+    collateral: CollateralConfig,
+    marketId: string,
+    amount: BigNumber = new BigNumber('1')
+): Promise<string[] | undefined> => {
+    const calleeConfig = collateral.exchanges[marketId];
+    if (!('automaticRouter' in calleeConfig)) {
+        return undefined;
+    }
+    return (await fetchAutoRouteInformation(network, collateral.symbol, amount.toFixed())).route || [];
+}
+
+const getMarketDataWithoutPrice = (calleeConfig: CalleeConfig, route: string[] | undefined, pools: Pool[] | undefined) => {
+    if (!route && calleeConfig.callee === 'UniswapV2LpTokenCalleeDai') {
+        const uniswapV2LpMarketData: Omit<MarketDataUniswapV2LpToken, 'marketUnitPrice'> = calleeConfig;
+        return uniswapV2LpMarketData;
+    }
+    if ('route' in calleeConfig && pools) {
+        const regularMarketData: Omit<MarketDataRegular, 'marketUnitPrice'> = {...calleeConfig, pools};
+        return regularMarketData;
+    }
+    if ('automaticRouter' in calleeConfig && route && pools) {
+        const autorouterMarketData: Omit<MarketDataUniswapV3Automatic, 'marketUnitPrice'> = {...calleeConfig, route, pools};
+        return autorouterMarketData;
+    }
+    throw new Error('Unexpected market data parameters. Failed to determine the callee type.');
+}
 
 export const getMarketDataById = async function (
     network: string,
@@ -44,6 +76,10 @@ export const getMarketDataById = async function (
     if (!allCalleeFunctions[calleeConfig?.callee]) {
         throw new Error(`Unsupported callee "${calleeConfig?.callee}" for collateral symbol "${collateral.symbol}"`);
     }
+
+    const route = 'route' in calleeConfig ? calleeConfig.route : await getCalleeAutoRoute(network, collateral, marketId, amount);
+    const pools = route ? await routeToPool(network, route, UNISWAP_FEE) : undefined;
+
     let marketUnitPrice: BigNumber;
     try {
         marketUnitPrice = await allCalleeFunctions[calleeConfig.callee].getMarketPrice(
@@ -56,20 +92,20 @@ export const getMarketDataById = async function (
         const errorMessage = error?.message;
         marketUnitPrice = new BigNumber(NaN);
         return {
-            ...calleeConfig,
+            ...getMarketDataWithoutPrice(calleeConfig, route, pools),
             marketUnitPrice,
             errorMessage,
         };
     }
     return {
-        ...calleeConfig,
+        ...getMarketDataWithoutPrice(calleeConfig, route, pools),
         marketUnitPrice: marketUnitPrice ? marketUnitPrice : new BigNumber(NaN),
     };
 };
 
 export const getMarketDataRecords = async function (
     network: string,
-    collateralSymbol: string,
+    collateralSymbol: CollateralSymbol,
     amount: BigNumber = new BigNumber('1')
 ): Promise<Record<string, MarketData>> {
     const collateral = getCollateralConfigBySymbol(collateralSymbol);
@@ -83,6 +119,7 @@ export const getMarketDataRecords = async function (
                 errorMessage: error?.message,
                 marketUnitPrice: new BigNumber(NaN),
                 route: [], // dummy value: MarketData requires either a route or tokens
+                pools: [],
             };
         }
         marketDataRecords = {
@@ -118,6 +155,7 @@ const _getMarketPrice = async function (
     collateralSymbol: string,
     amount: BigNumber = new BigNumber('1')
 ): Promise<BigNumber> {
+    // get collateral config and if exchanges contains automaticRouter, use that
     const marketDataRecords = await getMarketDataRecords(network, collateralSymbol, amount);
     const bestMarketId = await getBestMarketId(marketDataRecords);
     return marketDataRecords[bestMarketId].marketUnitPrice;

core/src/calleeFunctions/rETHCurveUniv3Callee.ts

@@ -1,5 +1,5 @@
 import { ethers } from 'ethers';
-import type { CalleeFunctions, CollateralConfig } from '../types';
+import type { CalleeFunctions, CollateralConfig, Pool } from '../types';
 import BigNumber from '../bignumber';
 import { getContractAddressByName, getJoinNameByCollateralType } from '../contracts';
 import { encodeRoute, convertCollateralToDai } from './helpers/uniswapV3';
@@ -12,13 +12,15 @@ const getCalleeData = async function (
     network: string,
     collateral: CollateralConfig,
     marketId: string,
-    profitAddress: string
+    profitAddress: string,
+    _pools?: Pool[]
 ): Promise<string> {
-    const marketData = collateral.exchanges[marketId];
-    if (marketData?.callee !== 'rETHCurveUniv3Callee') {
+    const calleeConfig = collateral.exchanges[marketId];
+    const isAutorouted = 'automaticRouter' in calleeConfig;
+    if (calleeConfig?.callee !== 'rETHCurveUniv3Callee' || isAutorouted) {
         throw new Error(`Can not encode route for the "${collateral.ilk}"`);
     }
-    const route = await encodeRoute(network, marketData.route);
+    const route = await encodeRoute(network, calleeConfig.route);
     const joinAdapterAddress = await getContractAddressByName(network, getJoinNameByCollateralType(collateral.ilk));
     const minProfit = 1;
     const typesArray = ['address', 'address', 'uint256', 'bytes', 'address'];