@paraswap/dex-lib 4.1.6 → 4.1.7-mwrappedm.0

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

@@ -25,69 +25,18 @@ export const BalancerV3Config: DexConfigMap<DexParams> = {
       apiNetworkName: 'SEPOLIA',
       balancerRouterAddress: '0x0BF61f706105EA44694f2e92986bD01C39930280',
       balancerBatchRouterAddress: '0xC85b652685567C1B074e8c0D4389f83a2E458b1C',
-      hooks: [
-        {
-          type: 'DirectionalFee',
-          address: '0xd68372e85d8a14afa5fdb3d506bf765939aaf382',
-        },
-        {
-          type: 'StableSurge',
-          factory: '0x9eB9867C1d4B6fd3a7D0dAd3101b5A153b1107Ec', // Pools with StableSurge hook will always be deployed from this factory
-          address: '0xc0cbcdd6b823a4f22aa6bbdde44c17e754266aef', // Address of the hook that will be used by pools
-        },
-      ],
     },
     [Network.GNOSIS]: {
       vaultAddress: '0xbA1333333333a1BA1108E8412f11850A5C319bA9',
       apiNetworkName: 'GNOSIS',
       balancerRouterAddress: '0x84813aA3e079A665C0B80F944427eE83cBA63617',
       balancerBatchRouterAddress: '0xe2fa4e1d17725e72dcdAfe943Ecf45dF4B9E285b',
-      hooks: [
-        {
-          type: 'StableSurge',
-          factory: '0x268E2EE1413D768b6e2dc3F5a4ddc9Ae03d9AF42', // Pools with StableSurge hook will always be deployed from this factory
-          address: '0xe4f1878eC9710846E2B529C1b5037F8bA94583b1', // Address of the hook that will be used by pools
-        },
-      ],
     },
     [Network.MAINNET]: {
       vaultAddress: '0xbA1333333333a1BA1108E8412f11850A5C319bA9',
       apiNetworkName: 'MAINNET',
       balancerRouterAddress: '0x5C6fb490BDFD3246EB0bB062c168DeCAF4bD9FDd',
       balancerBatchRouterAddress: '0x136f1EFcC3f8f88516B9E94110D56FDBfB1778d1',
-      hooks: [
-        {
-          type: 'StableSurge',
-          factory: '0xD53F5d8d926fb2a0f7Be614B16e649B8aC102D83', // Pools with StableSurge hook will always be deployed from this factory
-          address: '0xb18fA0cb5DE8cecB8899AAE6e38b1B7ed77885dA', // Address of the hook that will be used by pools
-        },
-      ],
-    },
-    [Network.ARBITRUM]: {
-      vaultAddress: '0xbA1333333333a1BA1108E8412f11850A5C319bA9',
-      apiNetworkName: 'ARBITRUM',
-      balancerRouterAddress: '0x0f08eEf2C785AA5e7539684aF04755dEC1347b7c',
-      balancerBatchRouterAddress: '0xaD89051bEd8d96f045E8912aE1672c6C0bF8a85E',
-      hooks: [
-        {
-          type: 'StableSurge',
-          factory: '0x86e67E115f96DF37239E0479441303De0de7bc2b', // Pools with StableSurge hook will always be deployed from this factory
-          address: '0x0Fa0f9990D7969a7aE6f9961d663E4A201Ed6417', // Address of the hook that will be used by pools
-        },
-      ],
-    },
-    [Network.BASE]: {
-      vaultAddress: '0xbA1333333333a1BA1108E8412f11850A5C319bA9',
-      apiNetworkName: 'BASE',
-      balancerRouterAddress: '0x76578ecf9a141296Ec657847fb45B0585bCDa3a6',
-      balancerBatchRouterAddress: '0x85a80afee867aDf27B50BdB7b76DA70f1E853062',
-      hooks: [
-        {
-          type: 'StableSurge',
-          factory: '0x4fb47126Fa83A8734991E41B942Ac29A3266C968', // Pools with StableSurge hook will always be deployed from this factory
-          address: '0xb2007B8B7E0260042517f635CFd8E6dD2Dd7f007', // Address of the hook that will be used by pools
-        },
-      ],
     },
   },
 };

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

@@ -10,7 +10,7 @@ import { Interface, Result } from '@ethersproject/abi';
 import { IDexHelper } from '../../dex-helper';
 import { WAD } from './balancer-v3-pool';
 
-export interface callData {
+interface callData {
   target: string;
   callData: string;
 }
@@ -161,6 +161,9 @@ const poolOnChain: Record<
           (r: string) => BigInt(r),
         ),
         isPoolPaused: resultIsPoolPaused[0],
+        hasHook:
+          resultHooksConfig[0].hooksContract !==
+          '0x0000000000000000000000000000000000000000',
       };
     },
   },

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

