@paraswap/dex-lib 4.0.22 → 4.0.24-bal-v3-nested-erc4626.0

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

@@ -11,6 +11,7 @@ import {
   StableMutableState,
   Step,
   TokenInfo,
+  TokenType,
 } from './types';
 import { getPoolsApi } from './getPoolsApi';
 import vaultExtensionAbi_V3 from '../../abi/balancer-v3/vault-extension.json';
@@ -543,11 +544,8 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
     );
     if (tokenIndex !== -1) {
       return {
-        isBoosted: false,
-        mainToken: tokenAddress,
-        underlyingToken: null,
         index: tokenIndex,
-        rate: poolState.tokenRates[tokenIndex],
+        type: TokenType.MainToken,
       };
     }
 
@@ -558,18 +556,23 @@ 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.erc4626Rates[tokenIndex]!,
+          type: TokenType.ERC4626,
+        };
+      }
+    }
+
+    // Check in nested underlying tokens if available
+    if (poolState.tokensNestedERC4626Underlying) {
+      tokenIndex = poolState.tokensNestedERC4626Underlying.findIndex(
+        address =>
+          address && address.toLowerCase() === tokenAddress.toLowerCase(),
+      );
+      if (tokenIndex !== -1) {
+        return {
+          index: tokenIndex,
+          type: TokenType.ERC4626Nested,
         };
       }
     }
