@paraswap/dex-lib 4.1.4-bal-v3-hooks.0 → 4.1.4

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,
-        };
-        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/fluid-dex/config.ts

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

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

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

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

@@ -4,46 +4,13 @@ dotenv.config();
 
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 import { testE2E } from '../../../tests/utils-e2e';
-import {
-  Tokens,
-  Holders,
-  NativeTokenSymbols,
-} from '../../../tests/constants-e2e';
+import { Tokens, Holders } from '../../../tests/constants-e2e';
 import { Network, ContractMethod, SwapSide } from '../../constants';
 import { generateConfig } from '../../config';
 import { CollateralReserves, DebtReserves, DexLimits } from './types';
 import { DummyDexHelper } from '../../dex-helper/index';
 import { FluidDex } from './fluid-dex';
 
-/*
-  README
-  ======
-
-  The template already enumerates the basic structure which involves
-  testing simpleSwap, multiSwap, megaSwap contract methods for
-  ETH <> TOKEN and TOKEN <> TOKEN swaps. You should replace tokenA and
-  tokenB with any two highly liquid tokens on FluidDex for the tests
-  to work. If the tokens that you would like to use are not defined in
-  Tokens or Holders map, you can update the './tests/constants-e2e'
-
-  Other than the standard cases that are already added by the template
-  it is highly recommended to add test cases which could be specific
-  to testing FluidDex (Eg. Tests based on poolType, special tokens,
-  etc).
-
-  You can run this individual test script by running:
-  `npx jest src/dex/<dex-name>/<dex-name>-e2e.test.ts`
-
-  e2e tests use the Tenderly fork api. Please add the following to your
-  .env file:
-  TENDERLY_TOKEN=Find this under Account>Settings>Authorization.
-  TENDERLY_ACCOUNT_ID=Your Tenderly account name.
-  TENDERLY_PROJECT=Name of a Tenderly project you have created in your
-  dashboard.
-
-  (This comment should be removed from the final implementation)
-*/
-
 function testForNetwork(
   network: Network,
   dexKey: string,
@@ -56,9 +23,14 @@ function testForNetwork(
     generateConfig(network).privateHttpProvider,
     network,
   );
+
   const tokens = Tokens[network];
   const holders = Holders[network];
 
+  // Create FluidDex instance to check reserves
+  const dexHelper = new DummyDexHelper(network);
+  const fluidDex = new FluidDex(network, dexKey, dexHelper);
+
   const sideToContractMethods = new Map([
     [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
     [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
@@ -69,11 +41,11 @@ function testForNetwork(
       describe(`${side}`, () => {
         contractMethods.forEach((contractMethod: string) => {
           describe(`${contractMethod}`, () => {
-            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+            it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
               await testE2E(
-                tokens[tokenASymbol],
                 tokens[tokenBSymbol],
-                holders[tokenASymbol],
+                tokens[tokenASymbol],
+                holders[tokenBSymbol],
                 tokenBAmount,
                 side,
                 dexKey,
@@ -82,12 +54,13 @@ function testForNetwork(
                 provider,
               );
             });
-            it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
+
+            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
               await testE2E(
-                tokens[tokenBSymbol],
                 tokens[tokenASymbol],
-                holders[tokenBSymbol],
-                tokenBAmount,
+                tokens[tokenBSymbol],
+                holders[tokenASymbol],
+                tokenAAmount,
                 side,
                 dexKey,
                 contractMethod as ContractMethod,
@@ -108,30 +81,11 @@ describe('FluidDex E2E', () => {
   describe('Mainnet', () => {
     const network = Network.MAINNET;
 
-    // TODO: Uncomment & test when the issue is resolved. Currently no price as expected.
-    // describe.only('FLUID -> ETH', () => {
-    //   const tokenASymbol: string = 'FLUID';
-    //   const tokenBSymbol: string = 'ETH';
-    //
-    //   const tokenAAmount: string = '160097047322810379';
-    //   const tokenBAmount: string = '79923068733005505624';
-    //
-    //   testForNetwork(
-    //     network,
-    //     dexKey,
-    //     tokenASymbol,
-    //     tokenBSymbol,
-    //     tokenAAmount,
-    //     tokenBAmount,
-    //   );
-    // });
-
-    describe('ETH -> INST', () => {
-      const tokenASymbol: string = 'ETH';
-      const tokenBSymbol: string = 'INST';
-
-      const tokenAAmount: string = '100000000000000';
-      const tokenBAmount: string = '100000000000000';
+    describe('limit:FLUID -> ETH', () => {
+      const tokenASymbol: string = 'FLUID';
+      const tokenBSymbol: string = 'ETH';
+      const tokenAAmount: string = '16009704732281037900';
+      const tokenBAmount: string = '7992306873300550562400';
 
       testForNetwork(
         network,
@@ -148,7 +102,7 @@ describe('FluidDex E2E', () => {
       const tokenBSymbol: string = 'ETH';
 
       const tokenAAmount: string = '100000000000000';
-      const tokenBAmount: string = '100000000000000';
+      const tokenBAmount: string = '3500000000000000000';
 
       testForNetwork(
         network,
@@ -237,6 +191,9 @@ function NewDebtReservesOne(): DebtReserves {
   };
 }
 
+const centerPriceTight: bigint = 3401944443797854601871360n;
+const centerPriceWide: bigint = 1190081051944310368000000000n;
+
 const limitsTight: DexLimits = {
   withdrawableToken0: {
     available: 456740438880263n,
@@ -283,10 +240,6 @@ const limitsWide: DexLimits = {
   },
 };
 
-const ErrInsufficientBorrowable = new Error('insufficient borrowable');
-const ErrInsufficientMaxPrice = new Error('insufficient max price');
-const ErrInsufficientReserve = new Error('insufficient reserve');
-
 describe('TestPoolSimulator_SwapInLimits', () => {
   const network = Network.MAINNET;
   const dexHelper = new DummyDexHelper(network);
@@ -295,21 +248,18 @@ describe('TestPoolSimulator_SwapInLimits', () => {
 
   it('when limits hit', () => {
     let outAmt;
-    try {
-      outAmt = fluidDex.swapInAdjusted(
-        true,
-        BigInt(1e15),
-        NewColReservesOne(),
-        NewDebtReservesOne(),
-        100n,
-        18,
-        limitsTight,
-        Math.floor(Date.now() / 1000) - 10,
-      );
-      expect(outAmt).toEqual(0n);
-    } catch (err: any) {
-      expect(err.message).toEqual(ErrInsufficientBorrowable.message);
-    }
+    outAmt = fluidDex.swapInAdjusted(
+      true,
+      BigInt(1e15),
+      NewColReservesOne(),
+      NewDebtReservesOne(),
+      100n,
+      18,
+      limitsTight,
+      BigInt(centerPriceTight),
+      Math.floor(Date.now() / 1000) - 10,
+    );
+    expect(outAmt).toEqual(0n);
   });
 
   it('when expanded', () => {
@@ -321,47 +271,41 @@ describe('TestPoolSimulator_SwapInLimits', () => {
       100n,
       18,
       limitsTight,
+      BigInt(centerPriceTight),
       Math.floor(Date.now() / 1000) - 6000,
     );
-    console.log('outAmt: ', outAmt);
-    expect(outAmt?.toString()).toEqual('998262697204710');
+    expect(outAmt?.toString()).toEqual('998163044346107');
   });
 
   it('when price diff hit', () => {
     let outAmt;
-    try {
-      outAmt = fluidDex.swapInAdjusted(
-        true,
-        BigInt(3e16),
-        NewColReservesOne(),
-        NewDebtReservesOne(),
-        100n,
-        18,
-        limitsWide,
-        Math.floor(Date.now() / 1000) - 10,
-      );
-      expect(outAmt).toEqual(0n);
-    } catch (err: any) {
-      expect(err.message).toEqual(ErrInsufficientMaxPrice.message);
-    }
+    outAmt = fluidDex.swapInAdjusted(
+      true,
+      BigInt(3e16),
+      NewColReservesOne(),
+      NewDebtReservesOne(),
+      100n,
+      18,
+      limitsWide,
+      BigInt(centerPriceWide),
+      Math.floor(Date.now() / 1000) - 10,
+    );
+    expect(outAmt).toEqual(0n);
   });
 
   it('when reserves limit is hit', () => {
     let outAmt;
-    try {
-      outAmt = fluidDex.swapInAdjusted(
-        true,
-        BigInt(5e16),
-        NewColReservesOne(),
-        NewDebtReservesOne(),
-        100n,
-        18,
-        limitsWide,
-        Math.floor(Date.now() / 1000) - 10,
-      );
-      expect(outAmt).toEqual(0n);
-    } catch (err: any) {
-      expect(err.message).toEqual(ErrInsufficientReserve.message);
-    }
+    outAmt = fluidDex.swapInAdjusted(
+      true,
+      BigInt(5e16),
+      NewColReservesOne(),
+      NewDebtReservesOne(),
+      100n,
+      18,
+      limitsWide,
+      BigInt(centerPriceWide),
+      Math.floor(Date.now() / 1000) - 10,
+    );
+    expect(outAmt).toEqual(0n);
   });
 });

package/src/dex/fluid-dex/fluid-dex-liquidity-proxy.ts

@@ -137,12 +137,14 @@ export class FluidDexLiquidityProxy extends StatefulEventSubscriber<FluidDexLiqu
         token0,
         token1,
         feeHex,
+        centerPriceHex,
         collateralReservesHex,
         debtReservesHex,
         dexLimitsHex,
       ] = poolReserve;
 
       const fee = Number(feeHex.toString());
+      const centerPrice = Number(centerPriceHex.toString());
 
       const collateralReserves = {
         token0RealReserves: bigIntify(collateralReservesHex[0]),
@@ -196,6 +198,7 @@ export class FluidDexLiquidityProxy extends StatefulEventSubscriber<FluidDexLiqu
         token0,
         token1,
         fee,
+        centerPrice,
         collateralReserves,
         debtReserves,
         dexLimits,