@@ -7,7 +7,6 @@ import {
 } from './config';
 import { CommonImmutablePoolState, ImmutablePoolStateMap } from './types';
 import { parseUnits } from 'ethers/lib/utils';
-import { HooksConfigMap } from './hooks/balancer-hook-event-subscriber';
 
 interface PoolToken {
   address: string;
@@ -22,9 +21,6 @@ interface Pool {
   id: string;
   type: string;
   poolTokens: PoolToken[];
-  hook: {
-    address: string;
-  } | null;
 }
 
 interface QueryResponse {
@@ -48,6 +44,7 @@ function createQuery(
   const whereClause = {
     chainIn: networkString,
     protocolVersionIn: 3,
+    hasHook: false,
     poolTypeIn: `[${poolTypesString}]`,
     ...(timestamp && { createTime: `{lt: ${timestamp}}` }),
     ...(disabledPoolIdsString && { idNotIn: `[${disabledPoolIdsString}]` }),
@@ -72,53 +69,37 @@ function createQuery(
             address
           }
         }
-        hook {
-          address
-        }
       }
     }
   `;
 }
 
-function toImmutablePoolStateMap(
-  pools: Pool[],
-  hooksConfigMap: HooksConfigMap,
-): ImmutablePoolStateMap {
-  return (
-    pools
-      // First filter out pools with hooks that aren't in hooksMap
-      .filter(
-        pool =>
-          !pool.hook ||
-          (pool.hook && pool.hook.address.toLowerCase() in hooksConfigMap),
-      )
-      .reduce((map, pool) => {
-        const immutablePoolState: CommonImmutablePoolState = {
-          poolAddress: pool.id,
-          tokens: pool.poolTokens.map(t => t.address),
-          tokensUnderlying: pool.poolTokens.map(t =>
-            t.underlyingToken ? t.underlyingToken.address : null,
-          ),
-          weights: pool.poolTokens.map(t =>
-            t.weight ? parseUnits(t.weight, 18).toBigInt() : 0n,
-          ),
-          poolType: pool.type,
-          hookAddress: pool.hook ? pool.hook.address.toLowerCase() : undefined,
-          hookType: pool.hook
-            ? hooksConfigMap[pool.hook.address.toLowerCase()].type
-            : undefined,
-          supportsUnbalancedLiquidity: true, // can default to true as only required for add/remove maths which we don't use
-        };
-        map[pool.id] = immutablePoolState;
-        return map;
-      }, {} as ImmutablePoolStateMap)
-  );
+function toImmutablePoolStateMap(pools: Pool[]): ImmutablePoolStateMap {
+  return pools.reduce((map, pool) => {
+    const immutablePoolState: CommonImmutablePoolState = {
+      poolAddress: pool.id,
+      tokens: pool.poolTokens.map(t => t.address),
+      tokensUnderlying: pool.poolTokens.map(t =>
+        t.underlyingToken ? t.underlyingToken.address : null,
+      ),
+      weights: pool.poolTokens.map(t =>
+        t.weight ? parseUnits(t.weight, 18).toBigInt() : 0n,
+      ),
+      poolType: pool.type,
+      // TODO add scalingFactors once API provides them
+      // scalingFactors: pool.poolTokens.map(t => parseUnits('1', 18).toBigInt()),
+      // TODO Hook support will be added in future PR
+      hookType: undefined,
+    };
+
+    map[pool.id] = immutablePoolState;
+    return map;
+  }, {} as ImmutablePoolStateMap);
 }
 
 // Any data from API will be immutable. Mutable data such as balances, etc will be fetched via onchain/event state.
 export async function getPoolsApi(
   network: number,
-  hooksConfigMap: HooksConfigMap,
   timestamp?: number,
 ): Promise<ImmutablePoolStateMap> {
   try {
@@ -140,7 +121,7 @@ export async function getPoolsApi(
     );
 
     const pools = response.data.data.poolGetAggregatorPools;
-    return toImmutablePoolStateMap(pools, hooksConfigMap);
+    return toImmutablePoolStateMap(pools);
   } catch (error) {
     // console.error('Error executing GraphQL query:', error);
     throw error;

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

@@ -1,6 +1,5 @@
 import axios from 'axios';
 import { apiUrl, BalancerV3Config, disabledPoolIds } from './config';
-import { HooksConfigMap } from './hooks/balancer-hook-event-subscriber';
 
 interface PoolToken {
   address: string;
@@ -17,9 +16,6 @@ export interface Pool {
   dynamicData: {
     totalLiquidity: string;
   };
-  hook: {
-    address: string;
-  } | null;
 }
 
 interface QueryResponse {
@@ -43,6 +39,7 @@ function createQuery(
   const whereClause = {
     chainIn: networkString,
     protocolVersionIn: 3,
+    hasHook: false,
     idIn: `[${poolIdString}]`,
     ...(disabledPoolIdsString && { idNotIn: `[${disabledPoolIdsString}]` }),
   };
@@ -71,9 +68,6 @@ function createQuery(
         dynamicData {
           totalLiquidity
         }
-        hook {
-          address
-        }
       }
     }
   `;
@@ -83,7 +77,6 @@ export async function getTopPoolsApi(
   networkId: number,
   poolsFilter: string[],
   count: number,
-  hooksTypeMap: HooksConfigMap,
 ): Promise<Pool[]> {
   try {
     const query = createQuery(networkId, poolsFilter, count);
@@ -99,11 +92,7 @@ export async function getTopPoolsApi(
       },
     );
 
-    const pools = response.data.data.poolGetAggregatorPools.filter(
-      pool =>
-        !pool.hook ||
-        (pool.hook && pool.hook.address.toLowerCase() in hooksTypeMap),
-    );
+    const pools = response.data.data.poolGetAggregatorPools;
     return pools;
   } catch (error) {
     // console.error('Error executing GraphQL query:', error);

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

@@ -1,6 +1,5 @@
 import { BufferState } from '@balancer-labs/balancer-maths';
 import { Address } from '../../types';
-import { HookConfig } from './hooks/balancer-hook-event-subscriber';
 
 // Immutable data types available on all pools (Available from API)
 export type CommonImmutablePoolState = {
@@ -13,9 +12,7 @@ export type CommonImmutablePoolState = {
   weights: bigint[];
   // TODO re-introduce this once added to API
   // scalingFactors: bigint[];
-  hookAddress: string | undefined;
   hookType: string | undefined;
-  supportsUnbalancedLiquidity: boolean;
 };
 
 // Mutable data types available on all pools (Available via onchain calls/events)
@@ -29,6 +26,8 @@ export interface CommonMutableState {
   isPoolPaused: boolean;
   // TODO remove this once API provides it
   scalingFactors: bigint[];
+  // TODO remove this once API provides it
+  hasHook: boolean;
 }
 
 type CommonPoolState = CommonImmutablePoolState & CommonMutableState;
@@ -77,7 +76,6 @@ export type DexParams = {
   // https://github.com/balancer/balancer-v3-monorepo/blob/main/pkg/interfaces/contracts/vault/IRouter.sol
   balancerRouterAddress: string;
   balancerBatchRouterAddress: string;
-  hooks?: HookConfig[];
 };
 
 export type TokenInfo = {

package/src/dex/cables/cables-e2e.test.ts

@@ -14,7 +14,7 @@ describe('Cables E2E', () => {
 
   const sideToContractMethods = new Map([
     [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
-    // [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
+    [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
   ]);
 
   describe('Arbitrum', () => {
@@ -30,7 +30,7 @@ describe('Cables E2E', () => {
       [
         {
           name: 'USDC',
-          sellAmount: '50000000000000',
+          sellAmount: '500000',
           buyAmount: '700000',
         },
         {
@@ -39,18 +39,18 @@ describe('Cables E2E', () => {
           buyAmount: '850000',
         },
       ],
-      // [
-      //   {
-      //     name: 'WETH',
-      //     sellAmount: '100000000000000000',
-      //     buyAmount: '200000000000000000',
-      //   },
-      //   {
-      //     name: 'USDT',
-      //     sellAmount: '6000000',
-      //     buyAmount: '8000000',
-      //   },
-      // ],
+      [
+        {
+          name: 'WETH',
+          sellAmount: '100000000000000000',
+          buyAmount: '200000000000000000',
+        },
+        {
+          name: 'USDT',
+          sellAmount: '6000000',
+          buyAmount: '8000000',
+        },
+      ],
     ];
 
     sideToContractMethods.forEach((contractMethods, side) =>
@@ -84,32 +84,32 @@ describe('Cables E2E', () => {
                   sleepMs,
                 );
               });
-              // it(`${pair[1].name} -> ${pair[0].name}`, async () => {
-              //   await testE2E(
-              //     side === SwapSide.SELL
-              //       ? tokens[pair[1].name]
-              //       : tokens[pair[0].name],
-              //     side === SwapSide.SELL
-              //       ? tokens[pair[0].name]
-              //       : tokens[pair[1].name],
-              //     side === SwapSide.SELL
-              //       ? holders[pair[1].name]
-              //       : holders[pair[0].name],
-              //     side === SwapSide.SELL
-              //       ? pair[1].sellAmount
-              //       : pair[1].buyAmount,
-              //     side,
-              //     dexKey,
-              //     contractMethod,
-              //     network,
-              //     provider,
-              //     undefined,
-              //     undefined,
-              //     undefined,
-              //     slippage,
-              //     sleepMs,
-              //   );
-              // });
+              it(`${pair[1].name} -> ${pair[0].name}`, async () => {
+                await testE2E(
+                  side === SwapSide.SELL
+                    ? tokens[pair[1].name]
+                    : tokens[pair[0].name],
+                  side === SwapSide.SELL
+                    ? tokens[pair[0].name]
+                    : tokens[pair[1].name],
+                  side === SwapSide.SELL
+                    ? holders[pair[1].name]
+                    : holders[pair[0].name],
+                  side === SwapSide.SELL
+                    ? pair[1].sellAmount
+                    : pair[1].buyAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                  undefined,
+                  undefined,
+                  undefined,
+                  slippage,
+                  sleepMs,
+                );
+              });
             });
           });
         });

package/src/dex/cables/cables.ts

@@ -399,15 +399,11 @@ export class Cables extends SimpleExchange implements IDex<any> {
       let decimals = baseToken.decimals;
       let out_decimals = quoteToken.decimals;
 
-      let price = 0;
-
-      try {
-        price = this.calculatePriceSwap(
-          orderbook,
-          Number(amt) / 10 ** decimals,
-          isInputQuote,
-        );
-      } catch {}
+      let price = this.calculatePriceSwap(
+        orderbook,
+        Number(amt) / 10 ** decimals,
+        isInputQuote,
+      );
       result.push(BigInt(Math.round(price * 10 ** out_decimals)));
     }
     return result;
@@ -420,17 +416,11 @@ export class Cables extends SimpleExchange implements IDex<any> {
   ) {
     let sumBaseQty = 0;
     let sumQuoteQty = 0;
-
     const selectedRows: string[][] = [];
 
     const isBase = qtyMode;
     const isQuote = !qtyMode;
 
-    const totalVolume: number = prices.reduce(
-      (sum, [, volume]) => sum + Number(volume),
-      0,
-    );
-
     for (const [price, volume] of prices) {
       if (isBase) {
         if (sumBaseQty >= requiredQty) {
@@ -470,10 +460,6 @@ export class Cables extends SimpleExchange implements IDex<any> {
       selectedRows.push([price, currentBaseQty.toString()]);
     }
 
-    if (sumBaseQty == 0) {
-      return 0;
-    }
-
     const vSumBase = selectedRows.reduce((sum: number, [price, volume]) => {
       return sum + Number(price) * Number(volume);
     }, 0);
@@ -482,24 +468,11 @@ export class Cables extends SimpleExchange implements IDex<any> {
       .dividedBy(new BigNumber(sumBaseQty))
       .toNumber();
 
-    let result: any;
     if (isBase) {
-      result = requiredQty / price;
+      return requiredQty / price;
     } else {
-      result = requiredQty * price;
+      return requiredQty * price;
     }
-
-    if (isQuote) {
-      if (requiredQty > totalVolume) {
-        result = 0;
-      }
-    } else {
-      if (result > totalVolume) {
-        result = 0;
-      }
-    }
-
-    return result;
   }
 
   async getPricesVolume(
@@ -565,10 +538,10 @@ export class Cables extends SimpleExchange implements IDex<any> {
       const priceData = priceMap[pairKey];
 
       let orderbook: any[] = [];
-      orderbook = priceData.bids;
-      // reverse orderbook if isInputQuote
-      if (isInputQuote) {
+      if (side === SwapSide.BUY) {
         orderbook = priceData.asks;
+      } else {
+        orderbook = priceData.bids;
       }
       if (orderbook?.length === 0) {
         throw new Error(`Empty orderbook for ${pairKey}`);

package/src/dex/fluid-dex/config.ts

@@ -7,14 +7,14 @@ export const FluidDexConfig: DexConfigMap<DexParams> = {
     [Network.MAINNET]: {
       commonAddresses: {
         liquidityProxy: '0x52aa899454998be5b000ad077a46bbe360f4e497',
-        resolver: '0xb387f9C2092cF7c4943F97842887eBff7AE96EB3',
+        resolver: '0x45f4ad57e300da55c33dea579a40fcee000d7b94',
         dexFactory: '0x91716C4EDA1Fb55e84Bf8b4c7085f84285c19085',
       },
     },
     [Network.ARBITRUM]: {
       commonAddresses: {
         liquidityProxy: '0x52Aa899454998Be5b000Ad077a46Bbe360F4e497',
-        resolver: '0xCe6F4E40152a1DF97ae95a7e4F60D944871A4060',
+        resolver: '0xb8f526718FF58758E256D9aD86bC194a9ff5986D',
         dexFactory: '0x91716C4EDA1Fb55e84Bf8b4c7085f84285c19085',
       },
     },

package/src/dex/fluid-dex/constants.ts

@@ -1,2 +1 @@
-// on-chain we use 1e4 but use extra buffer to avoid reverts
-export const MIN_SWAP_LIQUIDITY = 8500n;
+export const MIN_SWAP_LIQUIDITY = 10n ** 4n;