@paraswap/dex-lib 4.1.19 → 4.1.20

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

@@ -86,7 +86,10 @@ const poolOnChain: Record<
       poolAddress: string,
       data: any,
       startIndex: number,
-    ): Omit<CommonMutableState, 'erc4626Rates'> => {
+    ): Omit<
+      CommonMutableState,
+      'erc4626Rates' | 'erc4626MaxDeposit' | 'erc4626MaxMint'
+    > => {
       const resultTokenRates = decodeThrowError(
         contractInterface,
         'getPoolTokenRates',
@@ -241,6 +244,26 @@ const poolOnChain: Record<
       };
     },
   },
+  // nothing to encode/decode for this pool
+  // as all of the values are immutable and returned from the API
+  ['GYROE']: {
+    count: 0,
+    ['encode']: (
+      network: number,
+      contractInterface: Interface,
+      address: string,
+    ): callData[] => {
+      return [];
+    },
+    ['decode']: (
+      contractInterface: Interface,
+      poolAddress: string,
+      data: any,
+      startIndex: number,
+    ) => {
+      return {};
+    },
+  },
 };
 
 export function decodeThrowError(
@@ -271,12 +294,30 @@ export function getErc4626MultiCallData(
   );
 
   // 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]),
-    };
-  });
+  const erc4626MultiCallData: callData[] = uniqueErc4626Tokens.flatMap(
+    token => {
+      return [
+        {
+          target: token,
+          callData: erc4626Interface.encodeFunctionData('convertToAssets', [
+            WAD,
+          ]),
+        },
+        {
+          target: token,
+          callData: erc4626Interface.encodeFunctionData('maxDeposit', [
+            '0x0000000000000000000000000000000000000000',
+          ]),
+        },
+        {
+          target: token,
+          callData: erc4626Interface.encodeFunctionData('maxMint', [
+            '0x0000000000000000000000000000000000000000',
+          ]),
+        },
+      ];
+    },
+  );
   return erc4626MultiCallData;
 }
 
