Merge pull request #411 from balancer/tri-hops-with-mid-pool

Tri hops with mid pool

src/routeProposal/index.ts

@@ -14,6 +14,7 @@ import {
  SorConfig,
  PoolDictionary,
 } from '../types';
+import { getTriPaths } from './triPaths';
 
 export class RouteProposer {
  cache: Record<string, { paths: NewPath[] }> = {};
@@ -79,9 +80,17 @@ export class RouteProposer {
  this.config
  );
 
+ const triPaths = getTriPaths(
+ tokenIn,
+ tokenOut,
+ poolsAllDict,
+ this.config.triPathMidPoolIds ?? []
+ );
+
  const combinedPathData = pathData
  .concat(...boostedPaths)
- .concat(...pathsUsingStaBal);
+ .concat(...pathsUsingStaBal)
+ .concat(...triPaths);
  const [paths] = calculatePathLimits(combinedPathData, swapType);
 
  this.cache[`${tokenIn}${tokenOut}${swapType}${swapOptions.timestamp}`] =

src/routeProposal/triPaths.ts

@@ -0,0 +1,164 @@
+import { PoolDictionary, NewPath, PoolBase, PoolPairBase } from '../types';
+import { createPath, getHighestLiquidityPool } from './filtering';
+
+type TokenWithPools = {
+ token: string;
+ mostLiquidPoolIn: PoolBase<PoolPairBase> | null;
+ mostLiquidPoolOut: PoolBase<PoolPairBase> | null;
+};
+
+/**
+ * For each midpool construct 3 hop paths like: tokenIn[poolA]tokenA[MidPool]tokenB[poolB]tokenOut.
+ * tokenA/B are midpool pool tokens.
+ * poolA/B are most liquid pools connecting tokenIn/Out to tokenA/B.
+ * @param tokenIn
+ * @param tokenOut
+ * @param poolsAllDict
+ * @param midPoolsId
+ * @returns
+ */
+export function getTriPaths(
+ tokenIn: string,
+ tokenOut: string,
+ poolsAllDict: PoolDictionary,
+ midPoolsId: string[]
+): NewPath[] {
+ const triPaths: NewPath[] = [];
+ midPoolsId.forEach((midPoolId) => {
+ const midPoolTriPaths = getMidPoolTriPaths(
+ tokenIn,
+ tokenOut,
+ poolsAllDict,
+ midPoolId
+ );
+ triPaths.push(...midPoolTriPaths);
+ });
+ return triPaths;
+}
+
+function getMidPoolTriPaths(
+ tokenIn: string,
+ tokenOut: string,
+ poolsAllDict: PoolDictionary,
+ midPoolId: string
+): NewPath[] {
+ // We only want to use a pool as middle hop if tokenIn/Out aren't it's pool tokens as normal algo should take care of that path.
+ const midPool = getValidPool(tokenIn, tokenOut, poolsAllDict, midPoolId);
+ if (midPool === null) return [];
+ // For each midPool pool token find the most liquid pool connecting tokenIn/Out
+ const tokenPools = getTokenPools(tokenIn, tokenOut, poolsAllDict, midPool);
+ // Construct all possible paths via midPool using most liquid connecting pools
+ return constructPaths(tokenIn, tokenOut, tokenPools, midPool);
+}
+
+/**
+ * Construct all possible paths for tokenIn>tokenOut via midPool using most liquid connecting pools
+ * @param tokenIn
+ * @param tokenOut
+ * @param tokensWithPools
+ * @param midPool
+ * @returns
+ */
+function constructPaths(
+ tokenIn: string,
+ tokenOut: string,
+ tokensWithPools: TokenWithPools[],
+ midPool: PoolBase<PoolPairBase>
+): NewPath[] {
+ const paths: NewPath[] = [];
+ // For each valid mostLiquidPoolIn create a path via midPool and any valid mostLiquidPoolOut
+ tokensWithPools.forEach((tokenWithPoolsIn, i) => {
+ const mostLiquidPoolIn = tokenWithPoolsIn.mostLiquidPoolIn;
+ if (!mostLiquidPoolIn) return;
+ const remainingTokensWithPools = [
+ ...tokensWithPools.slice(0, i),
+ ...tokensWithPools.slice(i + 1),
+ ];
+ remainingTokensWithPools.forEach((tokenWithPoolsOut) => {
+ if (!tokenWithPoolsOut.mostLiquidPoolOut) return;
+ // console.log(
+ // `tokenIn[${mostLiquidPoolIn.id}]${tokenWithPoolsIn.token}[${midPool.id}]${tokenWithPoolsOut.token}[${tokenWithPoolsOut.mostLiquidPoolOut.id}]tokenOut`
+ // );
+ const tokens = [
+ tokenIn,
+ tokenWithPoolsIn.token,
+ tokenWithPoolsOut.token,
+ tokenOut,
+ ];
+ const pools = [
+ mostLiquidPoolIn,
+ midPool,
+ tokenWithPoolsOut.mostLiquidPoolOut,
+ ];
+ paths.push(createPath(tokens, pools));
+ });
+ });
+ return paths;
+}
+
+/**
+ * For each token in pool find the most liquid pool connecting tokenIn/Out
+ * @param tokenIn
+ * @param tokenOut
+ * @param poolsAllDict
+ * @param pool
+ * @returns
+ */
+function getTokenPools(
+ tokenIn: string,
+ tokenOut: string,
+ poolsAllDict: PoolDictionary,
+ pool: PoolBase<PoolPairBase>
+): TokenWithPools[] {
+ const tokenPools: TokenWithPools[] = pool.tokensList.map((token) => {
+ return { token, mostLiquidPoolIn: null, mostLiquidPoolOut: null };
+ });
+
+ tokenPools.forEach((t) => {
+ const mostLiquidInId = getHighestLiquidityPool(
+ tokenIn,
+ t.token,
+ poolsAllDict
+ );
+ const mostLiquidOutId = getHighestLiquidityPool(
+ t.token,
+ tokenOut,
+ poolsAllDict
+ );
+ t.mostLiquidPoolIn = mostLiquidInId
+ ? poolsAllDict[mostLiquidInId]
+ : null;
+ t.mostLiquidPoolOut = mostLiquidOutId
+ ? poolsAllDict[mostLiquidOutId]
+ : null;
+ });
+ return tokenPools;
+}
+
+/**
+ * We only want to use a pool as middle hop if tokenIn/Out aren't it's pool tokens as normal algo should take care of that path.
+ * @param tokenIn
+ * @param tokenOut
+ * @param poolsAllDict
+ * @param poolId
+ * @returns
+ */
+function getValidPool(
+ tokenIn: string,
+ tokenOut: string,
+ poolsAllDict: PoolDictionary,
+ poolId: string
+): PoolBase<PoolPairBase> | null {
+ const pool = poolsAllDict[poolId];
+ if (!pool) return null;
+ if (
+ pool.tokensList.some(
+ (t) =>
+ t.toLowerCase() === tokenIn.toLowerCase() ||
+ t.toLowerCase() === tokenOut.toLowerCase()
+ )
+ ) {
+ return null;
+ }
+ return pool;
+}

src/types.ts

@@ -10,6 +10,7 @@ export interface SorConfig {
  usdcConnectingPool?: { id: string; usdc: string };
  wETHwstETH?: { id: string; address: string };
  lbpRaisingTokens?: string[];
+ triPathMidPoolIds?: string[];
 }
 
 export type NoNullableField<T> = {

test/lib/subgraphPoolDataService.ts

@@ -126,6 +126,7 @@ export const Query: { [chainId: number]: string } = {
  100: queryWithLinear,
  1101: queryWithLinear,
  43114: queryWithLinear,
+ 8453: queryWithLinear,
 };
 
 export class SubgraphPoolDataService implements PoolDataService {

test/testScripts/constants.ts

@@ -10,6 +10,7 @@ export enum Network {
  GNOSIS = 100,
  ZKEVM = 1101,
  AVALANCHE = 43114,
+ BASE = 8453,
 }
 
 export const SOR_CONFIG: Record<Network, SorConfig> = {
@@ -141,6 +142,24 @@ export const SOR_CONFIG: Record<Network, SorConfig> = {
  },
  ],
  },
+ [Network.BASE]: {
+ chainId: Network.BASE,
+ vault: '0xBA12222222228d8Ba445958a75a0704d566BF2C8',
+ weth: '0x4200000000000000000000000000000000000006',
+ connectingTokens: [
+ {
+ symbol: 'WETH',
+ address: '0x4200000000000000000000000000000000000006',
+ },
+ ],
+ staBal3Pool: {
+ id: '0x6fbfcf88db1aada31f34215b2a1df7fafb4883e900000000000000000000000c',
+ address: '0x6FbFcf88DB1aADA31F34215b2a1Df7fafb4883e9',
+ },
+ triPathMidPoolIds: [
+ '0x2db50a0e0310723ef0c2a165cb9a9f80d772ba2f00020000000000000000000d',
+ ],
+ },
 };
 
 export const PROVIDER_URLS = {
@@ -151,6 +170,7 @@ export const PROVIDER_URLS = {
  [Network.GNOSIS]: process.env.RPC_URL_GNOSIS,
  [Network.ZKEVM]: process.env.RPC_URL_ZKEVM,
  [Network.AVALANCHE]: process.env.RPC_URL_AVALANCHE,
+ [Network.BASE]: process.env.RPC_URL_BASE,
 };
 
 export const MULTIADDR: { [chainId: number]: string } = {
@@ -165,6 +185,7 @@ export const MULTIADDR: { [chainId: number]: string } = {
  100: '0xbb6fab6b627947dae0a75808250d8b2652952cb5',
  1101: '0xca11bde05977b3631167028862be2a173976ca11',
  43114: '0xcA11bde05977b3631167028862bE2a173976CA11',
+ 8453: '0xcA11bde05977b3631167028862bE2a173976CA11',
 };
 
 export const SUBGRAPH_URLS = {
@@ -178,6 +199,7 @@ export const SUBGRAPH_URLS = {
  [Network.GNOSIS]: `https://api.thegraph.com/subgraphs/name/balancer-labs/balancer-gnosis-chain-v2`,
  [Network.ZKEVM]: `https://api.studio.thegraph.com/query/24660/balancer-polygon-zk-v2/version/latest`,
  [Network.AVALANCHE]: `https://api.thegraph.com/subgraphs/name/balancer-labs/balancer-avalanche-v2`,
+ [Network.BASE]: `https://api.studio.thegraph.com/query/24660/balancer-base-v2/version/latest`,
 };
 
 // This is the same across networks
@@ -551,10 +573,42 @@ export const ADDRESSES = {
  decimals: 18,
  symbol: 'sAVAX',
  },
+ BPT: {
+ address: '0xA154009870E9B6431305F19b09F9cfD7284d4E7A',
+ decimals: 18,
+ symbol: 'BPT',
+ },
  STETH: {
  address: 'TOD',
  decimals: 6,
  symbol: 'stETH',
  },
  },
+ [Network.BASE]: {
+ STETH: {
+ address: 'TOD0',
+ decimals: 18,
+ symbol: 'stETH',
+ },
+ WETH: {
+ address: '0x4200000000000000000000000000000000000006',
+ decimals: 18,
+ symbol: 'WETH',
+ },
+ USDC: {
+ address: '0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA',
+ decimals: 6,
+ symbol: 'USDC',
+ },
+ DAI: {
+ address: '0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb',
+ decimals: 18,
+ symbol: 'DAI',
+ },
+ BALD: {
+ address: '0x27D2DECb4bFC9C76F0309b8E88dec3a601Fe25a8',
+ decimals: 18,
+ symbol: 'BALD',
+ },
+ },
 };

test/testScripts/swapExample.ts

@@ -58,21 +58,17 @@ function setUp(networkId: Network, provider: JsonRpcProvider): SOR {
 }
 
 export async function swap(): Promise<void> {
- const networkId = Network.AVALANCHE;
+ const networkId = Network.BASE;
  const provider = new JsonRpcProvider(PROVIDER_URLS[networkId]);
  // gasPrice is used by SOR as a factor to determine how many pools to swap against.
  // i.e. higher cost means more costly to trade against lots of different pools.
  const gasPrice = BigNumber.from('14000000000');
  // This determines the max no of pools the SOR will use to swap.
  const maxPools = 4;
- const tokenIn = ADDRESSES[networkId].BETS;
- const tokenOut = ADDRESSES[networkId].WAVAX;
+ const tokenIn = ADDRESSES[networkId].DAI;
+ const tokenOut = ADDRESSES[networkId].BALD;
  const swapType: SwapTypes = SwapTypes.SwapExactIn;
- const swapAmount = parseFixed('1', 18);
- // BETS -> https://snowtrace.io//address/0x94025780a1ab58868d9b2dbbb775f44b32e8e6e5 (18)
- // BETS -> WAVAX https://snowtrace.io//address/0xb31f66aa3c1e785363f0875a1b74e27b85fd66c7 (18)
- // BETS -> USDC ()
- // via sAVAX: https://snowtrace.io//address/0x2b2c81e08f1af8835a78bb2a90ae924ace0ea4be (18)
+ const swapAmount = parseFixed('900', 18);
 
  const sor = setUp(networkId, provider);