@paraswap/dex-lib 4.0.0 → 4.0.1-balancer-v3-cables.0

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

@@ -0,0 +1,326 @@
+import _ from 'lodash';
+import {
+  ImmutablePoolStateMap,
+  CommonMutableState,
+  PoolStateMap,
+  StableMutableState,
+} from './types';
+import { BalancerV3Config } from './config';
+import { Interface, Result } from '@ethersproject/abi';
+import { IDexHelper } from '../../dex-helper';
+
+interface callData {
+  target: string;
+  callData: string;
+}
+
+// Encoding & Decoding for onchain calls to fetch mutable pool data
+// Each supported pool type should have its own specific calls if needed
+const poolOnChain: Record<
+  string,
+  {
+    count: number;
+    encode: (
+      network: number,
+      contractInterface: Interface,
+      address: string,
+    ) => callData[];
+    decode: (
+      contractInterface: Interface,
+      poolAddress: string,
+      data: any,
+      startIndex: number,
+    ) => {} | CommonMutableState | StableMutableState;
+  }
+> = {
+  ['COMMON']: {
+    count: 6,
+    ['encode']: (
+      network: number,
+      contractInterface: Interface,
+      address: string,
+    ): callData[] => {
+      return [
+        {
+          target: BalancerV3Config.BalancerV3[network].vaultAddress,
+          callData: contractInterface.encodeFunctionData('getPoolTokenRates', [
+            address,
+          ]),
+        },
+        {
+          target: BalancerV3Config.BalancerV3[network].vaultAddress,
+          callData: contractInterface.encodeFunctionData(
+            'getCurrentLiveBalances',
+            [address],
+          ),
+        },
+        {
+          target: BalancerV3Config.BalancerV3[network].vaultAddress,
+          callData: contractInterface.encodeFunctionData('getPoolConfig', [
+            address,
+          ]),
+        },
+        {
+          target: BalancerV3Config.BalancerV3[network].vaultAddress,
+          callData: contractInterface.encodeFunctionData('totalSupply', [
+            address,
+          ]),
+        },
+        {
+          target: BalancerV3Config.BalancerV3[network].vaultAddress,
+          callData: contractInterface.encodeFunctionData('isPoolPaused', [
+            address,
+          ]),
+        },
+        {
+          target: BalancerV3Config.BalancerV3[network].vaultAddress,
+          callData: contractInterface.encodeFunctionData('getHooksConfig', [
+            address,
+          ]),
+        },
+      ];
+    },
+    ['decode']: (
+      contractInterface: Interface,
+      poolAddress: string,
+      data: any,
+      startIndex: number,
+    ): CommonMutableState => {
+      const resultTokenRates = decodeThrowError(
+        contractInterface,
+        'getPoolTokenRates',
+        data[startIndex++],
+        poolAddress,
+      );
+      if (!resultTokenRates)
+        throw new Error(
+          `Failed to get result for getPoolTokenRates for ${poolAddress}`,
+        );
+      const resultLiveBalances = decodeThrowError(
+        contractInterface,
+        'getCurrentLiveBalances',
+        data[startIndex++],
+        poolAddress,
+      );
+      if (!resultLiveBalances)
+        throw new Error(
+          `Failed to get result for getCurrentLiveBalances for ${poolAddress}`,
+        );
+      const resultGetPoolConfig = decodeThrowError(
+        contractInterface,
+        'getPoolConfig',
+        data[startIndex++],
+        poolAddress,
+      );
+      if (!resultGetPoolConfig)
+        throw new Error(
+          `Failed to get result for getPoolConfig for ${poolAddress}`,
+        );
+      const resultTotalSupply = decodeThrowError(
+        contractInterface,
+        'totalSupply',
+        data[startIndex++],
+        poolAddress,
+      );
+      if (!resultTotalSupply)
+        throw new Error(
+          `Failed to get result for totalSupply for ${poolAddress}`,
+        );
+      const resultIsPoolPaused = decodeThrowError(
+        contractInterface,
+        'isPoolPaused',
+        data[startIndex++],
+        poolAddress,
+      );
+      if (!resultIsPoolPaused)
+        throw new Error(
+          `Failed to get result for isPoolPaused for ${poolAddress}`,
+        );
+      const resultHooksConfig = decodeThrowError(
+        contractInterface,
+        'getHooksConfig',
+        data[startIndex++],
+        poolAddress,
+      );
+      if (!resultHooksConfig)
+        throw new Error(
+          `Failed to get result for resultHooksConfig for ${poolAddress}`,
+        );
+      return {
+        tokenRates: resultTokenRates.tokenRates.map((r: string) => BigInt(r)),
+        balancesLiveScaled18: resultLiveBalances.balancesLiveScaled18.map(
+          (b: string) => BigInt(b),
+        ),
+        swapFee: BigInt(resultGetPoolConfig[0].staticSwapFeePercentage),
+        aggregateSwapFee: BigInt(
+          resultGetPoolConfig[0].aggregateSwapFeePercentage,
+        ),
+        totalSupply: BigInt(resultTotalSupply[0]),
+        scalingFactors: resultTokenRates.decimalScalingFactors.map(
+          (r: string) => BigInt(r),
+        ),
+        isPoolPaused: resultIsPoolPaused[0],
+        hasHook:
+          resultHooksConfig[0].hooksContract !==
+          '0x0000000000000000000000000000000000000000',
+      };
+    },
+  },
+  ['WEIGHTED']: {
+    count: 0,
+    ['encode']: (
+      network: number,
+      contractInterface: Interface,
+      address: string,
+    ): callData[] => {
+      return [];
+    },
+    ['decode']: (
+      contractInterface: Interface,
+      poolAddress: string,
+      data: any,
+      startIndex: number,
+    ) => {
+      return {};
+    },
+  },
+  ['STABLE']: {
+    count: 2,
+    ['encode']: (
+      network: number,
+      contractInterface: Interface,
+      address: string,
+    ): callData[] => {
+      return [
+        {
+          target: address,
+          callData: contractInterface.encodeFunctionData(
+            'getAmplificationParameter',
+          ),
+        },
+        {
+          target: address,
+          callData: contractInterface.encodeFunctionData(
+            'getAmplificationState',
+          ),
+        },
+      ];
+    },
+    ['decode']: (
+      contractInterface: Interface,
+      poolAddress: string,
+      data: any,
+      startIndex: number,
+    ): StableMutableState => {
+      const resultAmp = decodeThrowError(
+        contractInterface,
+        'getAmplificationParameter',
+        data[startIndex++],
+        poolAddress,
+      );
+      if (!resultAmp)
+        throw new Error(
+          `Failed to get result for getAmplificationParameter for ${poolAddress}`,
+        );
+      const resultAmpState = decodeThrowError(
+        contractInterface,
+        'getAmplificationState',
+        data[startIndex++],
+        poolAddress,
+      );
+      if (!resultAmpState)
+        throw new Error(
+          `Failed to get result for getAmplificationState for ${poolAddress}`,
+        );
+
+      return {
+        amp: resultAmp[0].toBigInt(),
+        ampIsUpdating: !!resultAmp[1],
+        ampStartValue: resultAmpState[0][0].toBigInt(),
+        ampEndValue: resultAmpState[0][1].toBigInt(),
+        ampStartTime: BigInt(resultAmpState[0][2]),
+        ampStopTime: BigInt(resultAmpState[0][3]),
+      };
+    },
+  },
+};
+
+export function decodeThrowError(
+  contractInterface: Interface,
+  functionName: string,
+  resultEntry: { success: boolean; returnData: any },
+  poolAddress: string,
+): Result {
+  if (!resultEntry.success)
+    throw new Error(`Failed to execute ${functionName} for ${poolAddress}`);
+  return contractInterface.decodeFunctionResult(
+    functionName,
+    resultEntry.returnData,
+  );
+}
+
+// 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,
+  immutablePoolStateMap: ImmutablePoolStateMap,
+  dexHelper: IDexHelper,
+  interfaces: {
+    [name: string]: Interface;
+  },
+  blockNumber?: number,
+): Promise<PoolStateMap> {
+  const multiCallData = Object.entries(immutablePoolStateMap)
+    .map(([address, pool]) => {
+      return [
+        ...poolOnChain['COMMON'].encode(network, interfaces['VAULT'], address),
+        ...poolOnChain[pool.poolType].encode(
+          network,
+          interfaces[pool.poolType],
+          address,
+        ),
+      ];
+    })
+    .flat();
+
+  // 500 is an arbitrary number chosen based on the blockGasLimit
+  const slicedMultiCallData = _.chunk(multiCallData, 500);
+
+  const multicallData = (
+    await Promise.all(
+      slicedMultiCallData.map(async _multiCallData =>
+        dexHelper.multiContract.methods
+          .tryAggregate(false, _multiCallData)
+          .call({}, blockNumber),
+      ),
+    )
+  ).flat();
+
+  let i = 0;
+  const poolStateMap = Object.fromEntries(
+    Object.entries(immutablePoolStateMap).map(([address, pool]) => {
+      const commonMutableData = poolOnChain['COMMON'].decode(
+        interfaces['VAULT'],
+        address,
+        multicallData,
+        i,
+      ) as CommonMutableState;
+      i = i + poolOnChain['COMMON'].count;
+      const poolMutableData = poolOnChain[pool.poolType].decode(
+        interfaces[pool.poolType],
+        address,
+        multicallData,
+        i,
+      );
+      i = i + poolOnChain[pool.poolType].count;
+      return [
+        address,
+        {
+          ...pool,
+          ...commonMutableData,
+          ...poolMutableData,
+        },
+      ];
+    }),
+  );
+  return poolStateMap;
+}

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

