@paraswap/dex-lib 4.0.3 → 4.0.5-balancer-v3.0

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

@@ -216,8 +216,8 @@ describe('BalancerV3 E2E', () => {
       const tokenASymbol: string = 'WXDAI';
       const tokenBSymbol: string = 'COW';
 
-      const tokenAAmount: string = '1000000000000000000';
-      const tokenBAmount: string = '1000000000000000000';
+      const tokenAAmount: string = '100000000000000000';
+      const tokenBAmount: string = '100000000000000000';
       const nativeTokenAmount = '100000000000000';
 
       testForNetwork(
@@ -233,12 +233,12 @@ describe('BalancerV3 E2E', () => {
     });
 
     describe('Weighed Path', () => {
-      const tokenASymbol: string = 'USDCe';
-      const tokenBSymbol: string = 'sDAI';
+      const tokenASymbol: string = 'sDAI';
+      const tokenBSymbol: string = 'XDAI';
 
-      const tokenAAmount: string = '1000000';
+      const tokenAAmount: string = '100000000000000000';
       const tokenBAmount: string = '100000000000000000';
-      const nativeTokenAmount = '0';
+      const nativeTokenAmount = '100000000000000000';
 
       testForNetwork(
         network,
@@ -272,4 +272,28 @@ describe('BalancerV3 E2E', () => {
       );
     });
   });
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+
+    describe('Stable Path', () => {
+      const tokenASymbol: string = 'wUSDL';
+      const tokenBSymbol: string = 'USDC';
+
+      const tokenAAmount: string = '1000000000000000000';
+      const tokenBAmount: string = '10000000';
+      const nativeTokenAmount = '0';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+        false,
+      );
+    });
+  });
 });

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

@@ -187,7 +187,7 @@ async function checkOnChainPricingNonMulti(
   // test match for each returned price
   for (const price of prices) {
     let expectedPrices: bigint[] = [];
-    if (price.data.steps.length === 1)
+    if (price.data.steps.length === 1 && !price.data.steps[0].isBuffer)
       expectedPrices = await querySinglePathPrices(
         network,
         side,
@@ -831,6 +831,234 @@ describe('BalancerV3', function () {
         }
       });
     });
