@paraswap/dex-lib 4.0.0 → 4.0.1-balancer-v3-cables.0

package/src/dex/balancer-v3/balancer-v3.ts

@@ -0,0 +1,538 @@
+import { AsyncOrSync, DeepReadonly } from 'ts-essentials';
+import {
+  Token,
+  Address,
+  ExchangePrices,
+  PoolPrices,
+  AdapterExchangeParam,
+  PoolLiquidity,
+  Logger,
+  DexExchangeParam,
+} from '../../types';
+import { SwapSide, Network } from '../../constants';
+import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
+import { getBigIntPow, getDexKeysWithNetwork, isETHAddress } from '../../utils';
+import { IDex } from '../../dex/idex';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { BalancerV3Data, PoolState, PoolStateMap } from './types';
+import { SimpleExchange } from '../simple-exchange';
+import { BalancerV3Config } from './config';
+import { BalancerV3EventPool } from './balancer-v3-pool';
+import { NumberAsString } from '@paraswap/core';
+import { SwapKind } from '@balancer-labs/balancer-maths';
+import { Interface } from '@ethersproject/abi';
+import { extractReturnAmountPosition } from '../../executor/utils';
+import { getTopPoolsApi } from './getTopPoolsApi';
+import balancerRouterAbi from '../../abi/balancer-v3/router.json';
+import balancerBatchRouterAbi from '../../abi/balancer-v3/batch-router.json';
+import { getGasCost } from './getGasCost';
+
+const MAX_UINT256 =
+  '115792089237316195423570985008687907853269984665640564039457584007913129639935';
+const POOL_UPDATE_TTL = 5 * 60; // 5mins
+const RATE_UPDATE_TTL = 1 * 60; // 1min
+
+type DeepMutable<T> = {
+  -readonly [P in keyof T]: T[P] extends object ? DeepMutable<T[P]> : T[P];
+};
+
+export class BalancerV3 extends SimpleExchange implements IDex<BalancerV3Data> {
+  protected eventPools: BalancerV3EventPool;
+
+  readonly hasConstantPriceLargeAmounts = false;
+  // Vault can handle native
+  readonly needWrapNative = false;
+
+  readonly isFeeOnTransferSupported = false;
+
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(BalancerV3Config);
+
+  logger: Logger;
+  balancerRouter: Interface;
+  balancerBatchRouter: Interface;
+  updateNewPoolsTimer?: NodeJS.Timeout;
+  updateRatesTimer?: NodeJS.Timeout;
+
+  constructor(
+    readonly network: Network,
+    readonly dexKey: string,
+    readonly dexHelper: IDexHelper,
+  ) {
+    super(dexHelper, dexKey);
+    this.logger = dexHelper.getLogger(dexKey);
+    this.eventPools = new BalancerV3EventPool(
+      dexKey,
+      network,
+      dexHelper,
+      this.logger,
+    );
+    this.balancerRouter = new Interface(balancerRouterAbi);
+    this.balancerBatchRouter = new Interface(balancerBatchRouterAbi);
+  }
+
+  // Initialize pricing is called once in the start of
+  // pricing service. It is intended to setup the integration
+  // for pricing requests. It is optional for a DEX to
+  // implement this function
+  async initializePricing(blockNumber: number) {
+    await this.eventPools.initialize(blockNumber);
+
+    // This will periodically query API and add any new pools to pool state
+    if (!this.updateNewPoolsTimer) {
+      this.updateNewPoolsTimer = setInterval(async () => {
+        try {
+          await this.updatePoolState();
+        } catch (e) {
+          this.logger.error(`${this.dexKey}: Failed to update pool state:`, e);
+        }
+      }, POOL_UPDATE_TTL * 1000);
+    }
+
+    // This will periodically refresh tokenRates with onchain state
+    if (!this.updateRatesTimer) {
+      this.updateRatesTimer = setInterval(async () => {
+        try {
+          await this.updateStatePoolRates();
+        } catch (e) {
+          this.logger.error(`${this.dexKey}: Failed to update pool rates:`, e);
+        }
+      }, RATE_UPDATE_TTL * 1000);
+    }
+  }
+
+  getAdapters(side: SwapSide): null {
+    return null;
+  }
+
+  // Returns list of pool identifiers that can be used
+  // for a given swap. poolIdentifiers must be unique
+  // across DEXes. It is recommended to use
+  // ${dexKey}_${poolAddress} as a poolIdentifier
+  async getPoolIdentifiers(
+    srcToken: Token,
+    destToken: Token,
+    side: SwapSide,
+    blockNumber: number,
+  ): Promise<string[]> {
+    const _from = this.dexHelper.config.wrapETH(srcToken);
+    const _to = this.dexHelper.config.wrapETH(destToken);
+    const poolState = this.eventPools.getState(blockNumber);
+    if (poolState === null) return [];
+    return this.findPoolAddressesWithTokens(
+      poolState,
+      _from.address.toLowerCase(),
+      _to.address.toLowerCase(),
+    );
+  }
+
+  findPoolAddressesWithTokens(
+    pools: DeepReadonly<PoolStateMap>,
+    tokenA: string,
+    tokenB: string,
+  ): string[] {
+    return Object.entries(pools)
+      .filter(([, poolState]) => {
+        return this.hasTokens(poolState, [tokenA, tokenB]);
+      })
+      .map(([address]) => address);
+  }
+
+  /**
+   * Filter pools that have tokens from/to and are in limitPool list
+   * @param pools
+   * @param from
+   * @param to
+   * @param limitPools
+   * @returns Array of PoolState
+   */
+  filterPools(
+    pools: DeepReadonly<PoolStateMap>,
+    from: string,
+    to: string,
+    limitPools?: string[],
+  ): PoolState[] {
+    return Object.entries(pools)
+      .filter(([address, poolState]) => {
+        const hasRequiredTokens = this.hasTokens(poolState, [from, to]);
+        const isAllowedPool = !limitPools || limitPools.includes(address);
+        return hasRequiredTokens && isAllowedPool;
+      })
+      .map(([_, poolState]) => poolState as DeepMutable<typeof poolState>);
+  }
+
+  hasTokens(pool: DeepReadonly<PoolState>, tokens: string[]): boolean {
+    return tokens.every(
+      token =>
+        pool.tokens.includes(token) || pool.tokensUnderlying.includes(token),
+    );
+  }
+
+  // Returns pool prices for amounts.
+  // If limitPools is defined only pools in limitPools
+  // should be used. If limitPools is undefined then
+  // any pools can be used.
+  async getPricesVolume(
+    srcToken: Token,
+    destToken: Token,
+    amounts: bigint[],
+    side: SwapSide,
+    blockNumber: number,
+    limitPools?: string[],
+  ): Promise<null | ExchangePrices<BalancerV3Data>> {
+    try {
+      const _from = this.dexHelper.config.wrapETH(srcToken);
+      const _to = this.dexHelper.config.wrapETH(destToken);
+      if (_from.address === _to.address) {
+        return null;
+      }
+
+      // This is used to get block timestamp which is needed to calculate Amp if it is updating
+      const block = await this.dexHelper.provider.getBlock(blockNumber);
+
+      // get up to date pools and state
+      const allPoolState = this.eventPools.getState(blockNumber);
+      if (allPoolState === null) {
+        this.logger.error(`getState returned null`);
+        return null;
+      }
+
+      // filter for pools with tokens and to only use limit pools
+      const allowedPools = this.filterPools(
+        allPoolState,
+        _from.address.toLowerCase(),
+        _to.address.toLowerCase(),
+        limitPools,
+      );
+
+      if (!allowedPools.length) return null;
+
+      const swapKind =
+        side === SwapSide.SELL ? SwapKind.GivenIn : SwapKind.GivenOut;
+      const tokenIn = _from.address;
+      const tokenOut = _to.address;
+
+      // Gets the single unit amount based off token decimals, e.g. for USDC its 1e6
+      const unitAmount = getBigIntPow(
+        (side === SwapSide.SELL ? _from : _to).decimals,
+      );
+
+      const poolPrices: ExchangePrices<BalancerV3Data> = [];
+      // For each pool we calculate swap result using balancer maths
+      for (let i = 0; i < allowedPools.length; i++) {
+        const pool = {
+          ...allowedPools[i],
+        };
+
+        const tokenInInfo = this.eventPools.getTokenInfo(pool, tokenIn);
+        const tokenOutInfo = this.eventPools.getTokenInfo(pool, tokenOut);
+        if (!tokenInInfo || !tokenOutInfo) {
+          continue;
+        }
+
+        const steps = this.eventPools.getSteps(pool, tokenInInfo, tokenOutInfo);
+
+        try {
+          // This is the max amount the pool can swap
+          const maxSwapAmount = this.eventPools.getMaxSwapAmount(
+            pool,
+            tokenInInfo,
+            tokenOutInfo,
+            swapKind,
+          );
+
+          let unit = 0n;
+          if (unitAmount < maxSwapAmount)
+            unit = this.eventPools.getSwapResult(
+              steps,
+              unitAmount,
+              swapKind,
+              block.timestamp,
+            );
+
+          const poolExchangePrice: PoolPrices<BalancerV3Data> = {
+            prices: new Array(amounts.length).fill(0n),
+            unit,
+            data: {
+              steps: steps,
+            },
+            exchange: this.dexKey,
+            gasCost: getGasCost(steps),
+            poolAddresses: [pool.poolAddress],
+            poolIdentifier: `${this.dexKey}_${pool.poolAddress}`,
+          };
+
+          for (let j = 0; j < amounts.length; j++) {
+            if (amounts[j] < maxSwapAmount) {
+              // Uses balancer maths to calculate swap
+              poolExchangePrice.prices[j] = this.eventPools.getSwapResult(
+                steps,
+                amounts[j],
+                swapKind,
+                block.timestamp,
+              );
+            }
+          }
+          poolPrices.push(poolExchangePrice);
+        } catch (err) {
+          this.logger.error(
+            `error fetching prices for pool: ${pool.poolAddress}`,
+          );
+          this.logger.error(err);
+        }
+      }
+
+      return poolPrices;
+    } catch (err) {}
+    return null;
+  }
+
+  // Returns estimated gas cost of calldata for this DEX in multiSwap
+  getCalldataGasCost(
+    poolPrices: PoolPrices<BalancerV3Data>,
+  ): number | number[] {
+    // TODO: update if there is any payload in getAdapterParam
+    return CALLDATA_GAS_COST.DEX_NO_PAYLOAD;
+  }
+
+  // Not used for V6
+  getAdapterParam(): AdapterExchangeParam {
+    return {
+      targetExchange: '0x',
+      payload: '0x',
+      networkFee: '0',
+    };
+  }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: BalancerV3Data,
+    side: SwapSide,
+  ): DexExchangeParam {
+    if (side === SwapSide.SELL) {
+      return this.getExactInParam(srcToken, destToken, srcAmount, data);
+    } else {
+      return this.getExactOutParam(
+        srcToken,
+        destToken,
+        srcAmount,
+        destAmount,
+        data,
+      );
+    }
+  }
+
+  getExactInParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    data: BalancerV3Data,
+  ): DexExchangeParam {
+    if (data.steps.length === 1) {
+      const exchangeData = this.balancerRouter.encodeFunctionData(
+        'swapSingleTokenExactIn',
+        [
+          data.steps[0].pool,
+          this.dexHelper.config.wrapETH(srcToken),
+          this.dexHelper.config.wrapETH(destToken),
+          srcAmount,
+          '0', // This should be limit for min amount out. Assume this is set elsewhere via Paraswap contract.
+          MAX_UINT256, // Deadline
+          isETHAddress(srcToken) || isETHAddress(destToken),
+          '0x',
+        ],
+      );
+      return {
+        permit2Approval: true,
+        needWrapNative: this.needWrapNative,
+        dexFuncHasRecipient: false,
+        exchangeData,
+        // This router handles single swaps
+        targetExchange:
+          BalancerV3Config.BalancerV3[this.network].balancerRouterAddress,
+        returnAmountPos: extractReturnAmountPosition(
+          this.balancerRouter,
+          'swapSingleTokenExactIn',
+        ),
+      };
+    } else {
+      // for each step:
+      // if tokenIn == pool router uses removeLiquidity SINGLE_TOKEN_EXACT_IN
+      // if tokenOut == pool router uses addLiquidity UNBALANCED
+      const exchangeData = this.balancerBatchRouter.encodeFunctionData(
+        'swapExactIn',
+        [
+          [
+            {
+              tokenIn: srcToken,
+              steps: data.steps.map(step => ({
+                pool: step.pool,
+                tokenOut: step.swapInput.tokenOut,
+                isBuffer: step.isBuffer,
+              })),
+              exactAmountIn: srcAmount,
+              minAmountOut: '0', // This should be limit for min amount out. Assume this is set elsewhere via Paraswap contract.
+            },
+          ],
+          MAX_UINT256, // Deadline
+          isETHAddress(srcToken) || isETHAddress(destToken),
+          '0x',
+        ],
+      );
+
+      return {
+        permit2Approval: true,
+        needWrapNative: this.needWrapNative,
+        dexFuncHasRecipient: false,
+        exchangeData,
+        // This router handles batch swaps
+        targetExchange:
+          BalancerV3Config.BalancerV3[this.network].balancerBatchRouterAddress,
+        returnAmountPos: undefined,
+      };
+    }
+  }
+
+  getExactOutParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    data: BalancerV3Data,
+  ): DexExchangeParam {
+    if (data.steps.length === 1) {
+      const exchangeData = this.balancerRouter.encodeFunctionData(
+        'swapSingleTokenExactOut',
+        [
+          data.steps[0].pool,
+          this.dexHelper.config.wrapETH(srcToken),
+          this.dexHelper.config.wrapETH(destToken),
+          destAmount,
+          MAX_UINT256, // This should be limit for max amount in. Assume this is set elsewhere via Paraswap contract.
+          MAX_UINT256, // Deadline
+          isETHAddress(srcToken) || isETHAddress(destToken),
+          '0x',
+        ],
+      );
+
+      return {
+        permit2Approval: true,
+        needWrapNative: this.needWrapNative,
+        dexFuncHasRecipient: false,
+        exchangeData,
+        // Single swaps are submitted via Balancer Router
+        targetExchange:
+          BalancerV3Config.BalancerV3[this.network].balancerRouterAddress,
+        returnAmountPos: undefined,
+      };
+    } else {
+      // for each step:
+      // if tokenIn == pool use removeLiquidity SINGLE_TOKEN_EXACT_OUT
+      // if tokenOut == pool use addLiquidity SINGLE_TOKEN_EXACT_OUT
+      const exchangeData = this.balancerBatchRouter.encodeFunctionData(
+        'swapExactOut',
+        [
+          [
+            {
+              tokenIn: srcToken,
+              steps: data.steps.map(step => ({
+                pool: step.pool,
+                tokenOut: step.swapInput.tokenOut,
+                isBuffer: step.isBuffer,
+              })),
+              exactAmountOut: destAmount,
+              maxAmountIn: srcAmount,
+            },
+          ],
+          MAX_UINT256, // Deadline
+          isETHAddress(srcToken) || isETHAddress(destToken),
+          '0x',
+        ],
+      );
+
+      return {
+        permit2Approval: true,
+        needWrapNative: this.needWrapNative,
+        dexFuncHasRecipient: false,
+        exchangeData,
+        // This router handles batch swaps
+        targetExchange:
+          BalancerV3Config.BalancerV3[this.network].balancerBatchRouterAddress,
+        returnAmountPos: undefined,
+      };
+    }
+  }
+
+  /**
+   * Uses multicall to get onchain token rate for each pool then updates pool state
+   */
+  async updateStatePoolRates(): Promise<void> {
+    await this.eventPools.updateStatePoolRates();
+  }
+
+  // This is called once before getTopPoolsForToken is
+  // called for multiple tokens. This can be helpful to
+  // update common state required for calculating
+  // getTopPoolsForToken. It is optional for a DEX
+  // to implement this
+  async updatePoolState(): Promise<void> {
+    await this.eventPools.updateStatePools();
+  }
+
+  // Returns list of top pools based on liquidity. Max
+  // limit number pools should be returned.
+  async getTopPoolsForToken(
+    tokenAddress: Address,
+    count: number,
+  ): Promise<PoolLiquidity[]> {
+    const poolsWithToken = Object.entries(this.eventPools.getStaleState() || {})
+      .filter(([, poolState]) => {
+        return this.hasTokens(poolState, [tokenAddress.toLowerCase()]);
+      })
+      .map(([address]) => address);
+
+    const topPools = await getTopPoolsApi(this.network, poolsWithToken, count);
+
+    return topPools.map(pool => {
+      const tokens = pool.poolTokens
+        .filter(t => t.address !== tokenAddress)
+        .map(t => ({
+          address: t.address,
+          decimals: t.decimals,
+        }));
+
+      const underlyingTokens = pool.poolTokens
+        .map(t => t.underlyingToken)
+        .filter(t => !!t)
+        .filter(t => t?.address !== tokenAddress) as Token[];
+
+      return {
+        exchange: this.dexKey,
+        address: pool.address,
+        liquidityUSD: parseFloat(pool.dynamicData.totalLiquidity),
+        connectorTokens: tokens.concat(underlyingTokens),
+      };
+    });
+  }
+
+  releaseResources(): AsyncOrSync<void> {
+    if (this.updateNewPoolsTimer) {
+      clearInterval(this.updateNewPoolsTimer);
+      this.updateNewPoolsTimer = undefined;
+      this.logger.info(
+        `${this.dexKey}: cleared updateNewPoolsTimer before shutting down`,
+      );
+    }
+    if (this.updateRatesTimer) {
+      clearInterval(this.updateRatesTimer);
+      this.updateRatesTimer = undefined;
+      this.logger.info(
+        `${this.dexKey}: cleared updateRatesTimer before shutting down`,
+      );
+    }
+  }
+}