@@ -0,0 +1,129 @@
+import axios from 'axios';
+import {
+  apiUrl,
+  BalancerV3Config,
+  disabledPoolIds,
+  SUPPORTED_POOLS,
+} from './config';
+import { CommonImmutablePoolState, ImmutablePoolStateMap } from './types';
+import { parseUnits } from 'ethers/lib/utils';
+
+interface PoolToken {
+  address: string;
+  weight: string | null;
+  isErc4626: boolean;
+  underlyingToken: {
+    address: string;
+  } | null;
+}
+
+interface Pool {
+  id: string;
+  type: string;
+  poolTokens: PoolToken[];
+}
+
+interface QueryResponse {
+  data: {
+    poolGetAggregatorPools: Pool[];
+  };
+}
+
+function createQuery(
+  networkId: number,
+  poolTypes: SUPPORTED_POOLS[],
+  timestamp?: number,
+): string {
+  const poolTypesString = poolTypes.map(type => `${type}`).join(', ');
+  const networkString = BalancerV3Config.BalancerV3[networkId].apiNetworkName;
+  const disabledPoolIdsString = disabledPoolIds.BalancerV3[networkId]
+    ?.map(p => `"${p}"`)
+    .join(', ');
+
+  // Build the where clause conditionally
+  const whereClause = {
+    chainIn: networkString,
+    protocolVersionIn: 3,
+    hasHook: false,
+    poolTypeIn: `[${poolTypesString}]`,
+    ...(timestamp && { createTime: `{lt: ${timestamp}}` }),
+    ...(disabledPoolIdsString && { idNotIn: `[${disabledPoolIdsString}]` }),
+  };
+
+  // Convert where clause to string, filtering out undefined values
+  const whereString = Object.entries(whereClause)
+    .map(([key, value]) => `${key}: ${value}`)
+    .join(', ');
+  return `
+    query MyQuery {
+      poolGetAggregatorPools(
+        where: {${whereString}}
+      ) {
+        id
+        type
+        poolTokens {
+          address
+          weight
+          isErc4626
+          underlyingToken {
+            address
+          }
+        }
+      }
+    }
+  `;
+}
+
+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,
+  timestamp?: number,
+): Promise<ImmutablePoolStateMap> {
+  try {
+    const query = createQuery(
+      network,
+      Object.values(SUPPORTED_POOLS),
+      timestamp,
+    );
+    const response = await axios.post<QueryResponse>(
+      apiUrl,
+      {
+        query,
+      },
+      {
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      },
+    );
+
+    const pools = response.data.data.poolGetAggregatorPools;
+    return toImmutablePoolStateMap(pools);
+  } catch (error) {
+    // console.error('Error executing GraphQL query:', error);
+    throw error;
+  }
+}

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