+
+    describe('Buffer, Nested Rate', () => {
+      /*
+      The Gnosis pool, 0x272d6be442e30d7c87390edeb9b96f1e84cecd8d uses a rate provider that is nested. 
+      So unwrap rate does not equal rate between aave wsteth and eth. 
+      This particular case the rate provider accounts for growth of wsteth in terms of weth and the additional aave yield. 
+      This highlighted that rateProvider can not be used for buffer wrap/unwrap which instead should use erc4626 rate.
+      */
+      const dexHelper = new DummyDexHelper(network);
+
+      const tokens = Tokens[network];
+      const srcTokenSymbol = 'wstETH';
+      const destTokenSymbol = 'waGnowstETH';
+
+      const amountsForSell = [
+        0n,
+        1n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        100n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      ];
+
+      const amountsForBuy = [
+        0n,
+        1n * BI_POWS[tokens[destTokenSymbol].decimals],
+        100n * BI_POWS[tokens[destTokenSymbol].decimals],
+      ];
+
+      beforeAll(async () => {
+        blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+        balancerV3 = new BalancerV3(network, dexKey, dexHelper);
+        if (balancerV3.initializePricing) {
+          await balancerV3.initializePricing(blockNumber);
+        }
+      });
+
+      it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+        await testPricingOnNetwork(
+          balancerV3,
+          network,
+          dexKey,
+          blockNumber,
+          srcTokenSymbol,
+          destTokenSymbol,
+          SwapSide.SELL,
+          amountsForSell,
+        );
+      });
+
+      it('getPoolIdentifiers and getPricesVolume BUY', async function () {
+        await testPricingOnNetwork(
+          balancerV3,
+          network,
+          dexKey,
+          blockNumber,
+          srcTokenSymbol,
+          destTokenSymbol,
+          SwapSide.BUY,
+          amountsForBuy,
+        );
+      });
+    });
+  });
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+    describe('Token/Underlying With Different Decimals', () => {
+      /*
+      Mainnet Pool, 0x5dd88b3aa3143173eb26552923922bdf33f50949 has an ERC4626 token with 18 decimals that uses a 6 decimal underlying.
+      Note for maths: Instead of manually adding support for each ERC4626 implementation (e.g. stata with Ray maths) we always use an 
+      18 decimal scaled rate and do 18 decimal maths to convert. We may end up loosing 100% accuracy but thats deemed acceptable.
+      */
+      describe.only('Buffer wrap 6decimal>18decimal', () => {
+        const dexHelper = new DummyDexHelper(network);
+
+        const tokens = Tokens[network];
+        const srcTokenSymbol = 'USDC';
+        const destTokenSymbol = 'steakUSDC';
+
+        const amountsForSell = [
+          0n,
+          1n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          10n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        ];
+
+        const amountsForBuy = [
+          0n,
+          1n * BI_POWS[tokens[destTokenSymbol].decimals],
+          10n * BI_POWS[tokens[destTokenSymbol].decimals],
+        ];
+
+        beforeAll(async () => {
+          blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+          balancerV3 = new BalancerV3(network, dexKey, dexHelper);
+          if (balancerV3.initializePricing) {
+            await balancerV3.initializePricing(blockNumber);
+          }
+        });
+
+        it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+          await testPricingOnNetwork(
+            balancerV3,
+            network,
+            dexKey,
+            blockNumber,
+            srcTokenSymbol,
+            destTokenSymbol,
+            SwapSide.SELL,
+            amountsForSell,
+          );
+        });
+
+        it('getPoolIdentifiers and getPricesVolume BUY', async function () {
+          await testPricingOnNetwork(
+            balancerV3,
+            network,
+            dexKey,
+            blockNumber,
+            srcTokenSymbol,
+            destTokenSymbol,
+            SwapSide.BUY,
+            amountsForBuy,
+          );
+        });
+      });
+      describe('Buffer unwrap 18decimal>6decimal', () => {
+        const dexHelper = new DummyDexHelper(network);
+
+        const tokens = Tokens[network];
+        const srcTokenSymbol = 'steakUSDC';
+        const destTokenSymbol = 'USDC';
+
+        const amountsForSell = [
+          0n,
+          1n * BI_POWS[tokens[srcTokenSymbol].decimals],
+          10n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        ];
+
+        const amountsForBuy = [
+          0n,
+          1n * BI_POWS[tokens[destTokenSymbol].decimals],
+          10n * BI_POWS[tokens[destTokenSymbol].decimals],
+        ];
+
+        beforeAll(async () => {
+          blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+          balancerV3 = new BalancerV3(network, dexKey, dexHelper);
+          if (balancerV3.initializePricing) {
+            await balancerV3.initializePricing(blockNumber);
+          }
+        });
+
+        it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+          await testPricingOnNetwork(
+            balancerV3,
+            network,
+            dexKey,
+            blockNumber,
+            srcTokenSymbol,
+            destTokenSymbol,
+            SwapSide.SELL,
+            amountsForSell,
+          );
+        });
+
+        it('getPoolIdentifiers and getPricesVolume BUY', async function () {
+          await testPricingOnNetwork(
+            balancerV3,
+            network,
+            dexKey,
+            blockNumber,
+            srcTokenSymbol,
+            destTokenSymbol,
+            SwapSide.BUY,
+            amountsForBuy,
+          );
+        });
+      });
+      describe('Full boosted path', () => {
+        const dexHelper = new DummyDexHelper(network);
+
+        const tokens = Tokens[network];
+        const srcTokenSymbol = 'wUSDL';
+        const destTokenSymbol = 'USDC';
+
+        const amountsForSell = [
+          0n,
+          1n * BI_POWS[tokens[srcTokenSymbol].decimals],
+        ];
+
+        const amountsForBuy = [
+          0n,
+          1n * BI_POWS[tokens[destTokenSymbol].decimals],
+        ];
+
+        beforeAll(async () => {
+          blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+          balancerV3 = new BalancerV3(network, dexKey, dexHelper);
+          if (balancerV3.initializePricing) {
+            await balancerV3.initializePricing(blockNumber);
+          }
+        });
+
+        it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+          await testPricingOnNetwork(
+            balancerV3,
+            network,
+            dexKey,
+            blockNumber,
+            srcTokenSymbol,
+            destTokenSymbol,
+            SwapSide.SELL,
+            amountsForSell,
+          );
+        });
+
+        it('getPoolIdentifiers and getPricesVolume BUY', async function () {
+          await testPricingOnNetwork(
+            balancerV3,
+            network,
+            dexKey,
+            blockNumber,
+            srcTokenSymbol,
+            destTokenSymbol,
+            SwapSide.BUY,
+            amountsForBuy,
+          );
+        });
+      });
+    });
   });
 });
 

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