@@ -285,12 +326,22 @@ export function decodeErc4626MultiCallData(
   erc4626MultiCallData: callData[],
   dataResultErc4626: any[],
 ) {
+  // We only need to process third of the erc4626MultiCallData entries
+  // since each entry corresponds to three results
+  const thirdLength = Math.floor(erc4626MultiCallData.length / 3);
+
   return Object.fromEntries(
-    erc4626MultiCallData.map((multiCallData, i) => {
+    Array.from({ length: thirdLength }).map((_, i) => {
+      const rateIndex = i * 3;
+      const maxDepositIndex = i * 3 + 1;
+      const maxMintIndex = i * 3 + 2;
+      const multiCallData = erc4626MultiCallData[rateIndex];
+
+      // Decode convertToAssets
       const rate = decodeThrowError(
         erc4626Interface,
         'convertToAssets',
-        dataResultErc4626[i],
+        dataResultErc4626[rateIndex],
         multiCallData.target,
       );
       if (!rate)
@@ -298,11 +349,41 @@ export function decodeErc4626MultiCallData(
           `Failed to get result for convertToAssets for ${multiCallData.target}`,
         );
 
-      return [multiCallData.target, BigInt(rate[0])];
+      // Decode maxDeposit
+      const maxDeposit = decodeThrowError(
+        erc4626Interface,
+        'maxDeposit',
+        dataResultErc4626[maxDepositIndex],
+        multiCallData.target,
+      );
+      if (!maxDeposit)
+        throw new Error(
+          `Failed to get result for maxDeposit for ${multiCallData.target}`,
+        );
+
+      // Decode maxMint
+      const maxMint = decodeThrowError(
+        erc4626Interface,
+        'maxMint',
+        dataResultErc4626[maxMintIndex],
+        multiCallData.target,
+      );
+      if (!maxMint)
+        throw new Error(
+          `Failed to get result for maxMint for ${multiCallData.target}`,
+        );
+
+      return [
+        multiCallData.target,
+        {
+          rate: BigInt(rate[0]),
+          maxDeposit: BigInt(maxDeposit[0]),
+          maxMint: BigInt(maxMint[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,
@@ -387,7 +468,15 @@ export async function getOnChainState(
           ...poolMutableData,
           erc4626Rates: pool.tokens.map(t => {
             if (!tokensWithRates[t]) return null;
-            return tokensWithRates[t];
+            return tokensWithRates[t].rate;
+          }),
+          erc4626MaxDeposit: pool.tokens.map(t => {
+            if (!tokensWithRates[t]) return null;
+            return tokensWithRates[t].maxDeposit;
+          }),
+          erc4626MaxMint: pool.tokens.map(t => {
+            if (!tokensWithRates[t]) return null;
+            return tokensWithRates[t].maxMint;
           }),
         },
       ];

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

@@ -8,34 +8,36 @@ import {
 import { CommonImmutablePoolState, ImmutablePoolStateMap } from './types';
 import { parseUnits } from 'ethers/lib/utils';
 import { HooksConfigMap } from './hooks/balancer-hook-event-subscriber';
-
+import { getUniqueHookNames } from './utils';
+import { GyroECLPImmutableString } from './gyroECLPPool';
 interface PoolToken {
   address: string;
   weight: string | null;
-  isErc4626: boolean;
+  canUseBufferForSwaps: boolean | null;
   underlyingToken: {
     address: string;
   } | null;
 }
 
-interface Pool {
+type Pool = {
   id: string;
   type: string;
   poolTokens: PoolToken[];
   hook: {
     address: string;
   } | null;
-}
+} & GyroECLPImmutableString;
 
 interface QueryResponse {
   data: {
-    poolGetAggregatorPools: Pool[];
+    aggregatorPools: Pool[];
   };
 }
 
 function createQuery(
   networkId: number,
   poolTypes: SUPPORTED_POOLS[],
+  hooks: string,
   timestamp?: number,
 ): string {
   const poolTypesString = poolTypes.map(type => `${type}`).join(', ');
@@ -51,6 +53,7 @@ function createQuery(
     poolTypeIn: `[${poolTypesString}]`,
     ...(timestamp && { createTime: `{lt: ${timestamp}}` }),
     ...(disabledPoolIdsString && { idNotIn: `[${disabledPoolIdsString}]` }),
+    includeHooks: `[${hooks}]`,
   };
 
   // Convert where clause to string, filtering out undefined values
@@ -59,7 +62,7 @@ function createQuery(
     .join(', ');
   return `
     query MyQuery {
-      poolGetAggregatorPools(
+      aggregatorPools(
         where: {${whereString}}
       ) {
         id
@@ -67,7 +70,7 @@ function createQuery(
         poolTokens {
           address
           weight
-          isErc4626
+          canUseBufferForSwaps
           underlyingToken {
             address
           }
@@ -75,6 +78,20 @@ function createQuery(
         hook {
           address
         }
+        alpha
+        beta
+        c
+        s
+        lambda
+        tauAlphaX
+        tauAlphaY
+        tauBetaX
+        tauBetaY
+        u
+        v
+        w
+        z
+        dSq
       }
     }
   `;
@@ -97,17 +114,34 @@ function toImmutablePoolStateMap(
           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,
+            t.underlyingToken && t.canUseBufferForSwaps
+              ? t.underlyingToken.address
+              : null,
           ),
+          weights: pool.poolTokens.map(t => scaleOrDefault(t.weight, 18, 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
+          // GyroECLP
+          // Parameters to configure the E-CLP pool, with 18 decimals
+          paramsAlpha: scaleOrDefault(pool.alpha, 18, 0n),
+          paramsBeta: scaleOrDefault(pool.beta, 18, 0n),
+          paramsC: scaleOrDefault(pool.c, 18, 0n),
+          paramsS: scaleOrDefault(pool.s, 18, 0n),
+          paramsLambda: scaleOrDefault(pool.lambda, 18, 0n),
+          // Parameters calculated off-chain based on eclpParams. 38 decimals for higher precision
+          tauAlphaX: scaleOrDefault(pool.tauAlphaX, 38, 0n),
+          tauAlphaY: scaleOrDefault(pool.tauAlphaY, 38, 0n),
+          tauBetaX: scaleOrDefault(pool.tauBetaX, 38, 0n),
+          tauBetaY: scaleOrDefault(pool.tauBetaY, 38, 0n),
+          u: scaleOrDefault(pool.u, 38, 0n),
+          v: scaleOrDefault(pool.v, 38, 0n),
+          w: scaleOrDefault(pool.w, 38, 0n),
+          z: scaleOrDefault(pool.z, 38, 0n),
+          dSq: scaleOrDefault(pool.dSq, 38, 0n),
         };
         map[pool.id] = immutablePoolState;
         return map;
@@ -115,6 +149,14 @@ function toImmutablePoolStateMap(
   );
 }
 
+function scaleOrDefault(
+  original: string | null,
+  decimals: number,
+  defaultValue: bigint,
+): bigint {
+  return original ? parseUnits(original, decimals).toBigInt() : defaultValue;
+}
+
 // 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,
@@ -125,6 +167,7 @@ export async function getPoolsApi(
     const query = createQuery(
       network,
       Object.values(SUPPORTED_POOLS),
+      getUniqueHookNames(hooksConfigMap),
       timestamp,
     );
     const response = await axios.post<QueryResponse>(
@@ -139,7 +182,7 @@ export async function getPoolsApi(
       },
     );
 
-    const pools = response.data.data.poolGetAggregatorPools;
+    const pools = response.data.data.aggregatorPools;
     return toImmutablePoolStateMap(pools, hooksConfigMap);
   } catch (error) {
     // console.error('Error executing GraphQL query:', error);

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

@@ -1,14 +1,16 @@
 import axios from 'axios';
 import { apiUrl, BalancerV3Config, disabledPoolIds } from './config';
 import { HooksConfigMap } from './hooks/balancer-hook-event-subscriber';
+import { getUniqueHookNames } from './utils';
 
 interface PoolToken {
   address: string;
   decimals: number;
-  underlyingToken?: {
+  canUseBufferForSwaps: boolean | null;
+  underlyingToken: {
     address: string;
     decimals: number;
-  };
+  } | null;
 }
 
 export interface Pool {
@@ -24,13 +26,14 @@ export interface Pool {
 
 interface QueryResponse {
   data: {
-    poolGetAggregatorPools: Pool[];
+    aggregatorPools: Pool[];
   };
 }
 
 function createQuery(
   networkId: number,
   poolsFilter: string[],
+  hooks: string,
   count: number,
 ): string {
   const disabledPoolIdsString = disabledPoolIds.BalancerV3[networkId]
@@ -45,6 +48,7 @@ function createQuery(
     protocolVersionIn: 3,
     idIn: `[${poolIdString}]`,
     ...(disabledPoolIdsString && { idNotIn: `[${disabledPoolIdsString}]` }),
+    includeHooks: `[${hooks}]`,
   };
 
   // Convert where clause to string, filtering out undefined values
@@ -53,7 +57,7 @@ function createQuery(
     .join(', ');
   return `
     query MyQuery {
-      poolGetAggregatorPools(
+      aggregatorPools(
         where: {${whereString}}
         first: ${count}
         orderBy: totalLiquidity
@@ -63,6 +67,7 @@ function createQuery(
         poolTokens {
           address
           decimals
+          canUseBufferForSwaps
           underlyingToken {
             address
             decimals
@@ -83,10 +88,15 @@ export async function getTopPoolsApi(
   networkId: number,
   poolsFilter: string[],
   count: number,
-  hooksTypeMap: HooksConfigMap,
+  hooksConfigMap: HooksConfigMap,
 ): Promise<Pool[]> {
   try {
-    const query = createQuery(networkId, poolsFilter, count);
+    const query = createQuery(
+      networkId,
+      poolsFilter,
+      getUniqueHookNames(hooksConfigMap),
+      count,
+    );
     const response = await axios.post<QueryResponse>(
       apiUrl,
       {
@@ -99,11 +109,19 @@ 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.aggregatorPools
+      .filter(
+        pool =>
+          !pool.hook ||
+          (pool.hook && pool.hook.address.toLowerCase() in hooksConfigMap),
+      )
+      .map(pool => ({
+        ...pool,
+        poolTokens: pool.poolTokens.map(t => ({
+          ...t,
+          underlyingToken: t.canUseBufferForSwaps ? t.underlyingToken : null,
+        })),
+      }));
     return pools;
   } catch (error) {
     // console.error('Error executing GraphQL query:', error);

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

@@ -0,0 +1,17 @@
+import { GyroECLPImmutable } from '@balancer-labs/balancer-maths';
+
+// https://sepolia.etherscan.io/tx/0x222800381cfc60b6af18c0f533149b6a3b4cda6c05aafb92cfbac42eb281bf76
+export const GYROECLP_GAS_COST = 214120;
+
+export type GyroECLPImmutableString = {
+  [K in keyof Omit<
+    GyroECLPImmutable,
+    'paramsAlpha' | 'paramsBeta' | 'paramsC' | 'paramsS' | 'paramsLambda'
+  >]: string;
+} & {
+  alpha: string;
+  beta: string;
+  c: string;
+  s: string;
+  lambda: string;
+};

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

@@ -8,10 +8,12 @@ import { HookStateMap } from './balancer-hook-event-subscriber';
 
 export const DirectionalFee = {
   type: 'DirectionalFee' as const,
+  apiName: 'DIRECTIONAL_FEE' as const,
 };
 
 export type DirectionalFeeConfig = {
   type: typeof DirectionalFee.type;
+  apiName: typeof DirectionalFee.apiName;
   address: string;
 };
 

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

@@ -10,10 +10,12 @@ import { Logger } from 'log4js';
 
 export const StableSurge = {
   type: 'StableSurge' as const,
+  apiName: 'STABLE_SURGE' as const,
 };
 
 export type StableSurgeConfig = {
   type: typeof StableSurge.type;
+  apiName: typeof StableSurge.apiName;
   factory: string;
   address: string;
 };

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

@@ -1,4 +1,4 @@
-import { BufferState } from '@balancer-labs/balancer-maths';
+import { BufferState, GyroECLPImmutable } from '@balancer-labs/balancer-maths';
 import { Address } from '../../types';
 import { HookConfig } from './hooks/balancer-hook-event-subscriber';
 
@@ -16,12 +16,14 @@ export type CommonImmutablePoolState = {
   hookAddress: string | undefined;
   hookType: string | undefined;
   supportsUnbalancedLiquidity: boolean;
-};
+} & GyroECLPImmutable;
 
 // Mutable data types available on all pools (Available via onchain calls/events)
 export interface CommonMutableState {
   tokenRates: bigint[];
   erc4626Rates: (bigint | null)[];
+  erc4626MaxDeposit: (bigint | null)[];
+  erc4626MaxMint: (bigint | null)[];
   balancesLiveScaled18: bigint[];
   swapFee: bigint;
   aggregateSwapFee: bigint;
@@ -86,4 +88,6 @@ export type TokenInfo = {
   mainToken: string;
   index: number;
   rate: bigint;
+  maxDeposit: bigint;
+  maxMint: bigint;
 };

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

@@ -0,0 +1,11 @@
+import { HooksConfigMap } from './hooks/balancer-hook-event-subscriber';
+
+export function getUniqueHookNames(hooksConfigMap: HooksConfigMap): string {
+  // Use Object.values to get all HookConfig objects
+  // Then map to extract just the names
+  // Use Set to get unique names
+  // Convert back to array and join with comma
+  return Array.from(
+    new Set(Object.values(hooksConfigMap).map(hook => hook.apiName)),
+  ).join(', ');
+}

package/tests/constants-e2e.ts

@@ -1367,6 +1367,10 @@ export const Tokens: {
       address: '0xe98fc055c99decd8da0c111b090885d5d15c774e',
       decimals: 18,
     },
+    eBTC: {
+      address: '0x657e8c867d8b37dcc18fa4caead9c45eb088c642',
+      decimals: 8,
+    },
     USDS: {
       address: '0x6491c05A82219b8D1479057361ff1654749b876b',
       decimals: 18,
@@ -1769,6 +1773,10 @@ export const Tokens: {
       address: `0x978206fae13faf5a8d293fb614326b237684b750`,
       decimals: 6,
     },
+    DAI: {
+      address: `0xB77EB1A70A96fDAAeB31DB1b42F2b8b5846b2613`,
+      decimals: 18,
+    },
   },
 };
 
@@ -2191,6 +2199,7 @@ export const Holders: {
     stataUSDC: '0x75D06bae37a9c349142fE7cee77804900b1C0EC3',
     stataUSDT: '0x75D06bae37a9c349142fE7cee77804900b1C0EC3',
     usdcAave: '0xdD5De55eA6804EFb283f43b0C091C25000a6486c',
+    DAI: '0x90347b9CC81a4a28aAc74E8B134040d5ce2eaB6D',
   },
 };
 

package/tests/token-storage-slots.json

@@ -579,6 +579,18 @@
     "0xe91d153e0b41518a2ce8dd3d7944fa863463a97d": {
       "balanceSlot": "0x0000000000000000000000000000000000000000000000000000000000000003",
       "allowanceSlot": "0x0000000000000000000000000000000000000000000000000000000000000004"
+    },
+    "0x177127622c4a00f3d409b75571e12cb3c8973d3c": {
+      "balanceSlot": "0x0000000000000000000000000000000000000000000000000000000000000003",
+      "allowanceSlot": "0x0000000000000000000000000000000000000000000000000000000000000005"
+    },
+    "0x57f664882f762fa37903fc864e2b633d384b411a": {
+      "balanceSlot": "0x52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace00",
+      "allowanceSlot": "0x52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace01"
+    },
+    "0x773cda0cade2a3d86e6d4e30699d40bb95174ff2": {
+      "balanceSlot": "0x52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace00",
+      "allowanceSlot": "0x52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace01"
     }
   },
   "137": {
@@ -629,6 +641,34 @@
     "0xd9aaec86b65d86f6a7b5b1b0c42ffa531710b6ca": {
       "balanceSlot": "0x0000000000000000000000000000000000000000000000000000000000000033",
       "allowanceSlot": "0x0000000000000000000000000000000000000000000000000000000000000034"
+    },
+    "0x4200000000000000000000000000000000000006": {
+      "balanceSlot": "0x0000000000000000000000000000000000000000000000000000000000000003",
+      "allowanceSlot": "0x0000000000000000000000000000000000000000000000000000000000000004"
+    },
+    "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913": {
+      "balanceSlot": "0x0000000000000000000000000000000000000000000000000000000000000009",
+      "allowanceSlot": "0x000000000000000000000000000000000000000000000000000000000000000a"
+    },
+    "0xc1cba3fcea344f92d9239c08c0568f6f2f0ee452": {
+      "balanceSlot": "0x0000000000000000000000000000000000000000000000000000000000000001",
+      "allowanceSlot": "0x0000000000000000000000000000000000000000000000000000000000000002"
+    },
+    "0x5875eee11cf8398102fdad704c9e96607675467a": {
+      "balanceSlot": "0x0000000000000000000000000000000000000000000000000000000000000002",
+      "allowanceSlot": "0x0000000000000000000000000000000000000000000000000000000000000003"
+    },
+    "0x616a4e1db48e22028f6bbf20444cd3b8e3273738": {
+      "balanceSlot": "0x0000000000000000000000000000000000000000000000000000000000000000",
+      "allowanceSlot": "0x0000000000000000000000000000000000000000000000000000000000000001"
+    },
+    "0x88b1cd4b430d95b406e382c3cdbae54697a0286e": {
+      "balanceSlot": "0x52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace00",
+      "allowanceSlot": "0x52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace01"
+    },
+    "0xc768c589647798a6ee01a91fde98ef2ed046dbd6": {
+      "balanceSlot": "0x52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace00",
+      "allowanceSlot": "0x52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace01"
     }
   },
   "42161": {

package/.idea/codeStyles/Project.xml

@@ -1,59 +0,0 @@
-<component name="ProjectCodeStyleConfiguration">
-  <code_scheme name="Project" version="173">
-    <HTMLCodeStyleSettings>
-      <option name="HTML_SPACE_INSIDE_EMPTY_TAG" value="true" />
-    </HTMLCodeStyleSettings>
-    <JSCodeStyleSettings version="0">
-      <option name="FORCE_SEMICOLON_STYLE" value="true" />
-      <option name="SPACE_BEFORE_FUNCTION_LEFT_PARENTH" value="false" />
-      <option name="USE_DOUBLE_QUOTES" value="false" />
-      <option name="FORCE_QUOTE_STYlE" value="true" />
-      <option name="ENFORCE_TRAILING_COMMA" value="WhenMultiline" />
-      <option name="SPACES_WITHIN_OBJECT_LITERAL_BRACES" value="true" />
-      <option name="SPACES_WITHIN_IMPORTS" value="true" />
-    </JSCodeStyleSettings>
-    <TypeScriptCodeStyleSettings version="0">
-      <option name="FORCE_SEMICOLON_STYLE" value="true" />
-      <option name="SPACE_BEFORE_FUNCTION_LEFT_PARENTH" value="false" />
-      <option name="USE_DOUBLE_QUOTES" value="false" />
-      <option name="FORCE_QUOTE_STYlE" value="true" />
-      <option name="ENFORCE_TRAILING_COMMA" value="WhenMultiline" />
-      <option name="SPACES_WITHIN_OBJECT_LITERAL_BRACES" value="true" />
-      <option name="SPACES_WITHIN_IMPORTS" value="true" />
-    </TypeScriptCodeStyleSettings>
-    <VueCodeStyleSettings>
-      <option name="INTERPOLATION_NEW_LINE_AFTER_START_DELIMITER" value="false" />
-      <option name="INTERPOLATION_NEW_LINE_BEFORE_END_DELIMITER" value="false" />
-    </VueCodeStyleSettings>
-    <codeStyleSettings language="HTML">
-      <option name="SOFT_MARGINS" value="80" />
-      <indentOptions>
-        <option name="INDENT_SIZE" value="2" />
-        <option name="CONTINUATION_INDENT_SIZE" value="2" />
-        <option name="TAB_SIZE" value="2" />
-      </indentOptions>
-    </codeStyleSettings>
-    <codeStyleSettings language="JavaScript">
-      <option name="SOFT_MARGINS" value="80" />
-      <indentOptions>
-        <option name="INDENT_SIZE" value="2" />
-        <option name="CONTINUATION_INDENT_SIZE" value="2" />
-        <option name="TAB_SIZE" value="2" />
-      </indentOptions>
-    </codeStyleSettings>
-    <codeStyleSettings language="TypeScript">
-      <option name="SOFT_MARGINS" value="80" />
-      <indentOptions>
-        <option name="INDENT_SIZE" value="2" />
-        <option name="CONTINUATION_INDENT_SIZE" value="2" />
-        <option name="TAB_SIZE" value="2" />
-      </indentOptions>
-    </codeStyleSettings>
-    <codeStyleSettings language="Vue">
-      <option name="SOFT_MARGINS" value="80" />
-      <indentOptions>
-        <option name="CONTINUATION_INDENT_SIZE" value="2" />
-      </indentOptions>
-    </codeStyleSettings>
-  </code_scheme>
-</component>

package/.idea/codeStyles/codeStyleConfig.xml

@@ -1,5 +0,0 @@
-<component name="ProjectCodeStyleConfiguration">
-  <state>
-    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
-  </state>
-</component>

package/.idea/inspectionProfiles/Project_Default.xml

@@ -1,6 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <profile version="1.0">
-    <option name="myName" value="Project Default" />
-    <inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
-  </profile>
-</component>

package/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/paraswap-dex-lib.iml" filepath="$PROJECT_DIR$/.idea/paraswap-dex-lib.iml" />
-    </modules>
-  </component>
-</project>