@@ -0,0 +1,96 @@
+import axios from 'axios';
+import { apiUrl, BalancerV3Config } from './config';
+
+interface PoolToken {
+  address: string;
+  decimals: number;
+  underlyingToken?: {
+    address: string;
+    decimals: number;
+  };
+}
+
+export interface Pool {
+  address: string;
+  poolTokens: PoolToken[];
+  dynamicData: {
+    totalLiquidity: string;
+  };
+}
+
+interface QueryResponse {
+  data: {
+    poolGetAggregatorPools: Pool[];
+  };
+}
+
+function createQuery(
+  networkId: number,
+  poolsFilter: string[],
+  count: number,
+): string {
+  const networkString = BalancerV3Config.BalancerV3[networkId].apiNetworkName;
+  const poolIdString = poolsFilter.map(a => `"${a}"`).join(', ');
+  // Build the where clause conditionally
+  const whereClause = {
+    chainIn: networkString,
+    protocolVersionIn: 3,
+    hasHook: false,
+    idIn: `[${poolIdString}]`,
+  };
+
+  // Convert where clause to string, filtering out undefined values
+  const whereString = Object.entries(whereClause)
+    .map(([key, value]) => `${key}: ${value}`)
+    .join(', ');
+  return `
+    query MyQuery {
+      poolGetAggregatorPools(
+        where: {${whereString}}
+        first: ${count}
+        orderBy: totalLiquidity
+        orderDirection: desc
+      ) {
+        address
+        poolTokens {
+          address
+          decimals
+          underlyingToken {
+            address
+            decimals
+          }
+        }
+        dynamicData {
+          totalLiquidity
+        }
+      }
+    }
+  `;
+}
+
+export async function getTopPoolsApi(
+  networkId: number,
+  poolsFilter: string[],
+  count: number,
+): Promise<Pool[]> {
+  try {
+    const query = createQuery(networkId, poolsFilter, count);
+    const response = await axios.post<QueryResponse>(
+      apiUrl,
+      {
+        query,
+      },
+      {
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      },
+    );
+
+    const pools = response.data.data.poolGetAggregatorPools;
+    return pools;
+  } catch (error) {
+    // console.error('Error executing GraphQL query:', error);
+    throw error;
+  }
+}

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