@@ -14,7 +14,12 @@ import {
 } from './types';
 import { getPoolsApi } from './getPoolsApi';
 import vaultExtensionAbi_V3 from '../../abi/balancer-v3/vault-extension.json';
-import { decodeThrowError, getOnChainState } from './getOnChainState';
+import {
+  decodeErc4626MultiCallData,
+  decodeThrowError,
+  getErc4626MultiCallData,
+  getOnChainState,
+} from './getOnChainState';
 import { BalancerV3Config } from './config';
 import { SwapKind, Vault } from '@balancer-labs/balancer-maths';
 import {
@@ -25,7 +30,7 @@ import {
 } from './stablePool';
 import { BI_POWS } from '../../bigint-constants';
 
-const WAD = BI_POWS[18];
+export const WAD = BI_POWS[18];
 
 export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
   handlers: {
@@ -65,6 +70,9 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
         'function getAmplificationParameter() external view returns (uint256 value, bool isUpdating, uint256 precision)',
         'function getAmplificationState() external view returns (tuple(uint64 startValue, uint64 endValue, uint32 startTime, uint32 endTime) amplificationState, uint256 precision)',
       ]),
+      ['ERC4626']: new Interface([
+        'function convertToAssets(uint256 shares) external view returns (uint256 assets)',
+      ]),
     };
 
     this.logDecoder = (log: Log) => this.interfaces['VAULT'].parseLog(log);
@@ -445,11 +453,12 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
     if (!poolState) return;
 
     // Fetch onchain pool rates
-    const poolRates = await this.getPoolRates(Object.keys(poolState));
+    const poolRates = await this.getPoolRates(poolState);
 
     // Update each pools rate