package/src/dex/balancer-v3/config.ts

@@ -0,0 +1,46 @@
+import { DexParams } from './types';
+import { DexConfigMap, AdapterMappings } from '../../types';
+import { Network, SwapSide } from '../../constants';
+
+// These map to the Balancer API poolType. Only Balancer supported pools will be added
+export enum SUPPORTED_POOLS {
+  WEIGHTED = 'WEIGHTED',
+  STABLE = 'STABLE',
+}
+
+export const disabledPoolIds: Record<string, Record<number, string[]>> = {
+  BalancerV3: {
+    [Network.GNOSIS]: [
+      // pools with rate provider that returns nested rate instead of wrap/unwrap rate
+      '0x6e6bb18449fcf15b79efa2cfa70acf7593088029',
+      '0x272d6be442e30d7c87390edeb9b96f1e84cecd8d',
+    ],
+  },
+};
+
+// Balancer API - aggregatorSpecific query serves all useful static pool data
+export const apiUrl = 'https://test-api-v3.balancer.fi/';
+
+// TODO Full config added after V3 release
+export const BalancerV3Config: DexConfigMap<DexParams> = {
+  BalancerV3: {
+    [Network.SEPOLIA]: {
+      vaultAddress: '0xbA1333333333a1BA1108E8412f11850A5C319bA9',
+      apiNetworkName: 'SEPOLIA',
+      balancerRouterAddress: '0x0BF61f706105EA44694f2e92986bD01C39930280',
+      balancerBatchRouterAddress: '0xC85b652685567C1B074e8c0D4389f83a2E458b1C',
+    },
+    [Network.GNOSIS]: {
+      vaultAddress: '0xbA1333333333a1BA1108E8412f11850A5C319bA9',
+      apiNetworkName: 'GNOSIS',
+      balancerRouterAddress: '0x84813aA3e079A665C0B80F944427eE83cBA63617',
+      balancerBatchRouterAddress: '0xe2fa4e1d17725e72dcdAfe943Ecf45dF4B9E285b',
+    },
+    [Network.MAINNET]: {
+      vaultAddress: '0xbA1333333333a1BA1108E8412f11850A5C319bA9',
+      apiNetworkName: 'MAINNET',
+      balancerRouterAddress: '0x5C6fb490BDFD3246EB0bB062c168DeCAF4bD9FDd',
+      balancerBatchRouterAddress: '0x136f1EFcC3f8f88516B9E94110D56FDBfB1778d1',
+    },
+  },
+};