@@ -0,0 +1,66 @@
+import { UnoptimizedRate, OptimalSwap } from '../../types';
+import _ from 'lodash';
+
+export function balancerV3Merge(or: UnoptimizedRate): UnoptimizedRate {
+  const fixRoute = (rawRate: OptimalSwap[]): OptimalSwap[] => {
+    let lastExchange: false | OptimalSwap = false;
+
+    let optimizedRate = new Array<OptimalSwap>();
+
+    rawRate.forEach((s: OptimalSwap) => {
+      if (
+        s.swapExchanges.length !== 1 ||
+        s.swapExchanges[0].exchange.toLowerCase() !== 'balancerv3'
+      ) {
+        lastExchange = false;
+        optimizedRate.push(s);
+        return;
+      }
+
+      if (
+        lastExchange &&
+        lastExchange.swapExchanges[0].exchange.toLowerCase() ===
+          s.swapExchanges[0].exchange.toLowerCase() &&
+        _.last(
+          <any[]>lastExchange.swapExchanges[0].data.steps,
+        )!.swapInput.tokenOut.toLowerCase() ===
+          s.swapExchanges[0].data.steps[0].swapInput.tokenIn.toLowerCase()
+      ) {
+        lastExchange.swapExchanges[0].data.steps =
+          lastExchange.swapExchanges[0].data.steps.concat(
+            s.swapExchanges[0].data.steps,
+          );
+
+        lastExchange.swapExchanges[0].poolAddresses =
+          lastExchange.swapExchanges[0].poolAddresses!.concat(
+            s.swapExchanges[0].poolAddresses!,
+          );
+
+        lastExchange.swapExchanges[0].data.gasUSD = (
+          parseFloat(lastExchange.swapExchanges[0].data.gasUSD) +
+          parseFloat(s.swapExchanges[0].data.gasUSD)
+        ).toFixed(6);
+
+        lastExchange.destToken = s.destToken;
+        lastExchange.destDecimals = s.destDecimals;
+
+        lastExchange.swapExchanges[0].destAmount =
+          s.swapExchanges[0].destAmount;
+
+        return;
+      }
+
+      lastExchange = _.cloneDeep(s);
+      optimizedRate.push(lastExchange);
+    });
+
+    return optimizedRate;
+  };
+
+  or.bestRoute = or.bestRoute.map(r => ({
+    ...r,
+    swaps: fixRoute(r.swaps),
+  }));
+
+  return or;
+}

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