-    poolRates.forEach(({ poolAddress, tokenRates }, i) => {
+    poolRates.forEach(({ poolAddress, tokenRates, erc4626Rates }, i) => {
       poolState[poolAddress].tokenRates = tokenRates;
+      poolState[poolAddress].erc4626Rates = erc4626Rates;
     });
 
     // Update state
@@ -457,9 +466,15 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
     this.setState(poolState, blockNumber);
   }
 
-  private async getPoolRates(poolAddresses: string[]) {
+  private async getPoolRates(poolState: PoolStateMap) {
+    const erc4626MultiCallData = getErc4626MultiCallData(
+      this.interfaces['ERC4626'],
+      poolState,
+    );
+
+    const poolAddresses = Object.keys(poolState);
     // For each pool make the getPoolTokenRates call
-    const multiCallData = poolAddresses.map(address => {
+    const poolsMultiCallData = poolAddresses.map(address => {
       return {
         target: BalancerV3Config.BalancerV3[this.network].vaultAddress,
         callData: this.interfaces['VAULT'].encodeFunctionData(
@@ -469,10 +484,13 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
       };
     });
     // 500 is an arbitrary number chosen based on the blockGasLimit
-    const slicedMultiCallData = _.chunk(multiCallData, 500);
+    const slicedMultiCallData = _.chunk(
+      [...erc4626MultiCallData, ...poolsMultiCallData],
+      500,
+    );
 
     // Make the multicall
-    const multicallData = (
+    const multicallDataResult = (
       await Promise.all(
         slicedMultiCallData.map(async _multiCallData =>
           this.dexHelper.multiContract.methods
@@ -482,16 +500,34 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
       )
     ).flat();
 
+    const dataResultErc4626 = multicallDataResult.slice(
+      0,
+      erc4626MultiCallData.length,
+    );
+    const dataResultPools = multicallDataResult.slice(
+      erc4626MultiCallData.length,
+    );
+
+    const tokensWithRates = decodeErc4626MultiCallData(
+      this.interfaces['ERC4626'],
+      erc4626MultiCallData,
+      dataResultErc4626,
+    );
+
     return poolAddresses.map((address, i) => {
       const tokenRateResult = decodeThrowError(
         this.interfaces['VAULT'],
         'getPoolTokenRates',
-        multicallData[i],
+        dataResultPools[i],
         address,
       );
       return {
         poolAddress: address,
         tokenRates: tokenRateResult.tokenRates.map((r: string) => BigInt(r)),
+        erc4626Rates: poolState[address].tokens.map(t => {
+          if (!tokensWithRates[t]) return null;
+          return tokensWithRates[t];
+        }),
       };
     });
   }
@@ -522,12 +558,18 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
           address && address.toLowerCase() === tokenAddress.toLowerCase(),
       );
       if (tokenIndex !== -1) {
+        if (poolState.erc4626Rates[tokenIndex] === null) {
+          this.logger.error(
+            `missing erc4626 token rate ${poolState.tokens[tokenIndex]}`,
+          );
+          return null;
+        }
         return {
           isBoosted: true,
           mainToken: poolState.tokens[tokenIndex],
           underlyingToken: tokenAddress,
           index: tokenIndex,
-          rate: poolState.tokenRates[tokenIndex],
+          rate: poolState.erc4626Rates[tokenIndex]!,
         };
       }
     }

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

@@ -10,11 +10,7 @@ export enum SUPPORTED_POOLS {
 
 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',
-    ],
+    [Network.GNOSIS]: [],
   },
 };
 

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

@@ -8,6 +8,7 @@ import {
 import { BalancerV3Config } from './config';
 import { Interface, Result } from '@ethersproject/abi';
 import { IDexHelper } from '../../dex-helper';
+import { WAD } from './balancer-v3-pool';
 
 interface callData {
   target: string;
@@ -85,7 +86,7 @@ const poolOnChain: Record<
       poolAddress: string,
       data: any,
       startIndex: number,
-    ): CommonMutableState => {
+    ): Omit<CommonMutableState, 'erc4626Rates'> => {
       const resultTokenRates = decodeThrowError(
         contractInterface,
         'getPoolTokenRates',
@@ -259,6 +260,52 @@ export function decodeThrowError(
   );
 }
 
+export function getErc4626MultiCallData(
+  erc4626Interface: Interface,
+  immutablePoolStateMap: ImmutablePoolStateMap,
+): callData[] {
+  // We want to query rate for each unique ERC4626 token
+  const uniqueErc4626Tokens = Array.from(
+    new Set(
+      Object.values(immutablePoolStateMap).flatMap(pool =>
+        pool.tokens.filter((_, index) => pool.tokensUnderlying[index] !== null),
+      ),
+    ),
+  );
+
+  // query result for 1e18 (this maintains correct scaling for different token decimals in maths)
+  const erc4626MultiCallData: callData[] = uniqueErc4626Tokens.map(token => {
+    return {
+      target: token,
+      callData: erc4626Interface.encodeFunctionData('convertToAssets', [WAD]),
+    };
+  });
+  return erc4626MultiCallData;
+}
+
+export function decodeErc4626MultiCallData(
+  erc4626Interface: Interface,
+  erc4626MultiCallData: callData[],
+  dataResultErc4626: any[],
+) {
+  return Object.fromEntries(
+    erc4626MultiCallData.map((multiCallData, i) => {
+      const rate = decodeThrowError(
+        erc4626Interface,
+        'convertToAssets',
+        dataResultErc4626[i],
+        multiCallData.target,
+      );
+      if (!rate)
+        throw new Error(
+          `Failed to get result for convertToAssets for ${multiCallData.target}`,
+        );
+
+      return [multiCallData.target, BigInt(rate[0])];
+    }),
+  );
+}
+
 // Any data from API will be immutable. Mutable data such as balances, etc will be fetched via onchain/event state.
 export async function getOnChainState(
   network: number,
@@ -269,7 +316,13 @@ export async function getOnChainState(
   },
   blockNumber?: number,
 ): Promise<PoolStateMap> {
-  const multiCallData = Object.entries(immutablePoolStateMap)
+  const erc4626MultiCallData = getErc4626MultiCallData(
+    interfaces['ERC4626'],
+    immutablePoolStateMap,
+  );
+
+  // query pool specific onchain data, e.g. totalSupply, etc
+  const poolsMultiCallData = Object.entries(immutablePoolStateMap)
     .map(([address, pool]) => {
       return [
         ...poolOnChain['COMMON'].encode(network, interfaces['VAULT'], address),
@@ -283,9 +336,12 @@ export async function getOnChainState(
     .flat();
 
   // 500 is an arbitrary number chosen based on the blockGasLimit
-  const slicedMultiCallData = _.chunk(multiCallData, 500);
+  const slicedMultiCallData = _.chunk(
+    [...erc4626MultiCallData, ...poolsMultiCallData],
+    500,
+  );
 
-  const multicallData = (
+  const multicallDataResult = (
     await Promise.all(
       slicedMultiCallData.map(async _multiCallData =>
         dexHelper.multiContract.methods
@@ -295,20 +351,34 @@ export async function getOnChainState(
     )
   ).flat();
 
+  const dataResultErc4626 = multicallDataResult.slice(
+    0,
+    erc4626MultiCallData.length,
+  );
+  const dataResultPools = multicallDataResult.slice(
+    erc4626MultiCallData.length,
+  );
+
+  const tokensWithRates = decodeErc4626MultiCallData(
+    interfaces['ERC4626'],
+    erc4626MultiCallData,
+    dataResultErc4626,
+  );
+
   let i = 0;
   const poolStateMap = Object.fromEntries(
     Object.entries(immutablePoolStateMap).map(([address, pool]) => {
       const commonMutableData = poolOnChain['COMMON'].decode(
         interfaces['VAULT'],
         address,
-        multicallData,
+        dataResultPools,
         i,
       ) as CommonMutableState;
       i = i + poolOnChain['COMMON'].count;
       const poolMutableData = poolOnChain[pool.poolType].decode(
         interfaces[pool.poolType],
         address,
-        multicallData,
+        dataResultPools,
         i,
       );
       i = i + poolOnChain[pool.poolType].count;
@@ -318,6 +388,10 @@ export async function getOnChainState(
           ...pool,
           ...commonMutableData,
           ...poolMutableData,
+          erc4626Rates: pool.tokens.map(t => {
+            if (!tokensWithRates[t]) return null;
+            return tokensWithRates[t];
+          }),
         },
       ];
     }),

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

@@ -18,6 +18,7 @@ export type CommonImmutablePoolState = {
 // Mutable data types available on all pools (Available via onchain calls/events)
 export interface CommonMutableState {
   tokenRates: bigint[];
+  erc4626Rates: (bigint | null)[];
   balancesLiveScaled18: bigint[];
   swapFee: bigint;
   aggregateSwapFee: bigint;

package/src/dex/bebop/bebop.ts

@@ -723,7 +723,7 @@ export class Bebop extends SimpleExchange implements IDex<BebopData> {
         }
       }
 
-      if (side == SwapSide.SELL) {
+      if (side === SwapSide.SELL) {
         const requiredAmount = BigInt(optimalSwapExchange.destAmount);
         const quoteAmount = BigInt(
           response.buyTokens[utils.getAddress(destToken.address)].amount,