package/src/dex/balancer-v3/getGasCost.ts

@@ -0,0 +1,37 @@
+import { STABLE_GAS_COST } from './stablePool';
+import { Step } from './types';
+import { WEIGHTED_GAS_COST } from './weightedPool';
+
+// https://sepolia.etherscan.io/tx/0x8c2c5ec7fc2855ed2ffab3467ee434f4e374e0ecf791e8d2b93c8d74e3f5b1fe
+// 0x7ec61d6dcf0ea412327c30f013e60578c0ff4d83c334a95fb3a68739860e6f59
+// 0xb45331fe60091bdf4ba4c201b7fdfefc1ca8087fa1b6bc28877ef84d167809f4
+const FULL_BOOSTED_SWAP_GAS_COST = 283070;
+// 0xb47bcae19ba4693d18f2148073d0d469ff59223e90d6f75eb25e06b0063f1556
+// 0x4730b0c1dce820f14747698446865364b98d96d3ed926e8e74bbead6482b8f8b
+const PARTIAL_BOOSTED_SWAP_GAS_COST = 259815;
+// 0xef9037f992645a9ecf26ddbdf65690a71acbffce2cc68445c869bb9707cb706a
+// 0x77aa06350df079a077147f1051b10e0612542eb3aff3ae1b3d4004341cb64690
+const BUFFER_WRAP_UNWRAP_GAS_COST = 155921;
+
+export function getGasCost(steps: Step[]): number {
+  if (steps.length === 2) {
+    // Partial boosted/buffer swap:
+    // token[wrap]wrappedToken[swap]wrappedToken or
+    // wrappedToken[swap]wrappedToken[unwrap]token
+    return PARTIAL_BOOSTED_SWAP_GAS_COST;
+  } else if (steps.length === 3) {
+    // Full boosted/buffer swap: token[wrap]wrappedToken[swap]wrappedToken[unwrap]token
+    return FULL_BOOSTED_SWAP_GAS_COST;
+  } else {
+    switch (steps[0].poolState.poolType) {
+      case 'WEIGHTED':
+        return WEIGHTED_GAS_COST;
+      case 'STABLE':
+        return STABLE_GAS_COST;
+      case 'BUFFER':
+        return BUFFER_WRAP_UNWRAP_GAS_COST;
+      default:
+        return WEIGHTED_GAS_COST;
+    }
+  }
+}