@@ -593,104 +596,182 @@ export class BalancerV3EventPool extends StatefulEventSubscriber<PoolStateMap> {
    * https://docs-v3.balancer.fi/concepts/vault/buffer.html
    */
   getSteps(pool: PoolState, tokenIn: TokenInfo, tokenOut: TokenInfo): Step[] {
-    if (tokenIn.isBoosted && tokenOut.isBoosted) {
-      return [
-        // Wrap tokenIn underlying to main token
-        this.getWrapStep(tokenIn),
-        // Swap main > main
-        this.getSwapStep(pool, tokenIn, tokenOut),
-        // Unwrap tokenOut main to underlying token
-        this.getUnwrapStep(tokenOut),
-      ];
-    } else if (tokenIn.isBoosted) {
-      if (
-        tokenIn.mainToken.toLowerCase() === tokenOut.mainToken.toLowerCase()
-      ) {
-        // wrap, token > erc4626
-        // tokenIn is boosted, e.g. isn't pool token and must be wrapped
-        return [this.getWrapStep(tokenIn)];
+    // This is a single buffer wrap/unwrap
+    if (tokenIn.index === tokenOut.index) {
+      return this.singleBufferStep(pool, tokenIn, tokenOut);
+    }
+
+    // Create steps based on token types
+    const steps: Step[] = [];
+
+    // Handle input token wrapping if needed
+    if (this.needsBuffer(tokenIn)) {
+      if (tokenIn.type === TokenType.ERC4626Nested) {
+        steps.push(this.getWrapStepNested(pool, tokenIn));
       }
-      return [
-        // Wrap tokenIn underlying to main token
-        this.getWrapStep(tokenIn),
-        // Swap main > main
-        this.getSwapStep(pool, tokenIn, tokenOut),
-      ];
-    } else if (tokenOut.isBoosted) {
-      if (
-        tokenIn.mainToken.toLowerCase() === tokenOut.mainToken.toLowerCase()
-      ) {
-        // unwrap, stata > token
-        // token out is boosted, e.g. isn't pool token
-        return [this.getUnwrapStep(tokenOut)];
+      steps.push(this.getWrapStep(pool, tokenIn));
+    }
+
+    // Add main swap step
+    steps.push(this.getSwapStep(pool, tokenIn, tokenOut));
+
+    // Handle output token unwrapping if needed
+    if (this.needsBuffer(tokenOut)) {
+      steps.push(this.getUnwrapStep(pool, tokenOut));
+      if (tokenOut.type === TokenType.ERC4626Nested) {
+        steps.push(this.getUnwrapStepNested(pool, tokenOut));
       }
-      return [
-        // Swap main > main
-        this.getSwapStep(pool, tokenIn, tokenOut),
-        // Unwrap tokenOut main to underlying token
-        this.getUnwrapStep(tokenOut),
-      ];
-    } else {
-      return [
-        // Swap main > main
-        this.getSwapStep(pool, tokenIn, tokenOut),
-      ];
     }
+
+    return steps;
+  }
+
+  private singleBufferStep(
+    pool: PoolState,
+    tokenIn: TokenInfo,
+    tokenOut: TokenInfo,
+  ): Step[] {
+    if (tokenIn.type === TokenType.ERC4626) {
+      // wrap, token > erc4626
+      // tokenIn is boosted, e.g. isn't pool token and must be wrapped
+      return [this.getWrapStep(pool, tokenIn)];
+    }
+    if (tokenOut.type === TokenType.ERC4626) {
+      // unwrap, erc4626 > token
+      // tokenOut is boosted, e.g. isn't pool token and must be unwrapped
+      return [this.getUnwrapStep(pool, tokenOut)];
+    }
+    throw new Error(`Error get step with same token index`);
+  }
+
+  private needsBuffer(token: TokenInfo): boolean {
+    return (
+      token.type === TokenType.ERC4626 || token.type === TokenType.ERC4626Nested
+    );
   }
 
-  getWrapStep(token: TokenInfo): Step {
-    if (!token.underlyingToken)
+  private validateUnderlyingToken(pool: PoolState, tokenIndex: number): void {
+    if (!pool.tokensUnderlying[tokenIndex] || !pool.erc4626Rates[tokenIndex]) {
       throw new Error(
-        `Buffer wrap: token has no underlying. ${token.mainToken}`,
+        `Underlying Token Error: token at index ${tokenIndex}. ${pool.tokensUnderlying[tokenIndex]} ${pool.erc4626Rates[tokenIndex]}`,
       );
-    // Vault expects pool to be the ERC4626 wrapped token, e.g. aUSDC
+    }
+  }
+
+  private validateNestedUnderlyingToken(
+    pool: PoolState,
+    tokenIndex: number,
+  ): void {
+    if (
+      !pool.tokensUnderlying[tokenIndex] ||
+      !pool.tokensNestedERC4626Underlying[tokenIndex] ||
+      !pool.erc4626NestedRates[tokenIndex]
+    ) {
+      throw new Error(
+        `NestedUnderlying Token Error: token at index ${tokenIndex}. ${pool.tokensUnderlying[tokenIndex]} ${pool.tokensNestedERC4626Underlying[tokenIndex]} ${pool.erc4626NestedRates[tokenIndex]}`,
+      );
+    }
+  }
+
+  getWrapStepNested(pool: PoolState, token: TokenInfo): Step {
+    this.validateNestedUnderlyingToken(pool, token.index);
+
+    const underlyingToken = pool.tokensUnderlying[token.index] as string;
+    const nestedUnderlyingToken = pool.tokensNestedERC4626Underlying[
+      token.index
+    ] as string;
+
     return {
-      pool: token.mainToken,
+      pool: underlyingToken,
       isBuffer: true,
       swapInput: {
-        tokenIn: token.underlyingToken,
-        tokenOut: token.mainToken,
+        tokenIn: nestedUnderlyingToken,
+        tokenOut: underlyingToken,
       },
       poolState: {
         poolType: 'Buffer',
-        rate: token.rate,
-        poolAddress: token.mainToken,
-        tokens: [token.mainToken, token.underlyingToken], // staticToken & underlying
+        rate: pool.erc4626NestedRates[token.index] as bigint,
+        poolAddress: underlyingToken,
+        tokens: [nestedUnderlyingToken, underlyingToken],
       },
     };
   }
 
-  getUnwrapStep(token: TokenInfo): Step {
-    if (!token.underlyingToken)
-      throw new Error(
-        `Buffer unwrap: token has no underlying. ${token.mainToken}`,
-      );
-    // Vault expects pool to be the ERC4626 wrapped token, e.g. aUSDC
+  getWrapStep(pool: PoolState, token: TokenInfo): Step {
+    this.validateUnderlyingToken(pool, token.index);
+
+    const wrappedToken = pool.tokens[token.index];
+    const underlyingToken = pool.tokensUnderlying[token.index] as string;
+
+    return {
+      pool: wrappedToken,
+      isBuffer: true,
+      swapInput: {
+        tokenIn: underlyingToken,
+        tokenOut: wrappedToken,
+      },
+      poolState: {
+        poolType: 'Buffer',
+        rate: pool.erc4626Rates[token.index] as bigint,
+        poolAddress: wrappedToken,
+        tokens: [wrappedToken, underlyingToken],
+      },
+    };
+  }
+
+  getUnwrapStepNested(pool: PoolState, token: TokenInfo): Step {
+    this.validateNestedUnderlyingToken(pool, token.index);
+
+    const underlyingToken = pool.tokensUnderlying[token.index] as string;
+    const nestedUnderlyingToken = pool.tokensNestedERC4626Underlying[
+      token.index
+    ] as string;
+
+    return {
+      pool: underlyingToken,
+      isBuffer: true,
+      swapInput: {
+        tokenIn: underlyingToken,
+        tokenOut: nestedUnderlyingToken,
+      },
+      poolState: {
+        poolType: 'Buffer',
+        rate: pool.erc4626NestedRates[token.index] as bigint,
+        poolAddress: underlyingToken,
+        tokens: [nestedUnderlyingToken, underlyingToken],
+      },
+    };
+  }
+
+  getUnwrapStep(pool: PoolState, token: TokenInfo): Step {
+    this.validateUnderlyingToken(pool, token.index);
+
+    const wrappedToken = pool.tokens[token.index];
+    const underlyingToken = pool.tokensUnderlying[token.index] as string;
+
     return {
-      pool: token.mainToken,
+      pool: wrappedToken,
       isBuffer: true,
       swapInput: {
-        tokenIn: token.mainToken,
-        tokenOut: token.underlyingToken,
+        tokenIn: wrappedToken,
+        tokenOut: underlyingToken,
       },
       poolState: {
         poolType: 'Buffer',
-        // TODO: for ERC4626 fetch the wrap/unwrap rate
-        rate: token.rate,
-        poolAddress: token.mainToken,
-        tokens: [token.mainToken, token.underlyingToken], // staticToken & underlying
+        rate: pool.erc4626Rates[token.index] as bigint,
+        poolAddress: wrappedToken,
+        tokens: [wrappedToken, underlyingToken],
       },
     };
   }
 
   getSwapStep(pool: PoolState, tokenIn: TokenInfo, tokenOut: TokenInfo): Step {
-    // A normal swap between two tokens in a pool
     return {
       pool: pool.poolAddress,
       isBuffer: false,
       swapInput: {
-        tokenIn: tokenIn.mainToken,
-        tokenOut: tokenOut.mainToken,
+        tokenIn: pool.tokens[tokenIn.index],
+        tokenOut: pool.tokens[tokenOut.index],
       },
       poolState: pool,
     };

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

@@ -177,7 +177,9 @@ export class BalancerV3 extends SimpleExchange implements IDex<BalancerV3Data> {
   hasTokens(pool: DeepReadonly<PoolState>, tokens: string[]): boolean {
     return tokens.every(
       token =>
-        pool.tokens.includes(token) || pool.tokensUnderlying.includes(token),
+        pool.tokens.includes(token) ||
+        pool.tokensUnderlying.includes(token) ||
+        pool.tokensNestedERC4626Underlying.includes(token),
     );
   }
 
@@ -586,11 +588,20 @@ export class BalancerV3 extends SimpleExchange implements IDex<BalancerV3Data> {
         .filter(t => !!t)
         .filter(t => t?.address !== tokenAddress) as Token[];
 
+      const nestedUnderlyingTokens = pool.poolTokens
+        .map(t => ({
+          address: t.underlyingToken?.underlyingTokenAddress,
+          decimals: t.underlyingToken?.decimals,
+        }))
+        .filter(item => !!item.address) as Token[];
+
       return {
         exchange: this.dexKey,
         address: pool.address,
         liquidityUSD: parseFloat(pool.dynamicData.totalLiquidity),
-        connectorTokens: tokens.concat(underlyingTokens),
+        connectorTokens: tokens
+          .concat(underlyingTokens)
+          .concat(nestedUnderlyingTokens),
       };
     });
   }

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

@@ -14,15 +14,7 @@ const PARTIAL_BOOSTED_SWAP_GAS_COST = 259815;
 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 {
+  if (steps.length === 1) {
     switch (steps[0].poolState.poolType) {
       case 'WEIGHTED':
         return WEIGHTED_GAS_COST;
@@ -33,5 +25,18 @@ export function getGasCost(steps: Step[]): number {
       default:
         return WEIGHTED_GAS_COST;
     }
+  } else 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 {
+    return (
+      FULL_BOOSTED_SWAP_GAS_COST +
+      (steps.length - 3) * BUFFER_WRAP_UNWRAP_GAS_COST
+    );
   }
 }

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

@@ -86,7 +86,7 @@ const poolOnChain: Record<
       poolAddress: string,
       data: any,
       startIndex: number,
-    ): Omit<CommonMutableState, 'erc4626Rates'> => {
+    ): Omit<CommonMutableState, 'erc4626Rates' | 'erc4626NestedRates'> => {
       const resultTokenRates = decodeThrowError(
         contractInterface,
         'getPoolTokenRates',
@@ -267,8 +267,17 @@ export function getErc4626MultiCallData(
   // 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),
+      Object.values(immutablePoolStateMap).flatMap(
+        pool =>
+          [
+            // Get tokens with corresponding non-null tokensUnderlying
+            ...pool.tokens.filter(
+              (_, index) => pool.tokensUnderlying[index] !== null,
+            ),
+            ...pool.tokensUnderlying.filter(
+              (_, index) => pool.tokensNestedERC4626Underlying[index] !== null,
+            ),
+          ] as string[],
       ),
     ),
   );
@@ -392,6 +401,10 @@ export async function getOnChainState(
             if (!tokensWithRates[t]) return null;
             return tokensWithRates[t];
           }),
+          erc4626NestedRates: pool.tokensUnderlying.map(t => {
+            if (!t || !tokensWithRates[t]) return null;
+            return tokensWithRates[t];
+          }),
         },
       ];
     }),

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

@@ -14,6 +14,7 @@ interface PoolToken {
   isErc4626: boolean;
   underlyingToken: {
     address: string;
+    underlyingTokenAddress: string | null;
   } | null;
 }
 
@@ -67,6 +68,7 @@ function createQuery(
           isErc4626
           underlyingToken {
             address
+            underlyingTokenAddress
           }
         }
       }
@@ -82,6 +84,9 @@ function toImmutablePoolStateMap(pools: Pool[]): ImmutablePoolStateMap {
       tokensUnderlying: pool.poolTokens.map(t =>
         t.underlyingToken ? t.underlyingToken.address : null,
       ),
+      tokensNestedERC4626Underlying: pool.poolTokens.map(t =>
+        t.underlyingToken ? t.underlyingToken.underlyingTokenAddress : null,
+      ),
       weights: pool.poolTokens.map(t =>
         t.weight ? parseUnits(t.weight, 18).toBigInt() : 0n,
       ),

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

@@ -7,6 +7,7 @@ interface PoolToken {
   underlyingToken?: {
     address: string;
     decimals: number;
+    underlyingTokenAddress: string;
   };
 }
 
@@ -63,6 +64,7 @@ function createQuery(
           underlyingToken {
             address
             decimals
+            underlyingTokenAddress
           }
         }
         dynamicData {

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

@@ -9,6 +9,7 @@ export type CommonImmutablePoolState = {
   tokens: string[];
   // For boosted pools underlying is the unwrapped token, e.g. USDC/DAI
   tokensUnderlying: (string | null)[];
+  tokensNestedERC4626Underlying: (string | null)[];
   weights: bigint[];
   // TODO re-introduce this once added to API
   // scalingFactors: bigint[];
@@ -19,6 +20,7 @@ export type CommonImmutablePoolState = {
 export interface CommonMutableState {
   tokenRates: bigint[];
   erc4626Rates: (bigint | null)[];
+  erc4626NestedRates: (bigint | null)[];
   balancesLiveScaled18: bigint[];
   swapFee: bigint;
   aggregateSwapFee: bigint;
@@ -78,10 +80,13 @@ export type DexParams = {
   balancerBatchRouterAddress: string;
 };
 
+export enum TokenType {
+  MainToken = 1,
+  ERC4626,
+  ERC4626Nested,
+}
+
 export type TokenInfo = {
-  isBoosted: boolean;
-  underlyingToken: string | null;
-  mainToken: string;
   index: number;
-  rate: bigint;
+  type: TokenType;
 };

package/src/dex/generic-rfq/e2e-test-config.ts

@@ -8,16 +8,16 @@ export const testConfig: {
     amount: string;
   }>;
 } = {
-  [Network.ARBITRUM]: [
+  [Network.MAINNET]: [
     {
-      srcToken: 'WETH',
+      srcToken: 'USDT',
       destToken: 'USDC',
       amount: '10000',
       swapSide: SwapSide.BUY,
     },
     {
       srcToken: 'USDC',
-      destToken: 'WETH',
+      destToken: 'USDT',
       amount: '10000',
       swapSide: SwapSide.SELL,
     },

package/src/dex/generic-rfq/generic-rfq-e2e.test.ts

@@ -115,8 +115,8 @@ describe(`GenericRFQ ${dexKey} E2E`, () => {
               `Please add "addBalance" and "addAllowance" functions for ${testCase.destToken} on ${Network[network]} (in constants-e2e.ts).`,
             );
           }
-          srcToken = smartTokens[testCase.srcToken];
-          destToken = smartTokens[testCase.destToken];
+          srcToken = new SmartToken(tokens[testCase.srcToken]);
+          destToken = new SmartToken(tokens[testCase.destToken]);
 
           srcToken.addBalance(testAccount.address, MAX_UINT);
           srcToken.addAllowance(

package/src/dex/maverick-v1/config.ts

@@ -14,8 +14,7 @@ export const MaverickV1Config: DexConfigMap<DexParams> = {
       poolInspectorAddress: '0xaA5BF61a664109e959D69C38734d4EA7dF74e456',
     },
     [Network.BASE]: {
-      subgraphURL:
-        'https://api.studio.thegraph.com/query/42519/maverick-base/version/latest',
+      subgraphURL: 'CSxkHjxpG1TxTBQMn55uG1DWpdD4Lsix4RNX4RTLvK4T',
       routerAddress: '0x32AED3Bce901DA12ca8489788F3A99fCe1056e14',
       poolInspectorAddress: '0x65A3AD03Be97619284bA7AA1E3Ca05638B9d6364',
     },

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

@@ -117,8 +117,7 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
       chunksCount: 10,
       initRetryFrequency: 10,
       initHash: `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`,
-      subgraphURL:
-        'https://api.studio.thegraph.com/query/48211/uniswap-v3-base/version/latest',
+      subgraphURL: 'GqzP4Xaehti8KSfQmv3ZctFSjnSUYZ4En5NRsiTbvZpz',
     },
   },
   SushiSwapV3: {

package/tests/constants-e2e.ts

@@ -128,7 +128,7 @@ export const Tokens: {
       address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
       decimals: 6,
       symbol: 'USDC',
-      addBalance: balancesFn,
+      addBalance: balanceAndBlacklistStatesFn,
       addAllowance: allowedFn,
     },
     INST: {
@@ -581,6 +581,21 @@ export const Tokens: {
       decimals: 6,
       symbol: 'USUALM',
     },
+    USDL: {
+      address: '0xbdC7c08592Ee4aa51D06C27Ee23D5087D65aDbcD',
+      decimals: 18,
+      symbol: 'USDL',
+    },
+    csUSDL: {
+      address: '0xbEeFc011e94f43b8B7b455eBaB290C7Ab4E216f1',
+      decimals: 18,
+      symbol: 'csUSDL',
+    },
+    csUSDC: {
+      address: '0x7204b7dbf9412567835633b6f00c3edc3a8d6330',
+      decimals: 18,
+      symbol: 'csUSDC',
+    },
   },
   [Network.POLYGON]: {
     jGBP: {

package/tests/smart-tokens.ts

@@ -5,9 +5,7 @@ export type StateOverride = {
 };
 
 export type StateSimulateApiOverride = {
-  storage: {
-    value: Record<string, string>;
-  };
+  storage: Record<string, string>;
 };
 
 export type StateOverrides = {