feat(trisolaris): Add Trisolaris integration and fix Bluebit

src/apps/bluebit/aurora/bluebit.farm.contract-position-fetcher.ts

@@ -3,6 +3,7 @@ import { Inject } from '@nestjs/common';
 import { IAppToolkit, APP_TOOLKIT } from '~app-toolkit/app-toolkit.interface';
 import { Register } from '~app-toolkit/decorators';
 import { RewardRateUnit } from '~app-toolkit/helpers/master-chef/master-chef.contract-position-helper';
+import { TRISOLARIS_DEFINITION } from '~apps/trisolaris';
 import { PositionFetcher } from '~position/position-fetcher.interface';
 import { ContractPosition } from '~position/position.interface';
 import { Network } from '~types/network.interface';
@@ -27,13 +28,7 @@ export class AuroraBluebitFarmContractPositionFetcher implements PositionFetcher
       appId,
       groupId,
       network,
-      dependencies: [
-        {
-          appId,
-          groupIds: [BLUEBIT_DEFINITION.groups.vault.id],
-          network,
-        },
-      ],
+      dependencies: [{ appId: TRISOLARIS_DEFINITION.id, groupIds: [TRISOLARIS_DEFINITION.groups.pool.id], network }],
       resolveContract: opts => this.bluebitContractFactory.bluebit(opts),
       resolvePoolLength: async ({ multicall, contract }) => multicall.wrap(contract).poolLength(),
       resolveDepositTokenAddress: async ({ poolIndex, contract, multicall }) => {

src/apps/bluebit/bluebit.module.ts

@@ -4,7 +4,6 @@ import { UniswapV2AppModule } from '~apps/uniswap-v2';
 
 import { AuroraBluebitBalanceFetcher } from './aurora/bluebit.balance-fetcher';
 import { AuroraBluebitFarmContractPositionFetcher } from './aurora/bluebit.farm.contract-position-fetcher';
-import { AuroraBluebitVaultTokenFetcher } from './aurora/bluebit.vault.token-fetcher';
 import { BluebitAppDefinition, BLUEBIT_DEFINITION } from './bluebit.definition';
 import { BluebitContractFactory } from './contracts';
 
@@ -14,7 +13,6 @@ import { BluebitContractFactory } from './contracts';
   providers: [
     AuroraBluebitBalanceFetcher,
     AuroraBluebitFarmContractPositionFetcher,
-    AuroraBluebitVaultTokenFetcher,
     BluebitAppDefinition,
     BluebitContractFactory,
   ],

src/apps/trisolaris/aurora/trisolaris.balance-fetcher.ts

@@ -0,0 +1,82 @@
+import { Inject } from '@nestjs/common';
+
+import { APP_TOOLKIT, IAppToolkit } from '~app-toolkit/app-toolkit.interface';
+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 { TrisolarisContractFactory, TrisolarisMasterChef, TrisolarisRewarder } from '../contracts';
+import { TRISOLARIS_DEFINITION } from '../trisolaris.definition';
+
+const appId = TRISOLARIS_DEFINITION.id;
+const network = Network.AURORA_MAINNET;
+
+@Register.BalanceFetcher(appId, network)
+export class AuroraTrisolarisBalanceFetcher implements BalanceFetcher {
+  constructor(
+    @Inject(APP_TOOLKIT) private readonly appToolkit: IAppToolkit,
+    @Inject(TrisolarisContractFactory) private readonly contractFactory: TrisolarisContractFactory,
+  ) {}
+
+  private async getPoolBalances(address: string) {
+    return this.appToolkit.helpers.tokenBalanceHelper.getTokenBalances({
+      address,
+      appId,
+      network,
+      groupId: TRISOLARIS_DEFINITION.groups.pool.id,
+    });
+  }
+
+  private async getFarmBalances(address: string) {
+    return this.appToolkit.helpers.masterChefContractPositionBalanceHelper.getBalances<TrisolarisMasterChef>({
+      address,
+      appId: TRISOLARIS_DEFINITION.id,
+      groupId: TRISOLARIS_DEFINITION.groups.farm.id,
+      network: Network.AVALANCHE_MAINNET,
+      resolveChefContract: ({ contractAddress, network }) =>
+        this.contractFactory.trisolarisMasterChef({ network, address: contractAddress }),
+      resolveStakedTokenBalance: this.appToolkit.helpers.masterChefDefaultStakedBalanceStrategy.build({
+        resolveStakedBalance: ({ contract, multicall, contractPosition }) =>
+          multicall
+            .wrap(contract)
+            .userInfo(contractPosition.dataProps.poolIndex, address)
+            .then(v => v.amount),
+      }),
+      resolveClaimableTokenBalances: this.appToolkit.helpers.masterChefV2ClaimableBalanceStrategy.build<
+        TrisolarisMasterChef,
+        TrisolarisRewarder
+      >({
+        resolvePrimaryClaimableBalance: ({ multicall, contract, contractPosition, address }) =>
+          multicall.wrap(contract).pendingTri(contractPosition.dataProps.poolIndex, address),
+        resolveRewarderAddress: ({ contract, contractPosition, multicall }) =>
+          multicall.wrap(contract).rewarder(contractPosition.dataProps.poolIndex),
+        resolveRewarderContract: ({ network, rewarderAddress }) =>
+          this.contractFactory.trisolarisRewarder({ address: rewarderAddress, network }),
+        resolveSecondaryClaimableBalance: ({ multicall, rewarderContract, contractPosition, address }) =>
+          multicall
+            .wrap(rewarderContract)
+            .pendingTokens(contractPosition.dataProps.poolIndex, address, 0)
+            .then(v => v[1][0]),
+      }),
+    });
+  }
+
+  async getBalances(address: string) {
+    const [poolBalances, farmBalances] = await Promise.all([
+      this.getPoolBalances(address),
+      this.getFarmBalances(address),
+    ]);
+
+    return presentBalanceFetcherResponse([
+      {
+        label: 'Pools',
+        assets: poolBalances,
+      },
+      {
+        label: 'Farms',
+        assets: farmBalances,
+      },
+    ]);
+  }
+}

src/apps/trisolaris/aurora/trisolaris.farm.contract-position-fetcher.ts

@@ -0,0 +1,66 @@
+import { Inject } from '@nestjs/common';
+
+import { APP_TOOLKIT, IAppToolkit } from '~app-toolkit/app-toolkit.interface';
+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 { TrisolarisMasterChef, TrisolarisRewarder, TrisolarisContractFactory } from '../contracts';
+import TRISOLARIS_DEFINITION from '../trisolaris.definition';
+
+const appId = TRISOLARIS_DEFINITION.id;
+const groupId = TRISOLARIS_DEFINITION.groups.farm.id;
+const network = Network.AURORA_MAINNET;
+
+@Register.ContractPositionFetcher({ appId, groupId, network })
+export class AuroraTrisolarisFarmContractPositionFetcher implements PositionFetcher<ContractPosition> {
+  constructor(
+    @Inject(APP_TOOLKIT) private readonly appToolkit: IAppToolkit,
+    @Inject(TrisolarisContractFactory) private readonly contractFactory: TrisolarisContractFactory,
+  ) {}
+
+  async getPositions() {
+    return this.appToolkit.helpers.masterChefContractPositionHelper.getContractPositions<TrisolarisMasterChef>({
+      address: '0x3838956710bcc9d122dd23863a0549ca8d5675d6',
+      appId,
+      groupId,
+      network,
+      dependencies: [{ appId: TRISOLARIS_DEFINITION.id, groupIds: [TRISOLARIS_DEFINITION.groups.pool.id], network }],
+      resolveContract: ({ address, network }) => this.contractFactory.trisolarisMasterChef({ address, network }),
+      resolvePoolLength: ({ multicall, contract }) => multicall.wrap(contract).poolLength(),
+      resolveDepositTokenAddress: ({ poolIndex, contract, multicall }) => multicall.wrap(contract).lpToken(poolIndex),
+      resolveRewardTokenAddresses: this.appToolkit.helpers.masterChefV2ClaimableTokenStrategy.build<
+        TrisolarisMasterChef,
+        TrisolarisRewarder
+      >({
+        resolvePrimaryClaimableToken: ({ multicall, contract }) => multicall.wrap(contract).TRI(),
+        resolveRewarderAddress: ({ multicall, contract, poolIndex }) => multicall.wrap(contract).rewarder(poolIndex),
+        resolveRewarderContract: ({ network, rewarderAddress }) =>
+          this.contractFactory.trisolarisRewarder({ address: rewarderAddress, network }),
+        resolveSecondaryClaimableToken: ({ multicall, rewarderContract }) =>
+          multicall.wrap(rewarderContract).rewardToken(),
+      }),
+      resolveRewardRate: this.appToolkit.helpers.masterChefV2RewardRateStrategy.build<
+        TrisolarisMasterChef,
+        TrisolarisRewarder
+      >({
+        resolvePoolAllocPoints: async ({ poolIndex, contract, multicall }) =>
+          multicall
+            .wrap(contract)
+            .poolInfo(poolIndex)
+            .then(v => v.allocPoint),
+        resolveTotalAllocPoints: ({ multicall, contract }) => multicall.wrap(contract).totalAllocPoint(),
+        resolvePrimaryTotalRewardRate: async ({ multicall, contract }) => multicall.wrap(contract).triPerBlock(),
+        resolveRewarderAddress: ({ multicall, contract, poolIndex }) => multicall.wrap(contract).rewarder(poolIndex),
+        resolveRewarderContract: ({ network, rewarderAddress }) =>
+          this.contractFactory.trisolarisRewarder({ address: rewarderAddress, network }),
+        resolveSecondaryTotalRewardRate: async ({ multicall, rewarderContract }) =>
+          multicall
+            .wrap(rewarderContract)
+            .tokenPerBlock()
+            .catch(() => '0'),
+      }),
+    });
+  }
+}

src/apps/trisolaris/aurora/trisolaris.pool.cache-manager.ts

@@ -0,0 +1,59 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { compact, range, uniq } from 'lodash';
+
+import { APP_TOOLKIT, IAppToolkit } from '~app-toolkit/app-toolkit.interface';
+import { CacheOnInterval } from '~cache/cache-on-interval.decorator';
+import { Network } from '~types/network.interface';
+
+import { TrisolarisContractFactory } from '../contracts';
+import TRISOLARIS_DEFINITION from '../trisolaris.definition';
+
+@Injectable()
+export class AuroraTrisolarisPoolAddressCacheManager {
+  constructor(
+    @Inject(APP_TOOLKIT) private readonly appToolkit: IAppToolkit,
+    @Inject(TrisolarisContractFactory) protected readonly contractFactory: TrisolarisContractFactory,
+  ) {}
+
+  @CacheOnInterval({
+    key: `apps-v3:${TRISOLARIS_DEFINITION.id}:chef-v2-pool-addresses`,
+    timeout: 15 * 60 * 1000,
+  })
+  private async getChefV2PoolAddresses() {
+    const network = Network.AURORA_MAINNET;
+    const chefAddress = '0x3838956710bcc9d122dd23863a0549ca8d5675d6';
+    const chefContract = this.contractFactory.trisolarisMasterChef({ address: chefAddress, network });
+
+    const provider = this.appToolkit.getNetworkProvider(network);
+    const multicall = this.appToolkit.getMulticall(network);
+    const numPools = await multicall.wrap(chefContract).poolLength();
+
+    const allAddresses = await Promise.all(
+      range(0, Number(numPools)).map(async v => {
+        const lpTokenAddressRaw = await multicall.wrap(chefContract).lpToken(v);
+        const lpTokenAddress = lpTokenAddressRaw.toLowerCase();
+        const lpTokenContract = this.contractFactory.trisolarisPair({ address: lpTokenAddress, network });
+
+        // Some EOAs exist on the MasterChef contract; calling these breaks multicall
+        const code = await provider.getCode(lpTokenAddress);
+        if (code === '0x') return null;
+
+        const isPool = await multicall
+          .wrap(lpTokenContract)
+          .token0()
+          .then(() => true)
+          .catch(() => false);
+        if (!isPool) return null;
+
+        return lpTokenAddress;
+      }),
+    );
+
+    return compact(allAddresses);
+  }
+
+  async getPoolAddresses(): Promise<string[]> {
+    const [chefV2PoolAddresses] = await Promise.all([this.getChefV2PoolAddresses()]);
+    return uniq([...chefV2PoolAddresses]);
+  }
+}

src/apps/trisolaris/aurora/trisolaris.pool.token-fetcher.ts

@@ -0,0 +1,51 @@
+import { Inject } from '@nestjs/common';
+
+import { Register } from '~app-toolkit/decorators';
+import { UniswapV2PoolTokenHelper } from '~apps/uniswap-v2';
+import { PositionFetcher } from '~position/position-fetcher.interface';
+import { AppTokenPosition } from '~position/position.interface';
+import { Network } from '~types/network.interface';
+
+import { TrisolarisContractFactory } from '../contracts';
+import { TrisolarisFactory } from '../contracts/ethers/TrisolarisFactory';
+import { TrisolarisPair } from '../contracts/ethers/TrisolarisPair';
+import TRISOLARIS_DEFINITION from '../trisolaris.definition';
+
+import { AuroraTrisolarisPoolAddressCacheManager } from './trisolaris.pool.cache-manager';
+
+const appId = TRISOLARIS_DEFINITION.id;
+const groupId = TRISOLARIS_DEFINITION.groups.pool.id;
+const network = Network.AURORA_MAINNET;
+
+@Register.TokenPositionFetcher({ appId, groupId, network, options: { includeInTvl: true } })
+export class AuroraTrisolarisPoolTokenFetcher implements PositionFetcher<AppTokenPosition> {
+  constructor(
+    @Inject(UniswapV2PoolTokenHelper)
+    private readonly poolTokenHelper: UniswapV2PoolTokenHelper,
+    @Inject(AuroraTrisolarisPoolAddressCacheManager)
+    private readonly addressCacheManager: AuroraTrisolarisPoolAddressCacheManager,
+    @Inject(TrisolarisContractFactory) private readonly contractFactory: TrisolarisContractFactory,
+  ) {}
+
+  getPositions() {
+    return this.poolTokenHelper.getTokens<TrisolarisFactory, TrisolarisPair>({
+      network,
+      appId,
+      groupId,
+      fee: 0.003,
+      factoryAddress: '0xc66f594268041db60507f00703b152492fb176e7',
+      resolveFactoryContract: opts => this.contractFactory.trisolarisFactory(opts),
+      resolvePoolContract: opts => this.contractFactory.trisolarisPair(opts),
+      resolvePoolTokenAddresses: () => this.addressCacheManager.getPoolAddresses(),
+      resolvePoolTokenSymbol: ({ multicall, poolContract }) => multicall.wrap(poolContract).symbol(),
+      resolvePoolTokenSupply: ({ multicall, poolContract }) => multicall.wrap(poolContract).totalSupply(),
+      resolvePoolReserves: async ({ multicall, poolContract }) => {
+        const reserves = await multicall.wrap(poolContract).getReserves();
+        return [reserves[0], reserves[1]];
+      },
+      resolvePoolUnderlyingTokenAddresses: async ({ multicall, poolContract }) => {
+        return Promise.all([multicall.wrap(poolContract).token0(), multicall.wrap(poolContract).token1()]);
+      },
+    });
+  }
+}