Chores

balancer-js/src/lib/constants/config.ts

@@ -409,6 +409,7 @@ export const BALANCER_NETWORK_CONFIG: Record<Network, BalancerNetworkConfig> = {
       },
     },
     averageBlockTime: 4,
+    multicallBatchSize: 128,
     pools: {},
     poolsToIgnore: [],
     sorConnectingTokens: [

balancer-js/src/modules/data/index.ts

@@ -99,7 +99,8 @@ export class Data implements BalancerDataRepositories {
         multicall: networkConfig.addresses.contracts.multicall,
         vault: networkConfig.addresses.contracts.vault,
       },
-      networkConfig.poolsToIgnore
+      networkConfig.poolsToIgnore,
+      networkConfig.multicallBatchSize
     );
 
     this.poolShares = new PoolSharesRepository(

balancer-js/src/modules/data/pool/onchain-data.ts

@@ -3,6 +3,7 @@ import { SubgraphPoolBase } from '@/.';
 import { Provider } from '@ethersproject/providers';
 import { formatFixed } from '@ethersproject/bignumber';
 import { SubgraphToken } from '@balancer-labs/sor';
+import { PoolToken, Pool } from '@/types';
 
 const abi = [
   'function getSwapFeePercentage() view returns (uint256)',
@@ -43,6 +44,11 @@ const getSwapFeeFn = (poolType: string) => {
   }
 };
 
+type GenericToken = SubgraphToken | PoolToken;
+type GenericPool = Omit<SubgraphPoolBase | Pool, 'tokens'> & {
+  tokens: GenericToken[];
+};
+
 interface OnchainData {
   poolTokens: [string[], string[]];
   totalShares: string;
@@ -133,7 +139,7 @@ const poolTypeCalls = (poolType: string, poolTypeVersion = 1) => {
   }
 };
 
-const merge = (pool: SubgraphPoolBase, result: OnchainData) => ({
+const merge = <T extends GenericPool>(pool: T, result: OnchainData) => ({
   ...pool,
   tokens: result.poolTokens
     ? pool.tokens.map((token) => {
@@ -188,7 +194,8 @@ export const fetchOnChainPoolData = async (
     poolTypeVersion?: number;
   }[],
   vaultAddress: string,
-  provider: Provider
+  provider: Provider,
+  batchSize = 1024
 ): Promise<{ [id: string]: OnchainData }> => {
   if (pools.length === 0) {
     return {};
@@ -201,28 +208,29 @@ export const fetchOnChainPoolData = async (
     poolTypeCalls(poolType, poolTypeVersion)(id, address, multicaller);
   });
 
-  // ZkEVM needs a smaller batch size
-  const results = (await multicaller.execute({}, 128)) as {
+  const results = (await multicaller.execute({}, batchSize)) as {
     [id: string]: OnchainData;
   };
 
   return results;
 };
 
-export async function getOnChainBalances(
-  subgraphPoolsOriginal: SubgraphPoolBase[],
+export async function getOnChainBalances<T extends GenericPool>(
+  subgraphPoolsOriginal: T[],
   _multiAddress: string,
   vaultAddress: string,
-  provider: Provider
-): Promise<SubgraphPoolBase[]> {
+  provider: Provider,
+  batchSize = 1024
+): Promise<T[]> {
   if (subgraphPoolsOriginal.length === 0) return subgraphPoolsOriginal;
 
-  const poolsWithOnchainData: SubgraphPoolBase[] = [];
+  const poolsWithOnchainData: T[] = [];
 
   const onchainData = (await fetchOnChainPoolData(
     subgraphPoolsOriginal,
     vaultAddress,
-    provider
+    provider,
+    batchSize
   )) as { [id: string]: OnchainData };
 
   subgraphPoolsOriginal.forEach((pool) => {

balancer-js/src/modules/data/pool/subgraphOnChain.ts

@@ -2,7 +2,7 @@ import { Cacheable, Findable, Searchable } from '../types';
 import { Provider } from '@ethersproject/providers';
 import { PoolAttribute, PoolsRepositoryFetchOptions } from './types';
 import { Pool } from '@/types';
-import { getOnChainBalances } from '../../../modules/sor/pool-data/onChainData';
+import { getOnChainBalances } from '../../../modules/sor/pool-data/onChainData3';
 import { PoolsSubgraphRepository } from './subgraph';
 import { isSameAddress } from '@/lib/utils';
 import { Logger } from '@/lib/utils/logger';
@@ -34,7 +34,8 @@ export class PoolsSubgraphOnChainRepository
   constructor(
     private poolsSubgraph: PoolsSubgraphRepository,
     options: PoolsSubgraphOnChainRepositoryOptions,
-    private readonly poolsToIgnore: string[] | undefined
+    private readonly poolsToIgnore: string[] | undefined,
+    private batchSize?: number
   ) {
     this.provider = options.provider;
     this.multicall = options.multicall;
@@ -70,7 +71,8 @@ export class PoolsSubgraphOnChainRepository
       filteredPools,
       this.multicall,
       this.vault,
-      this.provider
+      this.provider,
+      this.batchSize
     );
 
     logger.timeEnd(`fetching onchain ${filteredPools.length} pools`);
@@ -89,7 +91,8 @@ export class PoolsSubgraphOnChainRepository
       filteredPools,
       this.multicall,
       this.vault,
-      this.provider
+      this.provider,
+      this.batchSize
     );
 
     logger.timeEnd(`fetching onchain ${filteredPools.length} pools`);

balancer-js/src/modules/liquidity-managment/migrations.integrations.spec.ts

@@ -301,29 +301,29 @@ describe('Migrations', function () {
         });
       });
     });
+  });
 
-    context('polygon', () => {
-      const { approveRelayer, impersonate, runPool2Pool } = migrations(
-        Network.POLYGON
-      );
+  context('polygon', () => {
+    const { approveRelayer, impersonate, runPool2Pool } = migrations(
+      Network.POLYGON
+    );
 
-      beforeEach(() => approveRelayer());
+    beforeEach(() => approveRelayer());
 
-      context('ComposableStable to ComposableStable', () => {
-        before(() => impersonate('0xe80a6a7b4fdadf0aa59f3f669a8d394d1d4da86b'));
+    context('ComposableStable to ComposableStable', () => {
+      before(() => impersonate('0xe80a6a7b4fdadf0aa59f3f669a8d394d1d4da86b'));
 
-        it('should build a migration using exit / join', async () => {
-          const { balanceAfter, minBptOut } = await runPool2Pool(
-            polygonComposableStable,
-            polygonComposableStable
-          );
+      it('should build a migration using exit / join', async () => {
+        const { balanceAfter, minBptOut } = await runPool2Pool(
+          polygonComposableStable,
+          polygonComposableStable
+        );
 
-          // NOTICE: We don't know the exact amount of BPT that will be minted,
-          // because swaps from the linear pool are not deterministic due to external rates
-          expect(BigInt(balanceAfter)).to.satisfy(
-            (v: bigint) => v > BigInt(minBptOut)
-          );
-        });
+        // NOTICE: We don't know the exact amount of BPT that will be minted,
+        // because swaps from the linear pool are not deterministic due to external rates
+        expect(BigInt(balanceAfter)).to.satisfy(
+          (v: bigint) => v > BigInt(minBptOut)
+        );
       });
     });
   });

balancer-js/src/modules/sor/pool-data/subgraphPoolDataService.ts

@@ -95,7 +95,8 @@ export class SubgraphPoolDataService implements PoolDataService {
       mapped,
       this.network.addresses.contracts.multicall,
       this.network.addresses.contracts.vault,
-      this.provider
+      this.provider,
+      this.network.multicallBatchSize
     );
 
     logger.timeEnd(`fetching on-chain balances for ${mapped.length} pools`);