@paraswap/dex-lib 2.28.9-take-surplus.0 → 2.28.9-take-surplus.1

package/src/dex/algebra/lib/TickTable.ts

@@ -43,7 +43,7 @@ export class TickTable {
       // wordPos
       BigInt.asIntN(16, tick >> 8n),
       // bitPos
-      BigInt.asUintN(8, tick & BigInt(0xff)),
+      BigInt.asUintN(8, tick & 0xffn),
     ];
   }
 
@@ -56,7 +56,7 @@ export class TickTable {
       tick /= tickSpacing;
     }
     const [rowNumber, bitNumber] = TickTable.position(tick);
-    const mask = 1n << bitNumber;
+    const mask = BigInt.asUintN(256, 1n << bitNumber);
 
     // toggleTick is used only in _updatePosition which is always state changing event
     // Therefore it is never used in price query
@@ -83,20 +83,24 @@ export class TickTable {
     tickSpacing?: bigint,
   ): [bigint, boolean] {
     if (tickSpacing !== undefined) {
-      tick = Yul.sub(
-        Yul.sdiv(tick, tickSpacing),
-        Yul.and(
-          Yul.slt(tick, 0n),
-          Yul.not(Yul.iszero(Yul.smod(tick, tickSpacing))),
+      tick = BigInt.asIntN(
+        24,
+        Yul.sub(
+          Yul.sdiv(tick, tickSpacing),
+          Yul.and(
+            Yul.slt(tick, 0n),
+            Yul.not(Yul.iszero(Yul.smod(tick, tickSpacing))),
+          ),
         ),
       );
     }
-    const [rowNumber, bitNumber] = TickTable.position(tick);
-    isWordPosOut(rowNumber, state.startTickBitmap, isPriceQuery);
-    let tickBitmapValue = state.tickBitmap[rowNumber.toString()];
-    tickBitmapValue = tickBitmapValue === undefined ? 0n : tickBitmapValue;
     if (lte) {
-      const _row = tickBitmapValue << (255n - bitNumber);
+      const [rowNumber, bitNumber] = TickTable.position(tick);
+      isWordPosOut(rowNumber, state.startTickBitmap, isPriceQuery);
+      let tickBitmapValue = state.tickBitmap[rowNumber.toString()];
+      tickBitmapValue = tickBitmapValue === undefined ? 0n : tickBitmapValue;
+
+      const _row = BigInt.asUintN(256, tickBitmapValue << (255n - bitNumber));
       if (_row != 0n) {
         tick -= BigInt.asIntN(24, 255n - TickTable.getMostSignificantBit(_row));
         return [TickTable.boundTick(tick, tickSpacing), true];
@@ -106,7 +110,13 @@ export class TickTable {
       }
     } else {
       tick += 1n;
-      const _row = tickBitmapValue >> bitNumber;
+
+      const [rowNumber, bitNumber] = TickTable.position(tick);
+      isWordPosOut(rowNumber, state.startTickBitmap, isPriceQuery);
+      let tickBitmapValue = state.tickBitmap[rowNumber.toString()];
+      tickBitmapValue = tickBitmapValue === undefined ? 0n : tickBitmapValue;
+
+      const _row = BigInt.asUintN(256, tickBitmapValue >> bitNumber);
       if (_row !== 0n) {
         tick += BigInt.asIntN(
           24,
@@ -123,80 +133,71 @@ export class TickTable {
   static getSingleSignificantBit(word: bigint): bigint {
     let singleBitPos = 0n;
     singleBitPos = Yul.iszero(
-      word &&
-        BigInt(
-          '0x5555555555555555555555555555555555555555555555555555555555555555',
-        ),
+      word &
+        0x5555555555555555555555555555555555555555555555555555555555555555n,
     );
     singleBitPos =
-      singleBitPos ||
-      Yul.iszero(
-        word &&
-          BigInt(
-            '0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff',
-          ),
-      ) << 7n;
+      singleBitPos |
+      (Yul.iszero(
+        word &
+          0x00000000000000000000000000000000ffffffffffffffffffffffffffffffffn,
+      ) <<
+        7n);
     singleBitPos =
-      singleBitPos ||
-      Yul.iszero(
-        word &&
-          BigInt(
-            '0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff',
-          ),
-      ) << 6n;
+      singleBitPos |
+      (Yul.iszero(
+        word &
+          0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffffn,
+      ) <<
+        6n);
     singleBitPos =
-      singleBitPos ||
-      Yul.iszero(
-        word &&
-          BigInt(
-            '0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff',
-          ),
-      ) << 5n;
+      singleBitPos |
+      (Yul.iszero(
+        word &
+          0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffffn,
+      ) <<
+        5n);
     singleBitPos =
-      singleBitPos ||
-      Yul.iszero(
-        word &&
-          BigInt(
-            '0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff',
-          ),
-      ) << 4n;
+      singleBitPos |
+      (Yul.iszero(
+        word &
+          0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffffn,
+      ) <<
+        4n);
     singleBitPos =
-      singleBitPos ||
-      Yul.iszero(
-        word &&
-          BigInt(
-            '0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff',
-          ),
-      ) << 3n;
+      singleBitPos |
+      (Yul.iszero(
+        word &
+          0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ffn,
+      ) <<
+        3n);
     singleBitPos =
-      singleBitPos ||
-      Yul.iszero(
-        word &&
-          BigInt(
-            '0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f',
-          ),
-      ) << 2n;
+      singleBitPos |
+      (Yul.iszero(
+        word &
+          0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0fn,
+      ) <<
+        2n);
     singleBitPos =
-      singleBitPos ||
-      Yul.iszero(
-        word &&
-          BigInt(
-            '0x3333333333333333333333333333333333333333333333333333333333333333',
-          ),
-      ) << 1n;
+      singleBitPos |
+      (Yul.iszero(
+        word &
+          0x3333333333333333333333333333333333333333333333333333333333333333n,
+      ) <<
+        1n);
 
     return BigInt.asUintN(8, singleBitPos);
   }
 
   static getMostSignificantBit(word: bigint): bigint {
-    word = word || word >> 1n;
-    word = word || word >> 2n;
-    word = word || word >> 4n;
-    word = word || word >> 8n;
-    word = word || word >> 16n;
-    word = word || word >> 32n;
-    word = word || word >> 64n;
-    word = word || word >> 128n;
+    word = word | (word >> 1n);
+    word = word | (word >> 2n);
+    word = word | (word >> 4n);
+    word = word | (word >> 8n);
+    word = word | (word >> 16n);
+    word = word | (word >> 32n);
+    word = word | (word >> 64n);
+    word = word | (word >> 128n);
     word = word - (word >> 1n);
     return TickTable.getSingleSignificantBit(BigInt.asUintN(256, word));
   }

package/src/dex/algebra/types.ts

@@ -2,7 +2,7 @@ import { BigNumber } from 'ethers';
 import { Address, NumberAsString } from '../../types';
 import { TickInfo } from '../uniswap-v3/types';
 
-type GlobalStateV1_1 = {
+export type GlobalStateV1_1 = {
   price: bigint; // The square root of the current price in Q64.96 format
   tick: bigint; // The current tick
   fee: bigint; // The current fee in hundredths of a bip, i.e. 1e-6
@@ -51,6 +51,8 @@ export type PoolState_v1_9 = {
   areTicksCompressed: boolean;
 };
 
+export type FactoryState = Record<string, never>;
+
 export type AlgebraData = {
   path: {
     tokenIn: Address;
@@ -71,6 +73,8 @@ export type DexParams = {
   subgraphURL: string;
   initHash: string;
   version: 'v1.1' | 'v1.9';
+  forceRPC?: boolean;
+  forceManualStateGenerate?: boolean;
 };
 
 export type IAlgebraPoolState = PoolStateV1_1 | PoolState_v1_9;
@@ -94,7 +98,7 @@ export type TickInfoMappingsWithBigNumber = {
   value: TickInfoWithBigNumber;
 };
 
-type DecodedGlobalStateV1_1 = {
+export type DecodedGlobalStateV1_1 = {
   price: BigNumber;
   tick: number;
   fee: number;

package/src/dex/algebra/utils.ts

@@ -1,11 +1,12 @@
-import { BytesLike, ethers } from 'ethers';
+import { BigNumber, BytesLike, ethers } from 'ethers';
 import { assert } from 'ts-essentials';
 import { extractSuccessAndValue } from '../../lib/decoders';
 import { MultiResult } from '../../lib/multi-wrapper';
 import {
-  DecodedGlobalStateV1_9,
+  DecodedGlobalStateV1_1,
   DecodedStateMultiCallResultWithRelativeBitmapsV1_1,
   DecodedStateMultiCallResultWithRelativeBitmapsV1_9,
+  TickInfoWithBigNumber,
 } from './types';
 
 export function decodeStateMultiCallResultWithRelativeBitmapsV1_1(
@@ -134,3 +135,83 @@ export function decodeStateMultiCallResultWithRelativeBitmapsV1_9(
   // But I typed only the ones that are used later
   return decoded as DecodedStateMultiCallResultWithRelativeBitmapsV1_9;
 }
+
+export function decodeGlobalStateV1_1(
+  result: MultiResult<BytesLike> | BytesLike,
+): DecodedGlobalStateV1_1 {
+  const [isSuccess, toDecode] = extractSuccessAndValue(result);
+
+  assert(
+    isSuccess && toDecode !== '0x',
+    `decodeGlobalStateV1_1 failed to get decodable result: ${result}`,
+  );
+
+  const results: DecodedGlobalStateV1_1 = {
+    price: BigNumber.from(0),
+    tick: 0,
+    fee: 0,
+    communityFeeToken0: 0,
+    communityFeeToken1: 0,
+  };
+
+  [
+    results.price,
+    results.tick,
+    results.fee,
+    ,
+    results.communityFeeToken0,
+    results.communityFeeToken1,
+  ] = ethers.utils.defaultAbiCoder.decode(
+    [`uint160`, `int24`, `uint16`, `uint16`, `uint8`, `uint8`, `bool`],
+    toDecode,
+  );
+  // This conversion is not precise, because when we decode, we have more values
+  // But used later
+  return results;
+}
+
+export function decodeTicksV1_1(
+  result: MultiResult<BytesLike> | BytesLike,
+): TickInfoWithBigNumber {
+  const [isSuccess, toDecode] = extractSuccessAndValue(result);
+
+  assert(
+    isSuccess && toDecode !== '0x',
+    `decodeGlobalStateV1_1 failed to get decodable result: ${result}`,
+  );
+
+  const results: TickInfoWithBigNumber = {
+    liquidityNet: BigNumber.from(0),
+    liquidityGross: BigNumber.from(0),
+    secondsOutside: 0,
+    secondsPerLiquidityOutsideX128: BigNumber.from(0),
+    tickCumulativeOutside: BigNumber.from(0),
+    initialized: false,
+  };
+
+  [
+    results.liquidityGross,
+    results.liquidityNet,
+    ,
+    ,
+    results.tickCumulativeOutside,
+    results.secondsPerLiquidityOutsideX128,
+    results.secondsOutside,
+    results.initialized,
+  ] = ethers.utils.defaultAbiCoder.decode(
+    [
+      `uint128`,
+      `int128`,
+      `uint256`,
+      `uint256`,
+      `int256`,
+      `uint160`,
+      `uint32`,
+      `bool`,
+    ],
+    toDecode,
+  );
+  // This conversion is not precise, because when we decode, we have more values
+  // But used later
+  return results;
+}

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

@@ -2,7 +2,11 @@ import dotenv from 'dotenv';
 dotenv.config();
 
 import { testE2E } from '../../../tests/utils-e2e';
-import { Holders, Tokens } from '../../../tests/constants-e2e';
+import {
+  Holders,
+  NativeTokenSymbols,
+  Tokens,
+} from '../../../tests/constants-e2e';
 import { ContractMethod, Network, SwapSide } from '../../constants';
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 
@@ -10,6 +14,99 @@ import { generateConfig } from '../../config';
 
 jest.setTimeout(50 * 1000);
 
+function testForNetwork(
+  network: Network,
+  dexKey: string,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+  nativeTokenAmount: string,
+  slippage?: number | undefined,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+  const nativeTokenSymbol = NativeTokenSymbols[network];
+
+  const sideToContractMethods = new Map([
+    [
+      SwapSide.SELL,
+      [
+        ContractMethod.simpleSwap,
+        ContractMethod.multiSwap,
+        ContractMethod.megaSwap,
+      ],
+    ],
+    [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+  ]);
+
+  describe(`${network}`, () => {
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          describe(`${contractMethod}`, () => {
+            it(`${nativeTokenSymbol} -> ${tokenASymbol}`, async () => {
+              await testE2E(
+                tokens[nativeTokenSymbol],
+                tokens[tokenASymbol],
+                holders[nativeTokenSymbol],
+                side === SwapSide.SELL ? nativeTokenAmount : tokenAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+            it(`${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[nativeTokenSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[tokenBSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+                undefined,
+                undefined,
+                undefined,
+                slippage,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
 describe('BalancerV2 E2E', () => {
   describe('BalancerV2 MAINNET', () => {
     const dexKey = 'BalancerV2';
@@ -96,6 +193,18 @@ describe('BalancerV2 E2E', () => {
               buyAmount: '10000000000',
             },
           ],
+          [
+            {
+              name: 'USDC',
+              sellAmount: '111000000',
+              buyAmount: '111000000',
+            },
+            {
+              name: 'wstETH',
+              sellAmount: '100000000000000000',
+              buyAmount: '100000000000000000',
+            },
+          ],
         ];
 
       sideToContractMethods.forEach((contractMethods, side) =>
@@ -1054,7 +1163,7 @@ describe('BalancerV2 E2E', () => {
               sellAmount: '200000000',
               buyAmount: '2000000000',
             },
-          ]
+          ],
         ];
 
       sideToContractMethods.forEach((contractMethods, side) =>
@@ -1137,7 +1246,7 @@ describe('BalancerV2 E2E', () => {
               sellAmount: '200000000',
               buyAmount: '2000000000000000',
             },
-          ]
+          ],
         ];
 
       sideToContractMethods.forEach((contractMethods, side) =>
@@ -1181,7 +1290,28 @@ describe('BalancerV2 E2E', () => {
         }),
       );
     });
+  });
+
+  describe('BalancerV2 Base', () => {
+    const dexKey = 'BalancerV2';
+    const network = Network.BASE;
+
+    const tokenASymbol: string = 'USDC';
+    const tokenBSymbol: string = 'GOLD';
 
+    const tokenAAmount: string = '11110010';
+    const tokenBAmount: string = '210000000000000000000';
+    const nativeTokenAmount = '1000000000000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+      nativeTokenAmount,
+    );
   });
 
   describe('BeetsFi OPTIMISM', () => {
@@ -1436,5 +1566,4 @@ describe('BalancerV2 E2E', () => {
       });
     });
   });
-
 });

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

@@ -72,6 +72,91 @@ import {
 } from './constants';
 import { NumberAsString, OptimalSwapExchange } from '@paraswap/core';
 
+// If you disable some pool, don't forget to clear the cache, otherwise changes won't be applied immediately
+const enabledPoolTypes = [
+  // BalancerPoolTypes.MetaStable, // BOOSTED POOLS Disabled since vulnerability https://github.com/BalancerMaxis/multisig-ops/blob/main/BIPs/00notGov/2023-08-mitigation.md
+  BalancerPoolTypes.Stable,
+  BalancerPoolTypes.Weighted,
+  BalancerPoolTypes.LiquidityBootstrapping,
+  BalancerPoolTypes.Investment,
+  BalancerPoolTypes.StablePhantom,
+  BalancerPoolTypes.AaveLinear,
+  BalancerPoolTypes.ERC4626Linear,
+  BalancerPoolTypes.Linear,
+  BalancerPoolTypes.ComposableStable,
+  BalancerPoolTypes.BeefyLinear,
+  BalancerPoolTypes.GearboxLinear,
+  BalancerPoolTypes.MidasLinear,
+  BalancerPoolTypes.ReaperLinear,
+  BalancerPoolTypes.SiloLinear,
+  BalancerPoolTypes.TetuLinear,
+  BalancerPoolTypes.YearnLinear,
+];
+
+const disabledPoolIds = [
+  // broken ?
+  '0xbd482ffb3e6e50dc1c437557c3bea2b68f3683ee0000000000000000000003c6',
+
+  /* DISABLED POOLS SINCE VULNERABILITY https://github.com/BalancerMaxis/multisig-ops/blob/main/BIPs/00notGov/2023-08-mitigation.md*/
+  /* START:2023-08-mitigation */
+  //mainnet
+  '0xbf2ef8bdc2fc0f3203b3a01778e3ec5009aeef3300000000000000000000058d',
+  '0x99c88ad7dc566616548adde8ed3effa730eb6c3400000000000000000000049a',
+  '0x60683b05e9a39e3509d8fdb9c959f23170f8a0fa000000000000000000000489',
+  '0xa13a9247ea42d743238089903570127dda72fe4400000000000000000000035d',
+  '0x7b50775383d3d6f0215a8f290f2c9e2eebbeceb20000000000000000000000fe',
+  '0x25accb7943fd73dda5e23ba6329085a3c24bfb6a000200000000000000000387',
+  '0x50cf90b954958480b8df7958a9e965752f62712400000000000000000000046f',
+  '0x133d241f225750d2c92948e464a5a80111920331000000000000000000000476',
+  '0x8a6b25e33b12d1bb6929a8793961076bd1f9d3eb0002000000000000000003e8',
+  '0x959216bb492b2efa72b15b7aacea5b5c984c3cca000200000000000000000472',
+  '0x9b692f571b256140a39a34676bffa30634c586e100000000000000000000059d',
+
+  // polygon
+  '0xb3d658d5b95bf04e2932370dd1ff976fe18dd66a000000000000000000000ace',
+  '0x48e6b98ef6329f8f0a30ebb8c7c960330d64808500000000000000000000075b',
+  '0xb54b2125b711cd183edd3dd09433439d5396165200000000000000000000075e',
+
+  // arbitrum
+  '0xa8af146d79ac0bb981e4e0d8b788ec5711b1d5d000000000000000000000047b',
+  '0x077794c30afeccdf5ad2abc0588e8cee7197b71a000000000000000000000352',
+  '0x519cce718fcd11ac09194cff4517f12d263be067000000000000000000000382',
+
+  // optimism
+  '0x23ca0306b21ea71552b148cf3c4db4fc85ae19290000000000000000000000ac',
+  '0x62cf35db540152e94936de63efc90d880d4e241b0000000000000000000000ef',
+  '0x098f32d98d0d64dba199fc1923d3bf4192e787190001000000000000000000d2',
+  '0x43da214fab3315aa6c02e0b8f2bfb7ef2e3c60a50000000000000000000000ae',
+  '0xb1c9ac57594e9b1ec0f3787d9f6744ef4cb0a02400000000000000000000006e',
+  '0xde45f101250f2ca1c0f8adfc172576d10c12072d00000000000000000000003f',
+  '0x05e7732bf9ae5592e6aa05afe8cd80f7ab0a7bea00020000000000000000005a',
+  '0x981fb05b738e981ac532a99e77170ecb4bc27aef00010000000000000000004b',
+  '0x6222ae1d2a9f6894da50aa25cb7b303497f9bebd000000000000000000000046',
+  '0x3c74c4ed512050eb843d89fb9dcd5ebb4668eb6d0002000000000000000000cc',
+
+  // fantom
+  '0xc0064b291bd3d4ba0e44ccfc81bf8e7f7a579cd200000000000000000000042c',
+  '0x6e6dc948ce85c62125ff7a1e543d761a88f0a4cb000000000000000000000743',
+  '0x78ab08bf98f90f29a09c9b1d85b3b549369b03a3000100000000000000000354',
+  '0x302b8b64795b064cadc32f74993a6372498608070001000000000000000003e0',
+  '0x5ddb92a5340fd0ead3987d3661afcd6104c3b757000000000000000000000187',
+  '0xdfc65c1f15ad3507754ef0fd4ba67060c108db7e000000000000000000000406',
+  '0x6da14f5acd58dd5c8e486cfa1dc1c550f5c61c1c0000000000000000000003cf',
+  '0x592fa9f9d58065096f2b7838709c116957d7b5cf00020000000000000000043c',
+  '0xf47f4d59c863c02cbfa3eefe6771b9c9fbe7b97800000000000000000000072b',
+  '0xff2753aaba51c9f84689b9bd0a21b3cf380a1cff00000000000000000000072e',
+  '0x10441785a928040b456a179691141c48356eb3a50001000000000000000002fa',
+  '0x64b301e21d640f9bef90458b0987d81fb4cf1b9e00020000000000000000022e',
+  '0xba0e9aea8a7fa1daab4edf244191f2387a4e472b000100000000000000000737',
+  '0x1e2576344d49779bdbb71b1b76193d27e6f996b700020000000000000000032d',
+  '0xa10285f445bcb521f1d623300dc4998b02f11c8f00000000000000000000043b',
+
+  // zkevm
+  '0x6f34a44fce1506352a171232163e7716dd073ade000200000000000000000015',
+  '0xe274c9deb6ed34cfe4130f8d0a8a948dea5bb28600000000000000000000000d',
+  /* END:2023-08-mitigation */
+];
+
 const fetchAllPools = `query ($count: Int) {
   pools: pools(
     first: $count
@@ -81,7 +166,7 @@ const fetchAllPools = `query ($count: Int) {
       totalLiquidity_gt: ${MIN_USD_LIQUIDITY_TO_FETCH.toString()},
       totalShares_not_in: ["0", "0.000000000001"],
       id_not_in: [
-        "0xbd482ffb3e6e50dc1c437557c3bea2b68f3683ee0000000000000000000003c6"
+        ${disabledPoolIds.map(p => `"${p}"`).join(', ')}
       ],
        address_not_in: [
         "0x0afbd58beca09545e4fb67772faf3858e610bcd0",
@@ -93,9 +178,7 @@ const fetchAllPools = `query ($count: Int) {
       ],
       swapEnabled: true,
       poolType_in: [
-        "MetaStable", "Stable", "Weighted", "LiquidityBootstrapping", "Investment", "StablePhantom", "AaveLinear",
-        "ERC4626Linear", "Linear", "ComposableStable", "BeefyLinear", "GearboxLinear", "MidasLinear",
-        "ReaperLinear", "SiloLinear", "TetuLinear", "YearnLinear"
+        ${enabledPoolTypes.map(p => `"${p}"`).join(', ')}
       ]
     }
   ) {
@@ -826,8 +909,6 @@ export class BalancerV2
             prices: resOut.prices,
             data: {
               poolId: pool.id,
-              tokenIn: _from.address.toLowerCase(),
-              tokenOut: _to.address.toLowerCase(),
             },
             poolAddresses: [poolAddress],
             exchange: this.dexKey,

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

@@ -23,7 +23,12 @@ export const BalancerConfig: DexConfigMap<DexParams> = {
       subgraphURL:
         'https://api.thegraph.com/subgraphs/name/balancer-labs/balancer-avalanche-v2',
       vaultAddress: '0xBA12222222228d8Ba445958a75a0704d566BF2C8',
-    }
+    },
+    [Network.BASE]: {
+      subgraphURL:
+        'https://api.studio.thegraph.com/query/24660/balancer-base-v2/version/latest',
+      vaultAddress: '0xBA12222222228d8Ba445958a75a0704d566BF2C8',
+    },
   },
   BeetsFi: {
     [Network.FANTOM]: {
@@ -71,5 +76,9 @@ export const Adapters: Record<number, AdapterMappings> = {
   [Network.AVALANCHE]: {
     [SwapSide.SELL]: [{ name: 'AvalancheAdapter01', index: 8 }],
     [SwapSide.BUY]: [{ name: 'AvalancheBuyAdapter', index: 7 }],
-  }
+  },
+  [Network.BASE]: {
+    [SwapSide.SELL]: [{ name: 'BaseAdapter01', index: 4 }],
+    [SwapSide.BUY]: [{ name: 'BaseBuyAdapter', index: 3 }],
+  },
 };