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

package/src/dex/augustus-approvals.ts

@@ -1,11 +1,13 @@
-import { Address, ParaSwapVersion } from '@paraswap/core';
-import { CACHE_PREFIX, ETHER_ADDRESS } from '../constants';
-import { ICache, IDexHelper } from '../dex-helper';
+import { Address } from '@paraswap/core';
+import { CACHE_PREFIX, ETHER_ADDRESS, PERMIT2_ADDRESS } from '../constants';
+import { ICache } from '../dex-helper';
 import { Interface } from '@ethersproject/abi';
 import ERC20ABI from '../abi/erc20.json';
+import Permit2Abi from '../abi/permit2.json';
 import { uint256ToBigInt } from '../lib/decoders';
 import { MultiCallParams, MultiWrapper } from '../lib/multi-wrapper';
 import { ConfigHelper } from '../config';
+import { BigNumber } from 'ethers';
 
 const DEFAULT_APPROVE_CACHE_KEY_VALUE = 'true';
 
@@ -14,6 +16,7 @@ type ApprovalsMapping = Record<string, boolean>;
 
 export class AugustusApprovals {
   erc20Interface: Interface;
+  permit2Interface: Interface;
 
   private cache: ICache;
 
@@ -32,6 +35,7 @@ export class AugustusApprovals {
     this.augustusAddress = config.data.augustusAddress;
     this.augustusV6Address = config.data.augustusV6Address;
     this.erc20Interface = new Interface(ERC20ABI);
+    this.permit2Interface = new Interface(Permit2Abi);
     this.cache = cache;
 
     this.cacheApprovesKey = `${CACHE_PREFIX}_${this.network}_generic_approves`;
@@ -41,19 +45,22 @@ export class AugustusApprovals {
     spender: Address,
     token: Address,
     target: Address,
+    permit2 = false,
   ): Promise<boolean> {
-    const approvals = await this.hasApprovals(spender, [[token, target]]);
+    const approvals = await this.hasApprovals(spender, [
+      [token, target, permit2],
+    ]);
     return approvals[0];
   }
 
   async hasApprovals(
     spender: Address,
-    tokenTargetMapping: [token: Address, target: Address][],
+    tokenTargetMapping: [token: Address, target: Address, permit2: boolean][],
   ): Promise<boolean[]> {
     let approvalsMapping: Record<string, boolean> = {};
 
-    tokenTargetMapping.forEach(([token, target]) => {
-      const key = this.createCacheKey(spender, token, target);
+    tokenTargetMapping.forEach(([token, target, permit2]) => {
+      const key = this.createCacheKey(spender, token, target, permit2);
       // set approved 'true' for ETH
       approvalsMapping[key] = token.toLowerCase() === ETHER_ADDRESS;
     });
@@ -68,7 +75,9 @@ export class AugustusApprovals {
 
     // to keep same order and length as input
     return tokenTargetMapping
-      .map(([token, target]) => this.createCacheKey(spender, token, target))
+      .map(([token, target, permit2]) =>
+        this.createCacheKey(spender, token, target, permit2),
+      )
       .map(key => approvalsMapping[key]);
   }
 
@@ -107,17 +116,37 @@ export class AugustusApprovals {
       spender: Address,
       token: Address,
       target: Address,
+      permit2: boolean,
     ][],
   ): Promise<boolean[]> {
     const allowanceCalldata: MultiCallParams<bigint>[] =
-      spenderTokenTargetMapping.map(([spender, token, target]) => ({
-        target: token,
-        callData: this.erc20Interface.encodeFunctionData('allowance', [
-          spender,
-          target,
-        ]),
-        decodeFunction: uint256ToBigInt,
-      }));
+      spenderTokenTargetMapping.map(([spender, token, target, permit2]) =>
+        permit2
+          ? {
+              target: PERMIT2_ADDRESS,
+              callData: this.permit2Interface.encodeFunctionData('allowance', [
+                spender,
+                token,
+                target,
+              ]),
+              decodeFunction: value => {
+                const [amount, expiration, nonce] =
+                  this.permit2Interface.decodeFunctionResult(
+                    'allowance',
+                    value.toString(),
+                  ) as [BigNumber, BigNumber, BigNumber];
+                return amount.toBigInt();
+              },
+            }
+          : {
+              target: token,
+              callData: this.erc20Interface.encodeFunctionData('allowance', [
+                spender,
+                target,
+              ]),
+              decodeFunction: uint256ToBigInt,
+            },
+      );
 
     const allowances = await this.multiWrapper.tryAggregate<bigint>(
       false,
@@ -157,14 +186,18 @@ export class AugustusApprovals {
     spender: Address,
     token: Address,
     target: Address,
+    permit2 = false,
   ): string {
-    return `${spender}_${token}_${target}`;
+    return `${spender}_${token}_${target}${
+      permit2 ? '_permit2' : ''
+    }`.toLowerCase();
   }
 
   private splitCacheKey(
     key: string,
-  ): [spender: Address, token: Address, target: Address] {
-    return key.split('_') as [Address, Address, Address];
+  ): [spender: Address, token: Address, target: Address, permit2: boolean] {
+    const [spender, token, target, permit2] = key.split('_');
+    return [spender, token, target, permit2 === 'permit2'];
   }
 
   private filterKeys(tokenTargetMapping: ApprovalsMapping, approved = false) {

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

@@ -0,0 +1,275 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import {
+  Tokens,
+  Holders,
+  NativeTokenSymbols,
+} from '../../../tests/constants-e2e';
+import { Network, ContractMethod, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+
+/*
+  README
+  ======
+
+  This test script should add e2e tests for BalancerV3. The tests
+  should cover as many cases as possible. Most of the DEXes follow
+  the following test structure:
+    - DexName
+      - ForkName + Network
+        - ContractMethod
+          - ETH -> Token swap
+          - Token -> ETH swap
+          - Token -> Token swap
+
+  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 BalancerV3 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 BalancerV3 (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,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+  nativeTokenAmount: string,
+  testNative: boolean,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+  const nativeTokenSymbol = NativeTokenSymbols[network];
+
+  // TODO: Add any direct swap contractMethod name if it exists
+  const sideToContractMethods = new Map([
+    [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
+  ]);
+
+  describe(`${network}`, () => {
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          describe(`${contractMethod}`, () => {
+            if (testNative) {
+              it(`${nativeTokenSymbol} -> ${tokenASymbol}`, async () => {
+                await testE2E(
+                  tokens[nativeTokenSymbol],
+                  tokens[tokenASymbol],
+                  holders[nativeTokenSymbol],
+                  side === SwapSide.SELL ? nativeTokenAmount : tokenAAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                );
+              });
+              it(`${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
+                await testE2E(
+                  tokens[tokenASymbol],
+                  tokens[nativeTokenSymbol],
+                  holders[tokenASymbol],
+                  side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
+                  side,
+                  dexKey,
+                  contractMethod,
+                  network,
+                  provider,
+                );
+              });
+            }
+            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[tokenBSymbol],
+                holders[tokenASymbol],
+                side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+            it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
+              await testE2E(
+                tokens[tokenBSymbol],
+                tokens[tokenASymbol],
+                holders[tokenBSymbol],
+                side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
+// TODO - these tests dont currently run without full PS setup on Sepolia
+describe('BalancerV3 E2E', () => {
+  const dexKey = 'BalancerV3';
+
+  describe('Sepolia', () => {
+    const network = Network.SEPOLIA;
+
+    describe('Weighted Path', () => {
+      const tokenASymbol: string = 'bal';
+      const tokenBSymbol: string = 'daiAave';
+
+      const tokenAAmount: string = '1000000000000000000';
+      const tokenBAmount: string = '1000000000000000000';
+      const nativeTokenAmount = '100000000000000';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+        true,
+      );
+    });
+
+    describe('Stable Path', () => {
+      const tokenASymbol: string = 'stataUSDT';
+      const tokenBSymbol: string = 'stataUSDC';
+
+      const tokenAAmount: string = '10000000';
+      const tokenBAmount: string = '10000000';
+      const nativeTokenAmount = '0';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+        false,
+      );
+    });
+
+    describe('Boosted Path', () => {
+      const tokenASymbol: string = 'usdcAave';
+      const tokenBSymbol: string = 'daiAave';
+
+      const tokenAAmount: string = '10000000';
+      const tokenBAmount: string = '1000000000000000000';
+      const nativeTokenAmount = '0';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+        false,
+      );
+    });
+  });
+
+  describe('Gnosis', () => {
+    const network = Network.GNOSIS;
+
+    describe('Stable Path', () => {
+      const tokenASymbol: string = 'WXDAI';
+      const tokenBSymbol: string = 'COW';
+
+      const tokenAAmount: string = '1000000000000000000';
+      const tokenBAmount: string = '1000000000000000000';
+      const nativeTokenAmount = '100000000000000';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+        false,
+      );
+    });
+
+    describe('Weighed Path', () => {
+      const tokenASymbol: string = 'USDCe';
+      const tokenBSymbol: string = 'sDAI';
+
+      const tokenAAmount: string = '1000000';
+      const tokenBAmount: string = '100000000000000000';
+      const nativeTokenAmount = '0';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+        false,
+      );
+    });
+
+    describe('Boosted Path', () => {
+      const tokenASymbol: string = 'waGnoWETH';
+      const tokenBSymbol: string = 'waGnowstETH';
+
+      const tokenAAmount: string = '1000000000000000';
+      const tokenBAmount: string = '1000000000000000';
+      const nativeTokenAmount = '0';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+        false,
+      );
+    });
+  });
+});

package/src/dex/balancer-v3/balancer-v3-events.test.ts

@@ -0,0 +1,223 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { BalancerV3EventPool } from './balancer-v3-pool';
+import { Network } from '../../constants';
+import { Address } from '../../types';
+import { DummyDexHelper } from '../../dex-helper/index';
+import { testEventSubscriber } from '../../../tests/utils-events';
+import { PoolStateMap, StableMutableState } from './types';
+import { BalancerV3Config } from './config';
+import _ from 'lodash';
+
+/*
+  README
+  ======
+
+  This test script adds unit tests for BalancerV3 event based
+  system. This is done by fetching the state on-chain before the
+  event block, manually pushing the block logs to the event-subscriber,
+  comparing the local state with on-chain state.
+
+  Most of the logic for testing is abstracted by `testEventSubscriber`.
+  You need to do two things to make the tests work:
+
+  1. Fetch the block numbers where certain events were released. You
+  can modify the `./scripts/fetch-event-blocknumber.ts` to get the
+  block numbers for different events. Make sure to get sufficient
+  number of blockNumbers to cover all possible cases for the event
+  mutations.
+
+  2. Complete the implementation for fetchPoolState function. The
+  function should fetch the on-chain state of the event subscriber
+  using just the blocknumber.
+
+  The template tests only include the test for a single event
+  subscriber. There can be cases where multiple event subscribers
+  exist for a single DEX. In such cases additional tests should be
+  added.
+
+  You can run this individual test script by running:
+  `npx jest src/dex/balancer-v3/balancer-v3-events.test.ts`
+
+  (This comment should be removed from the final implementation)
+*/
+
+jest.setTimeout(50 * 1000);
+
+async function fetchPoolState(
+  balancerV3Pools: BalancerV3EventPool,
+  blockNumber: number,
+  poolAddress: string,
+): Promise<PoolStateMap> {
+  const pools = await balancerV3Pools.generateState(blockNumber);
+  // Filter to pool of interest
+  return Object.entries(_.cloneDeep(pools) as PoolStateMap)
+    .filter(([address]) => {
+      return address.toLowerCase() === poolAddress.toLowerCase();
+    })
+    .reduce((acc, [address, pool]) => {
+      acc[address] = pool;
+      return acc;
+    }, {} as PoolStateMap);
+}
+
+function stateCompare(state: PoolStateMap, expectedState: PoolStateMap) {
+  if (state['0xd63db0b88dca565633fb8d70a70b9b8093d34a7e']) {
+    if (
+      (
+        expectedState[
+          '0xd63db0b88dca565633fb8d70a70b9b8093d34a7e'
+        ] as StableMutableState
+      ).ampIsUpdating
+    ) {
+      compareAmpUpdating(state, expectedState);
+    } else compareAmpStopped(state, expectedState);
+  } else expect(state).toEqual(expectedState);
+}
+
+function compareAmpUpdating(state: PoolStateMap, expectedState: PoolStateMap) {
+  // tokenRates and balancesLiveScaled18 are gradually increasing between blocks due to tokenRate (and can't be tracked via event) so will be ignored
+  const compare = {
+    ...state,
+    ['0xd63db0b88dca565633fb8d70a70b9b8093d34a7e']: _.omit(
+      state['0xd63db0b88dca565633fb8d70a70b9b8093d34a7e'],
+      ['balancesLiveScaled18', 'tokenRates'],
+    ),
+  };
+  const expectedCompare = {
+    ...expectedState,
+    ['0xd63db0b88dca565633fb8d70a70b9b8093d34a7e']: _.omit(
+      expectedState['0xd63db0b88dca565633fb8d70a70b9b8093d34a7e'],
+      ['balancesLiveScaled18', 'tokenRates'],
+    ),
+  };
+  expect(compare).toEqual(expectedCompare);
+}
+
+function compareAmpStopped(state: PoolStateMap, expectedState: PoolStateMap) {
+  if (state['0xd63db0b88dca565633fb8d70a70b9b8093d34a7e']) {
+    // tokenRates and balancesLiveScaled18 are gradually increasing between blocks due to tokenRate (and can't be tracked via event) so will be ignored
+    // In Contract ampStartTime & ampStopTime are updated to timestamp event is called.
+    // There doesn't appear to be a way to easily get timestamp non-async so we default to 0n which should have no effect.
+    const compare = {
+      ...state,
+      ['0xd63db0b88dca565633fb8d70a70b9b8093d34a7e']: _.omit(
+        state['0xd63db0b88dca565633fb8d70a70b9b8093d34a7e'],
+        ['balancesLiveScaled18', 'tokenRates'],
+      ),
+    };
+    const expectedCompare = {
+      ...expectedState,
+      ['0xd63db0b88dca565633fb8d70a70b9b8093d34a7e']: {
+        ..._.omit(expectedState['0xd63db0b88dca565633fb8d70a70b9b8093d34a7e'], [
+          'balancesLiveScaled18',
+          'tokenRates',
+        ]),
+        ampStartTime: 0n,
+        ampStopTime: 0n,
+      },
+    };
+    expect(compare).toEqual(expectedCompare);
+  } else expect(state).toEqual(expectedState);
+}
+
+// eventName -> blockNumbers
+type EventMappings = Record<string, EventData>;
+type EventData = { blockNumbers: number[]; poolAddress: string[] };
+
+describe('BalancerV3 EventPool', function () {
+  const dexKey = 'BalancerV3';
+  const network = Network.SEPOLIA;
+  const dexHelper = new DummyDexHelper(network);
+  const logger = dexHelper.getLogger(dexKey);
+  let balancerV3Pool: BalancerV3EventPool;
+
+  // vault -> EventMappings
+  // TODO once we have a new test deployment add tests for: AggregateSwapFeePercentageChanged, SwapFeePercentageChanged, PoolPausedStateChanged
+  const eventsToTest: Record<Address, EventMappings> = {
+    [BalancerV3Config.BalancerV3[network].vaultAddress]: {
+      // https://eth-sepolia.blockscout.com/tx/0xc417d38ad6e21250c9ddded37680b40f0991cfd3f8ae2d8b5800507a58d48c44
+      LiquidityAdded: {
+        blockNumbers: [7170937],
+        poolAddress: ['0x2ff3b96e0057a1f25f1d62ab800554ccdb268ab8'],
+      },
+      // https://sepolia.etherscan.io/tx/0xc1596e26d51104b9236a0debc3e1946b30b82f92b8331639ad6f6aea2ff2decc
+      LiquidityRemoved: {
+        blockNumbers: [7170957],
+        poolAddress: ['0x2ff3b96e0057a1f25f1d62ab800554ccdb268ab8'],
+      },
+      // https://sepolia.etherscan.io/tx/0x78d18503c2dd4458c94ec916b10c088bb4e8b90059676d00dbcec83f763d8c0e
+      Swap: {
+        blockNumbers: [7175721],
+        poolAddress: ['0x2ff3b96e0057a1f25f1d62ab800554ccdb268ab8'],
+      },
+      // 7170034, AmpUpdateStarted, https://eth-sepolia.blockscout.com/tx/0xfbe2e53d9cede1dc900100a1d6e809a89d909746ac7b8cc011e93227af8dda8b?tab=logs
+      // 7170069, AmpUpdateStopped, https://eth-sepolia.blockscout.com/tx/0x2ee2e1d5980013fdf1cf9c3789e0321fb598c2412db8ee8057fcfaffd1c792ab?tab=logs
+      VaultAuxiliary: {
+        blockNumbers: [7170034, 7170069],
+        poolAddress: [
+          '0xD63dB0B88dca565633fB8d70a70b9b8093d34A7E',
+          '0xD63dB0B88dca565633fB8d70a70b9b8093d34A7E',
+        ],
+      },
+      // https://sepolia.etherscan.io/tx/0x71f9879485f4e4cf97aa42381988ffe277f05a872d6b507cfa007cec1239a3f8#eventlog
+      SwapFeePercentageChanged: {
+        blockNumbers: [7206571],
+        poolAddress: ['0xe69b70a86A4e1fD33dA95693A1aE12Be1c26C8ea'],
+      },
+      // https://sepolia.etherscan.io/tx/0xaf232ca2df59ba5fad38d74e9b54ec2ae1ad2e6abca8348f107cf3fd94c787c7#eventlog
+      // Should remove pool from state as its paused and no longer supports swaps
+      PoolPausedStateChanged: {
+        blockNumbers: [7206586],
+        poolAddress: ['0xe69b70a86A4e1fD33dA95693A1aE12Be1c26C8ea'],
+      },
+      // https://sepolia.etherscan.io/tx/0xa23dc10bd0fbed7ffffe867766d9b0d7670ca4a0bc352669f547bc7775644349#eventlog
+      AggregateSwapFeePercentageChanged: {
+        blockNumbers: [7206701],
+        poolAddress: ['0xe69b70a86A4e1fD33dA95693A1aE12Be1c26C8ea'],
+      },
+    },
+  };
+
+  beforeEach(async () => {
+    balancerV3Pool = new BalancerV3EventPool(
+      dexKey,
+      network,
+      dexHelper,
+      logger,
+    );
+  });
+
+  Object.entries(eventsToTest).forEach(
+    ([vaultAddress, events]: [string, EventMappings]) => {
+      describe(`Events for Vault: ${vaultAddress}`, () => {
+        Object.entries(events).forEach(
+          ([eventName, eventData]: [string, EventData]) => {
+            describe(`${eventName}`, () => {
+              eventData.blockNumbers.forEach((blockNumber: number, i) => {
+                it(`Pool: ${eventData.poolAddress[i]} State after ${blockNumber}`, async function () {
+                  await testEventSubscriber(
+                    balancerV3Pool,
+                    balancerV3Pool.addressesSubscribed,
+                    (_blockNumber: number) =>
+                      fetchPoolState(
+                        balancerV3Pool,
+                        _blockNumber,
+                        eventData.poolAddress[i],
+                      ),
+                    blockNumber,
+                    `${dexKey}_${vaultAddress}`,
+                    dexHelper.provider,
+                    stateCompare,
+                  );
+                });
+              });
+            });
+          },
+        );
+      });
+    },
+  );
+});