@@ -0,0 +1,78 @@
+import { defaultAbiCoder } from '@ethersproject/abi';
+import { PoolState } from '@balancer-labs/balancer-maths';
+import { StableMutableState } from './types';
+
+// TODO - Update with more accurate
+export const STABLE_GAS_COST = 155000;
+
+export function isStableMutableState(
+  poolState: any,
+): poolState is StableMutableState {
+  return (
+    poolState &&
+    typeof poolState === 'object' &&
+    'amp' in poolState &&
+    'ampIsUpdating' in poolState &&
+    'ampStartValue' in poolState &&
+    'ampEndValue' in poolState &&
+    'ampStartTime' in poolState &&
+    'ampStopTime' in poolState
+  );
+}
+
+// https://github.com/balancer/balancer-v3-monorepo/blob/009f2793abda248b150ccd15c1db25930c96ca82/pkg/pool-stable/contracts/StablePool.sol#L274
+export function getAmplificationParameter(
+  startValue: bigint,
+  endValue: bigint,
+  startTime: bigint,
+  endTime: bigint,
+  timestamp: bigint,
+): bigint {
+  let value: bigint;
+  if (timestamp < endTime) {
+    if (endValue > startValue) {
+      value =
+        startValue +
+        ((endValue - startValue) * (timestamp - startTime)) /
+          (endTime - startTime);
+    } else {
+      value =
+        startValue -
+        ((startValue - endValue) * (timestamp - startTime)) /
+          (endTime - startTime);
+    }
+  } else {
+    value = endValue;
+  }
+  return value;
+}
+
+export function ampUpdateStartedEvent(poolState: PoolState, eventData: any) {
+  // abi.encode(currentValueUint64, endValueUint64, startTimeUint32, endTimeUint32)
+  const decodedParams = defaultAbiCoder.decode(
+    ['uint64', 'uint64', 'uint32', 'uint32'],
+    eventData,
+  );
+  if (isStableMutableState(poolState)) {
+    if (decodedParams[3] > decodedParams[2]) poolState.ampIsUpdating = true;
+    poolState.ampStartValue = decodedParams[0].toBigInt();
+    poolState.ampEndValue = decodedParams[1].toBigInt();
+    poolState.ampStartTime = BigInt(decodedParams[2]);
+    poolState.ampStopTime = BigInt(decodedParams[3]);
+  } else throw new Error("Can't update amp on non-stable pool");
+}
+
+export function ampUpdateStoppedEvent(poolState: PoolState, eventData: any) {
+  // abi.encode(currentValue)
+  const decodedParams = defaultAbiCoder.decode(['uint256'], eventData);
+  if (isStableMutableState(poolState)) {
+    poolState.ampIsUpdating = false;
+    poolState.amp = decodedParams[0].toBigInt();
+    poolState.ampStartValue = decodedParams[0].toBigInt();
+    poolState.ampEndValue = decodedParams[0].toBigInt();
+    // In Contract these are update to timestamp event is called.
+    // There doesn't appear to be a way to easily get timestamp non-async so default to 0n which should have no effect
+    poolState.ampStartTime = BigInt(0n);
+    poolState.ampStopTime = BigInt(0n);
+  } else throw new Error("Can't update amp on non-stable pool");
+}