feat: Add missing Balancer-v2 farms in Polygon and Arbitrum

src/apps/balancer-v2/arbitrum/balancer-v2.balance-fetcher.ts

@@ -1,12 +1,13 @@
 import { Inject } from '@nestjs/common';
 
-import { TokenBalanceHelper } from '~app-toolkit';
+import { SingleStakingContractPositionBalanceHelper, TokenBalanceHelper } from '~app-toolkit';
 import { Register } from '~app-toolkit/decorators';
 import { presentBalanceFetcherResponse } from '~app-toolkit/helpers/presentation/balance-fetcher-response.present';
 import { BalanceFetcher } from '~balance/balance-fetcher.interface';
 import { Network } from '~types/network.interface';
 
 import { BALANCER_V2_DEFINITION } from '../balancer-v2.definition';
+import { BalancerGauge, BalancerV2ContractFactory } from '../contracts';
 import { BalancerV2ClaimableContractPositionBalanceHelper } from '../helpers/balancer-v2.claimable.contract-position-balance-helper';
 
 const appId = BALANCER_V2_DEFINITION.id;
@@ -15,11 +16,27 @@ const network = Network.ARBITRUM_MAINNET;
 @Register.BalanceFetcher(appId, network)
 export class ArbitrumBalancerV2BalanceFetcher implements BalanceFetcher {
   constructor(
+    @Inject(SingleStakingContractPositionBalanceHelper)
+    private readonly singleStakingContractPositionBalanceHelper: SingleStakingContractPositionBalanceHelper,
     @Inject(TokenBalanceHelper) private readonly tokenBalanceHelper: TokenBalanceHelper,
     @Inject(BalancerV2ClaimableContractPositionBalanceHelper)
     private readonly balancerV2ClaimableContractPositionBalanceHelper: BalancerV2ClaimableContractPositionBalanceHelper,
+    @Inject(BalancerV2ContractFactory)
+    private readonly balancerV2ContractFactory: BalancerV2ContractFactory,
   ) {}
 
+  async getStakedBalances(address: string) {
+    return this.singleStakingContractPositionBalanceHelper.getBalances<BalancerGauge>({
+      address,
+      network,
+      appId,
+      groupId: BALANCER_V2_DEFINITION.groups.farm.id,
+      resolveContract: ({ address, network }) => this.balancerV2ContractFactory.balancerGauge({ address, network }),
+      resolveStakedTokenBalance: ({ contract, address, multicall }) => multicall.wrap(contract).balanceOf(address),
+      resolveRewardTokenBalances: () => [],
+    });
+  }
+
   async getPoolBalances(address: string) {
     return this.tokenBalanceHelper.getTokenBalances({
       address,
@@ -37,8 +54,9 @@ export class ArbitrumBalancerV2BalanceFetcher implements BalanceFetcher {
   }
 
   async getBalances(address: string) {
-    const [poolBalances, claimableBalances] = await Promise.all([
+    const [poolBalances, stakedBalances, claimableBalances] = await Promise.all([
       this.getPoolBalances(address),
+      this.getStakedBalances(address),
       this.getClaimableBalances(address),
     ]);
 
@@ -47,6 +65,10 @@ export class ArbitrumBalancerV2BalanceFetcher implements BalanceFetcher {
         label: 'Pools',
         assets: poolBalances,
       },
+      {
+        label: 'Staked',
+        assets: stakedBalances,
+      },
       {
         label: 'Claimable',
         assets: claimableBalances,

src/apps/balancer-v2/arbitrum/balancer-v2.staked.contract-position-fetcher.ts

@@ -0,0 +1,48 @@
+import { Inject } from '@nestjs/common';
+
+import { SingleStakingFarmContractPositionHelper } from '~app-toolkit';
+import { Register } from '~app-toolkit/decorators';
+import { PositionFetcher } from '~position/position-fetcher.interface';
+import { ContractPosition } from '~position/position.interface';
+import { Network } from '~types/network.interface';
+
+import { BALANCER_V2_DEFINITION } from '../balancer-v2.definition';
+import { BalancerGauge, BalancerV2ContractFactory } from '../contracts';
+import { BalancerV2GaugeAddressesGetter } from '../helpers/balancer-v2.gauge-addresses-getter';
+
+const appId = BALANCER_V2_DEFINITION.id;
+const groupId = BALANCER_V2_DEFINITION.groups.farm.id;
+const network = Network.ARBITRUM_MAINNET;
+
+@Register.ContractPositionFetcher({ appId, groupId, network })
+export class ArbitrumBalancerV2StakedfContractPositionFetcher implements PositionFetcher<ContractPosition> {
+  constructor(
+    @Inject(BalancerV2ContractFactory)
+    private readonly balancerV2ContractFactory: BalancerV2ContractFactory,
+    @Inject(BalancerV2GaugeAddressesGetter)
+    private readonly balancerV2GaugeAddressesGetter: BalancerV2GaugeAddressesGetter,
+    @Inject(SingleStakingFarmContractPositionHelper)
+    private readonly curveStakingHelper: SingleStakingFarmContractPositionHelper,
+  ) {}
+
+  async getPositions() {
+    const farms = await this.balancerV2GaugeAddressesGetter.getGauges({ network });
+    return await this.curveStakingHelper.getContractPositions<BalancerGauge>({
+      network,
+      appId,
+      groupId,
+      dependencies: [
+        {
+          appId: BALANCER_V2_DEFINITION.id,
+          groupIds: [BALANCER_V2_DEFINITION.groups.pool.id],
+          network,
+        },
+      ],
+      resolveFarmAddresses: () => farms.map(farm => farm.address),
+      resolveFarmContract: ({ address, network }) => this.balancerV2ContractFactory.balancerGauge({ address, network }),
+      resolveStakedTokenAddress: ({ contract, multicall }) => multicall.wrap(contract).lp_token(),
+      resolveRewardTokenAddresses: async () => [],
+      resolveRois: async () => ({ dailyROI: 0, weeklyROI: 0, yearlyROI: 0 }),
+    });
+  }
+}

src/apps/balancer-v2/balancer-v2.module.ts

@@ -4,6 +4,7 @@ import { CurveAppModule } from '~apps/curve';
 
 import { ArbitrumBalancerV2BalanceFetcher } from './arbitrum/balancer-v2.balance-fetcher';
 import { ArbitrumBalancerV2PoolTokenFetcher } from './arbitrum/balancer-v2.pool.token-fetcher';
+import { ArbitrumBalancerV2StakedfContractPositionFetcher } from './arbitrum/balancer-v2.staked.contract-position-fetcher';
 import BALANCER_V2_DEFINITION, { BalancerV2AppDefinition } from './balancer-v2.definition';
 import { BalancerV2ContractFactory } from './contracts';
 import { EthereumBalancerV2BalanceFetcher } from './ethereum/balancer-v2.balance-fetcher';
@@ -19,6 +20,7 @@ import { BalancerV2SpotPriceHelper } from './helpers/balancer-v2.spot-price.help
 import { BalancerV2TheGraphPoolTokenDataStrategy } from './helpers/balancer-v2.the-graph.pool-token-address-strategy';
 import { PolygonBalancerV2BalanceFetcher } from './polygon/balancer-v2.balance-fetcher';
 import { PolygonBalancerV2PoolTokenFetcher } from './polygon/balancer-v2.pool.token-fetcher';
+import { PolygonBalancerV2StakedfContractPositionFetcher } from './polygon/balancer-v2.staked.contract-position-fetcher';
 
 @Register.AppModule({
   appId: BALANCER_V2_DEFINITION.id,
@@ -29,6 +31,7 @@ import { PolygonBalancerV2PoolTokenFetcher } from './polygon/balancer-v2.pool.to
     // Arbitrum
     ArbitrumBalancerV2BalanceFetcher,
     ArbitrumBalancerV2PoolTokenFetcher,
+    ArbitrumBalancerV2StakedfContractPositionFetcher,
     // Ethereum
     EthereumBalancerV2BalanceFetcher,
     EthereumBalancerV2PoolTokenFetcher,
@@ -37,6 +40,7 @@ import { PolygonBalancerV2PoolTokenFetcher } from './polygon/balancer-v2.pool.to
     // Polygon
     PolygonBalancerV2BalanceFetcher,
     PolygonBalancerV2PoolTokenFetcher,
+    PolygonBalancerV2StakedfContractPositionFetcher,
     // Helpers
     BalancerV2CacheManager,
     BalancerV2PoolTokensHelper,

src/apps/balancer-v2/ethereum/balancer-v2.staked.contract-position-fetcher.ts

@@ -26,7 +26,6 @@ export class EthereumBalancerV2StakedfContractPositionFetcher implements Positio
   ) {}
 
   async getPositions() {
-    const network = Network.ETHEREUM_MAINNET;
     const farms = await this.balancerV2GaugeAddressesGetter.getGauges({ network });
     return await this.curveStakingHelper.getContractPositions<BalancerGauge>({
       network,

src/apps/balancer-v2/polygon/balancer-v2.balance-fetcher.ts

@@ -1,19 +1,38 @@
 import { Inject } from '@nestjs/common';
 
-import { TokenBalanceHelper } from '~app-toolkit';
+import { SingleStakingContractPositionBalanceHelper, TokenBalanceHelper } from '~app-toolkit';
 import { Register } from '~app-toolkit/decorators';
 import { presentBalanceFetcherResponse } from '~app-toolkit/helpers/presentation/balance-fetcher-response.present';
 import { BalanceFetcher } from '~balance/balance-fetcher.interface';
 import { Network } from '~types/network.interface';
 
 import { BALANCER_V2_DEFINITION } from '../balancer-v2.definition';
+import { BalancerGauge, BalancerV2ContractFactory } from '../contracts';
 
 const appId = BALANCER_V2_DEFINITION.id;
 const network = Network.POLYGON_MAINNET;
 
 @Register.BalanceFetcher(appId, network)
 export class PolygonBalancerV2BalanceFetcher implements BalanceFetcher {
-  constructor(@Inject(TokenBalanceHelper) private readonly tokenBalanceHelper: TokenBalanceHelper) {}
+  constructor(
+    @Inject(TokenBalanceHelper) private readonly tokenBalanceHelper: TokenBalanceHelper,
+    @Inject(BalancerV2ContractFactory)
+    private readonly balancerV2ContractFactory: BalancerV2ContractFactory,
+    @Inject(SingleStakingContractPositionBalanceHelper)
+    private readonly singleStakingContractPositionBalanceHelper: SingleStakingContractPositionBalanceHelper,
+  ) {}
+
+  async getStakedBalances(address: string) {
+    return this.singleStakingContractPositionBalanceHelper.getBalances<BalancerGauge>({
+      address,
+      network,
+      appId,
+      groupId: BALANCER_V2_DEFINITION.groups.farm.id,
+      resolveContract: ({ address, network }) => this.balancerV2ContractFactory.balancerGauge({ address, network }),
+      resolveStakedTokenBalance: ({ contract, address, multicall }) => multicall.wrap(contract).balanceOf(address),
+      resolveRewardTokenBalances: () => [],
+    });
+  }
 
   async getPoolBalances(address: string) {
     return this.tokenBalanceHelper.getTokenBalances({
@@ -25,13 +44,20 @@ export class PolygonBalancerV2BalanceFetcher implements BalanceFetcher {
   }
 
   async getBalances(address: string) {
-    const [poolBalances] = await Promise.all([this.getPoolBalances(address)]);
+    const [poolBalances, stakedBalances] = await Promise.all([
+      this.getPoolBalances(address),
+      this.getStakedBalances(address),
+    ]);
 
     return presentBalanceFetcherResponse([
       {
         label: 'Pools',
         assets: poolBalances,
       },
+      {
+        label: 'Staked',
+        assets: stakedBalances,
+      },
     ]);
   }
 }

src/apps/balancer-v2/polygon/balancer-v2.staked.contract-position-fetcher.ts

@@ -0,0 +1,48 @@
+import { Inject } from '@nestjs/common';
+
+import { SingleStakingFarmContractPositionHelper } from '~app-toolkit';
+import { Register } from '~app-toolkit/decorators';
+import { PositionFetcher } from '~position/position-fetcher.interface';
+import { ContractPosition } from '~position/position.interface';
+import { Network } from '~types/network.interface';
+
+import { BALANCER_V2_DEFINITION } from '../balancer-v2.definition';
+import { BalancerGauge, BalancerV2ContractFactory } from '../contracts';
+import { BalancerV2GaugeAddressesGetter } from '../helpers/balancer-v2.gauge-addresses-getter';
+
+const appId = BALANCER_V2_DEFINITION.id;
+const groupId = BALANCER_V2_DEFINITION.groups.farm.id;
+const network = Network.POLYGON_MAINNET;
+
+@Register.ContractPositionFetcher({ appId, groupId, network })
+export class PolygonBalancerV2StakedfContractPositionFetcher implements PositionFetcher<ContractPosition> {
+  constructor(
+    @Inject(BalancerV2ContractFactory)
+    private readonly balancerV2ContractFactory: BalancerV2ContractFactory,
+    @Inject(BalancerV2GaugeAddressesGetter)
+    private readonly balancerV2GaugeAddressesGetter: BalancerV2GaugeAddressesGetter,
+    @Inject(SingleStakingFarmContractPositionHelper)
+    private readonly curveStakingHelper: SingleStakingFarmContractPositionHelper,
+  ) {}
+
+  async getPositions() {
+    const farms = await this.balancerV2GaugeAddressesGetter.getGauges({ network });
+    return await this.curveStakingHelper.getContractPositions<BalancerGauge>({
+      network,
+      appId,
+      groupId,
+      dependencies: [
+        {
+          appId: BALANCER_V2_DEFINITION.id,
+          groupIds: [BALANCER_V2_DEFINITION.groups.pool.id],
+          network,
+        },
+      ],
+      resolveFarmAddresses: () => farms.map(farm => farm.address),
+      resolveFarmContract: ({ address, network }) => this.balancerV2ContractFactory.balancerGauge({ address, network }),
+      resolveStakedTokenAddress: ({ contract, multicall }) => multicall.wrap(contract).lp_token(),
+      resolveRewardTokenAddresses: async () => [],
+      resolveRois: async () => ({ dailyROI: 0, weeklyROI: 0, yearlyROI: 0 }),
+    });
+  }
+}