@paraswap/dex-lib 4.0.22 → 4.0.23

package/src/dex/balancer-v2/balancer-v2-integration.test.ts

@@ -30,11 +30,9 @@ async function getOnChainPricingForWeightedPool(
         return 0n;
       }
 
-      const params = balancerV2.getBalancerParam(
+      const params = balancerV2.getBalancerV2BatchSwapParam(
         srcTokenAddress,
         destTokenAddress,
-        '0',
-        '0',
         {
           swaps: [
             {
@@ -44,6 +42,8 @@ async function getOnChainPricingForWeightedPool(
           ],
         },
         side,
+        balancerV2.dexHelper.config.data.augustusV6Address!,
+        balancerV2.dexHelper.config.data.augustusV6Address!,
       );
 
       const calldata = [
@@ -611,85 +611,243 @@ describe('BalancerV2', function () {
   });
 
   describe('GyroE', () => {
-    // sDAI<>GYD - more likely to have continued liqudity
-    const gyroEAddr = '0x1cce5169bde03f3d5ad0206f6bd057953539dae6';
-
-    it('getPoolIdentifiers and getPricesVolume', async function () {
-      const network = Network.MAINNET;
-      const dexHelper = new DummyDexHelper(network);
-      // const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
-      const blocknumber = 19425305;
-      const balancerV2 = new BalancerV2(network, dexKey, dexHelper);
-      const tokens = Tokens[network];
-
-      await balancerV2.initializePricing(blocknumber);
-
-      const pools = await balancerV2.getPoolIdentifiers(
-        tokens.GYD,
-        tokens.sDAI,
-        SwapSide.SELL,
-        blocknumber,
-      );
-      console.log('GYD <> sDAI Pool Identifiers (Mainnet): ', pools);
-
-      const isPool = pools.find(poolIdentifier =>
-        poolIdentifier.includes(gyroEAddr),
-      );
-
-      expect(isPool).toBeDefined();
-
-      const poolPrices = await balancerV2.getPricesVolume(
-        tokens.GYD,
-        tokens.sDAI,
-        amounts,
-        SwapSide.SELL,
-        blocknumber,
-        pools,
-      );
-      console.log('GYD <> sDAI Pool Prices (Mainnet): ', poolPrices);
-
-      expect(poolPrices).not.toBeNull();
-      checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
-      const isPoolPrice = poolPrices!.find(price =>
-        price.data.poolId.includes(gyroEAddr),
-      );
-      expect(isPoolPrice).toBeDefined();
-
-      const onChainPrices = await getOnChainPricingForWeightedPool(
-        balancerV2,
-        blocknumber,
-        isPoolPrice!,
-        amounts,
-        tokens.GYD.address,
-        tokens.sDAI.address,
-        SwapSide.SELL,
-      );
-
-      console.log('GYD <> sDAI on-chain prices: ', onChainPrices);
-
-      expect(onChainPrices).toEqual(isPoolPrice!.prices);
-
-      await balancerV2.releaseResources();
+    describe('sDAI > GYD', () => {
+      // sDAI<>GYD - more likely to have continued liqudity
+      const gyroEAddr = '0x1cce5169bde03f3d5ad0206f6bd057953539dae6';
+
+      it('getPoolIdentifiers and getPricesVolume', async function () {
+        const network = Network.MAINNET;
+        const dexHelper = new DummyDexHelper(network);
+        // const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+        const blocknumber = 19425305;
+        const balancerV2 = new BalancerV2(network, dexKey, dexHelper);
+        const tokens = Tokens[network];
+
+        await balancerV2.initializePricing(blocknumber);
+
+        const pools = await balancerV2.getPoolIdentifiers(
+          tokens.GYD,
+          tokens.sDAI,
+          SwapSide.SELL,
+          blocknumber,
+        );
+        console.log('GYD <> sDAI Pool Identifiers (Mainnet): ', pools);
+
+        const isPool = pools.find(poolIdentifier =>
+          poolIdentifier.includes(gyroEAddr),
+        );
+
+        expect(isPool).toBeDefined();
+
+        const poolPrices = await balancerV2.getPricesVolume(
+          tokens.GYD,
+          tokens.sDAI,
+          amounts,
+          SwapSide.SELL,
+          blocknumber,
+          pools,
+        );
+        console.log('GYD <> sDAI Pool Prices (Mainnet): ', poolPrices);
+
+        expect(poolPrices).not.toBeNull();
+        checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+        const isPoolPrice = poolPrices!.find(price =>
+          price.data.poolId.includes(gyroEAddr),
+        );
+        expect(isPoolPrice).toBeDefined();
+
+        const onChainPrices = await getOnChainPricingForWeightedPool(
+          balancerV2,
+          blocknumber,
+          isPoolPrice!,
+          amounts,
+          tokens.GYD.address,
+          tokens.sDAI.address,
+          SwapSide.SELL,
+        );
+
+        console.log('GYD <> sDAI on-chain prices: ', onChainPrices);
+
+        expect(onChainPrices).toEqual(isPoolPrice!.prices);
+
+        await balancerV2.releaseResources();
+      });
+
+      it('getTopPoolsForToken', async function () {
+        const network = Network.MAINNET;
+        const dexHelper = new DummyDexHelper(network);
+        const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+        const balancerV2 = new BalancerV2(network, dexKey, dexHelper);
+        await balancerV2.initializePricing(blocknumber);
+        const tokens = Tokens[network];
+
+        const poolLiquidity = await balancerV2.getTopPoolsForToken(
+          tokens.sDAI.address.toLowerCase(),
+          10,
+        );
+        console.log('sDAI Top Pools (Mainnet):', poolLiquidity);
+
+        checkPoolsLiquidity(poolLiquidity, tokens.sDAI.address, dexKey);
+        const isTopPool = poolLiquidity.find(
+          pool => pool.address === gyroEAddr,
+        );
+        expect(isTopPool).toBeDefined();
+        await balancerV2.releaseResources();
+      });
     });
 
-    it('getTopPoolsForToken', async function () {
-      const network = Network.MAINNET;
-      const dexHelper = new DummyDexHelper(network);
-      const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
-      const balancerV2 = new BalancerV2(network, dexKey, dexHelper);
-      await balancerV2.initializePricing(blocknumber);
-      const tokens = Tokens[network];
-
-      const poolLiquidity = await balancerV2.getTopPoolsForToken(
-        tokens.sDAI.address.toLowerCase(),
-        10,
-      );
-      console.log('sDAI Top Pools (Mainnet):', poolLiquidity);
-
-      checkPoolsLiquidity(poolLiquidity, tokens.sDAI.address, dexKey);
-      const isTopPool = poolLiquidity.find(pool => pool.address === gyroEAddr);
-      expect(isTopPool).toBeDefined();
-      await balancerV2.releaseResources();
+    describe('WETH / USDC', () => {
+      const gyroEAddr = '0x4c42b5057a8663e2b1ac21685d1502c937a03817';
+
+      it('SELL WETH -> USDC getPoolIdentifiers and getPricesVolume', async function () {
+        const network = Network.BASE;
+
+        const dexHelper = new DummyDexHelper(network);
+        const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+        // const blocknumber = 19425305;
+        const balancerV2 = new BalancerV2(network, dexKey, dexHelper);
+        const tokens = Tokens[network];
+
+        const amounts = [
+          0n,
+          BI_POWS[18],
+          2n * BI_POWS[18],
+          3n * BI_POWS[18],
+          4n * BI_POWS[18],
+          5n * BI_POWS[18],
+          6n * BI_POWS[18],
+          7n * BI_POWS[18],
+          8n * BI_POWS[18],
+          9n * BI_POWS[18],
+          10n * BI_POWS[18],
+        ];
+
+        await balancerV2.initializePricing(blocknumber);
+
+        const pools = await balancerV2.getPoolIdentifiers(
+          tokens.WETH,
+          tokens.USDC,
+          SwapSide.SELL,
+          blocknumber,
+        );
+        console.log('WETH <> USDC Pool Identifiers (Mainnet): ', pools);
+
+        const isPool = pools.find(poolIdentifier =>
+          poolIdentifier.includes(gyroEAddr),
+        );
+
+        expect(isPool).toBeDefined();
+
+        const poolPrices = await balancerV2.getPricesVolume(
+          tokens.WETH,
+          tokens.USDC,
+          amounts,
+          SwapSide.SELL,
+          blocknumber,
+          pools,
+        );
+        console.log('WETH <> USDC Pool Prices (Base): ', poolPrices);
+
+        expect(poolPrices).not.toBeNull();
+
+        // checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+        const isPoolPrice = poolPrices!.find(price =>
+          price.data.poolId.includes(gyroEAddr),
+        );
+        expect(isPoolPrice).toBeDefined();
+
+        const onChainPrices = await getOnChainPricingForWeightedPool(
+          balancerV2,
+          blocknumber,
+          isPoolPrice!,
+          amounts,
+          tokens.WETH.address,
+          tokens.USDC.address,
+          SwapSide.SELL,
+        );
+
+        console.log('WETH <> USDC on-chain prices: ', onChainPrices);
+
+        expect(onChainPrices).toEqual(isPoolPrice!.prices);
+
+        await balancerV2.releaseResources();
+      });
+
+      it('SELL USDC -> WETH getPoolIdentifiers and getPricesVolume', async function () {
+        const network = Network.BASE;
+        const dexHelper = new DummyDexHelper(network);
+        // const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+        const blocknumber = 24931862;
+        const balancerV2 = new BalancerV2(network, dexKey, dexHelper);
+        const tokens = Tokens[network];
+
+        const amounts = [
+          0n,
+          1000000n,
+          // BI_POWS[6],
+          // 2n * BI_POWS[6],
+          // 3n * BI_POWS[6],
+          // 4n * BI_POWS[6],
+          // 5n * BI_POWS[6],
+          // 6n * BI_POWS[6],
+          // 7n * BI_POWS[6],
+          // 8n * BI_POWS[6],
+          // 9n * BI_POWS[6],
+          // 10n * BI_POWS[6],
+        ];
+
+        await balancerV2.initializePricing(blocknumber);
+
+        const pools = await balancerV2.getPoolIdentifiers(
+          tokens.USDC,
+          tokens.WETH,
+          SwapSide.SELL,
+          blocknumber,
+        );
+        console.log('USDC -> WETH Pool Identifiers (Base): ', pools);
+
+        const isPool = pools.find(poolIdentifier =>
+          poolIdentifier.includes(gyroEAddr),
+        );
+
+        expect(isPool).toBeDefined();
+
+        const poolPrices = await balancerV2.getPricesVolume(
+          tokens.USDC,
+          tokens.WETH,
+          amounts,
+          SwapSide.SELL,
+          blocknumber,
+          pools,
+        );
+        console.log('USDC -> WETH Pool Prices (Base): ', poolPrices);
+
+        expect(poolPrices).not.toBeNull();
+
+        // checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+        const isPoolPrice = poolPrices!.find(price =>
+          price.data.poolId.includes(gyroEAddr),
+        );
+        expect(isPoolPrice).toBeDefined();
+
+        console.log('isPoolPrice: ', isPoolPrice);
+
+        const onChainPrices = await getOnChainPricingForWeightedPool(
+          balancerV2,
+          blocknumber,
+          isPoolPrice!,
+          amounts,
+          tokens.USDC.address,
+          tokens.WETH.address,
+          SwapSide.SELL,
+        );
+
+        console.log('USDC -> WETH on-chain prices: ', onChainPrices);
+
+        expect(onChainPrices).toEqual(isPoolPrice!.prices);
+
+        await balancerV2.releaseResources();
+      });
     });
   });
 });

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

@@ -21,8 +21,7 @@ export const BalancerConfig: DexConfigMap<DexParams> = {
       vaultAddress: '0xBA12222222228d8Ba445958a75a0704d566BF2C8',
     },
     [Network.BASE]: {
-      subgraphURL:
-        'https://api.studio.thegraph.com/query/24660/balancer-base-v2/version/latest',
+      subgraphURL: 'E7XyutxXVLrp8njmjF16Hh38PCJuHm12RRyMt5ma4ctX',
       vaultAddress: '0xBA12222222228d8Ba445958a75a0704d566BF2C8',
     },
     [Network.GNOSIS]: {

package/src/dex/generic-rfq/e2e-test-config.ts

@@ -8,16 +8,16 @@ export const testConfig: {
     amount: string;
   }>;
 } = {
-  [Network.ARBITRUM]: [
+  [Network.MAINNET]: [
     {
-      srcToken: 'WETH',
+      srcToken: 'USDT',
       destToken: 'USDC',
       amount: '10000',
       swapSide: SwapSide.BUY,
     },
     {
       srcToken: 'USDC',
-      destToken: 'WETH',
+      destToken: 'USDT',
       amount: '10000',
       swapSide: SwapSide.SELL,
     },

package/src/dex/generic-rfq/generic-rfq-e2e.test.ts

@@ -115,8 +115,8 @@ describe(`GenericRFQ ${dexKey} E2E`, () => {
               `Please add "addBalance" and "addAllowance" functions for ${testCase.destToken} on ${Network[network]} (in constants-e2e.ts).`,
             );
           }
-          srcToken = smartTokens[testCase.srcToken];
-          destToken = smartTokens[testCase.destToken];
+          srcToken = new SmartToken(tokens[testCase.srcToken]);
+          destToken = new SmartToken(tokens[testCase.destToken]);
 
           srcToken.addBalance(testAccount.address, MAX_UINT);
           srcToken.addAllowance(

package/src/dex/maverick-v1/config.ts

@@ -14,8 +14,7 @@ export const MaverickV1Config: DexConfigMap<DexParams> = {
       poolInspectorAddress: '0xaA5BF61a664109e959D69C38734d4EA7dF74e456',
     },
     [Network.BASE]: {
-      subgraphURL:
-        'https://api.studio.thegraph.com/query/42519/maverick-base/version/latest',
+      subgraphURL: 'CSxkHjxpG1TxTBQMn55uG1DWpdD4Lsix4RNX4RTLvK4T',
       routerAddress: '0x32AED3Bce901DA12ca8489788F3A99fCe1056e14',
       poolInspectorAddress: '0x65A3AD03Be97619284bA7AA1E3Ca05638B9d6364',
     },

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

@@ -117,8 +117,7 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
       chunksCount: 10,
       initRetryFrequency: 10,
       initHash: `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`,
-      subgraphURL:
-        'https://api.studio.thegraph.com/query/48211/uniswap-v3-base/version/latest',
+      subgraphURL: 'GqzP4Xaehti8KSfQmv3ZctFSjnSUYZ4En5NRsiTbvZpz',
     },
   },
   SushiSwapV3: {

package/tests/constants-e2e.ts

@@ -128,7 +128,7 @@ export const Tokens: {
       address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
       decimals: 6,
       symbol: 'USDC',
-      addBalance: balancesFn,
+      addBalance: balanceAndBlacklistStatesFn,
       addAllowance: allowedFn,
     },
     INST: {

package/tests/smart-tokens.ts

@@ -5,9 +5,7 @@ export type StateOverride = {
 };
 
 export type StateSimulateApiOverride = {
-  storage: {
-    value: Record<string, string>;
-  };
+  storage: Record<string, string>;
 };
 
 export type StateOverrides = {