feat(stargate): Extract Stargate to Studio (#943)

src/apps/stargate/arbitrum/stargate.balance-fetcher.ts

@@ -0,0 +1,69 @@
+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 { StargateChef, StargateContractFactory } from '../contracts';
+import { STARGATE_DEFINITION } from '../stargate.definition';
+
+const network = Network.ARBITRUM_MAINNET;
+
+@Register.BalanceFetcher(STARGATE_DEFINITION.id, network)
+export class ArbitrumStargateBalanceFetcher implements BalanceFetcher {
+  constructor(
+    @Inject(APP_TOOLKIT) private readonly appToolkit: IAppToolkit,
+    @Inject(StargateContractFactory) private readonly contractFactory: StargateContractFactory,
+  ) {}
+
+  async getPoolTokenBalances(address: string) {
+    return this.appToolkit.helpers.tokenBalanceHelper.getTokenBalances({
+      address,
+      appId: STARGATE_DEFINITION.id,
+      groupId: STARGATE_DEFINITION.groups.pool.id,
+      network,
+    });
+  }
+
+  async getStakedBalances(address: string) {
+    return this.appToolkit.helpers.masterChefContractPositionBalanceHelper.getBalances<StargateChef>({
+      address,
+      appId: STARGATE_DEFINITION.id,
+      groupId: STARGATE_DEFINITION.groups.farm.id,
+      network,
+      resolveChefContract: ({ contractAddress }) =>
+        this.contractFactory.stargateChef({ 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.masterChefDefaultClaimableBalanceStrategy.build({
+        resolveClaimableBalance: ({ multicall, contract, contractPosition, address }) =>
+          multicall.wrap(contract).pendingStargate(contractPosition.dataProps.poolIndex, address),
+      }),
+    });
+  }
+
+  async getBalances(address: string) {
+    const [poolTokenBalances, stakedBalances] = await Promise.all([
+      this.getPoolTokenBalances(address),
+      this.getStakedBalances(address),
+    ]);
+
+    return presentBalanceFetcherResponse([
+      {
+        label: 'Pools',
+        assets: poolTokenBalances,
+      },
+      {
+        label: 'Farms',
+        assets: stakedBalances,
+      },
+    ]);
+  }
+}

src/apps/stargate/arbitrum/stargate.farm.contract-position-fetcher.ts

@@ -0,0 +1,49 @@
+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 { StargateChef, StargateContractFactory } from '../contracts';
+import { STARGATE_DEFINITION } from '../stargate.definition';
+
+const appId = STARGATE_DEFINITION.id;
+const groupId = STARGATE_DEFINITION.groups.farm.id;
+const network = Network.ARBITRUM_MAINNET;
+
+@Register.ContractPositionFetcher({ appId, groupId, network })
+export class ArbitrumStargateFarmContractPositionFetcher implements PositionFetcher<ContractPosition> {
+  constructor(
+    @Inject(APP_TOOLKIT) private readonly appToolkit: IAppToolkit,
+    @Inject(StargateContractFactory) private readonly contractFactory: StargateContractFactory,
+  ) {}
+
+  async getPositions() {
+    return this.appToolkit.helpers.masterChefContractPositionHelper.getContractPositions<StargateChef>({
+      address: '0xea8dfee1898a7e0a59f7527f076106d7e44c2176',
+      appId,
+      groupId,
+      network,
+      dependencies: [{ appId: STARGATE_DEFINITION.id, groupIds: [STARGATE_DEFINITION.groups.pool.id], network }],
+      resolveContract: ({ address, network }) => this.contractFactory.stargateChef({ address, network }),
+      resolvePoolLength: ({ multicall, contract }) => multicall.wrap(contract).poolLength(),
+      resolveDepositTokenAddress: ({ poolIndex, contract, multicall }) =>
+        multicall
+          .wrap(contract)
+          .poolInfo(poolIndex)
+          .then(v => v.lpToken),
+      resolveRewardTokenAddresses: ({ multicall, contract }) => multicall.wrap(contract).stargate(),
+      resolveRewardRate: this.appToolkit.helpers.masterChefDefaultRewardsPerBlockStrategy.build({
+        resolvePoolAllocPoints: async ({ poolIndex, contract, multicall }) =>
+          multicall
+            .wrap(contract)
+            .poolInfo(poolIndex)
+            .then(v => v.allocPoint),
+        resolveTotalAllocPoints: ({ multicall, contract }) => multicall.wrap(contract).totalAllocPoint(),
+        resolveTotalRewardRate: ({ multicall, contract }) => multicall.wrap(contract).stargatePerBlock(),
+      }),
+    });
+  }
+}

src/apps/stargate/arbitrum/stargate.pool.token-fetcher.ts

@@ -0,0 +1,25 @@
+import { Inject } from '@nestjs/common';
+
+import { Register } from '~app-toolkit/decorators';
+import { PositionFetcher } from '~position/position-fetcher.interface';
+import { AppTokenPosition } from '~position/position.interface';
+import { Network } from '~types/network.interface';
+
+import { StargatePoolTokenHelper } from '../helpers/stargate.pool.token-helper';
+import { STARGATE_DEFINITION } from '../stargate.definition';
+
+const appId = STARGATE_DEFINITION.id;
+const groupId = STARGATE_DEFINITION.groups.pool.id;
+const network = Network.ARBITRUM_MAINNET;
+
+@Register.TokenPositionFetcher({ appId, groupId, network })
+export class ArbitrumStargatePoolTokenFetcher implements PositionFetcher<AppTokenPosition> {
+  constructor(@Inject(StargatePoolTokenHelper) private readonly stargatePoolTokenHelper: StargatePoolTokenHelper) {}
+
+  async getPositions() {
+    return this.stargatePoolTokenHelper.getPositions({
+      factoryAddress: '0x55bdb4164d28fbaf0898e0ef14a589ac09ac9970',
+      network,
+    });
+  }
+}

src/apps/stargate/avalanche/stargate.balance-fetcher.ts

@@ -0,0 +1,69 @@
+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 { StargateChef, StargateContractFactory } from '../contracts';
+import { STARGATE_DEFINITION } from '../stargate.definition';
+
+const network = Network.AVALANCHE_MAINNET;
+
+@Register.BalanceFetcher(STARGATE_DEFINITION.id, network)
+export class AvalancheStargateBalanceFetcher implements BalanceFetcher {
+  constructor(
+    @Inject(APP_TOOLKIT) private readonly appToolkit: IAppToolkit,
+    @Inject(StargateContractFactory) private readonly contractFactory: StargateContractFactory,
+  ) {}
+
+  async getPoolTokenBalances(address: string) {
+    return this.appToolkit.helpers.tokenBalanceHelper.getTokenBalances({
+      address,
+      appId: STARGATE_DEFINITION.id,
+      groupId: STARGATE_DEFINITION.groups.pool.id,
+      network,
+    });
+  }
+
+  async getStakedBalances(address: string) {
+    return this.appToolkit.helpers.masterChefContractPositionBalanceHelper.getBalances<StargateChef>({
+      address,
+      appId: STARGATE_DEFINITION.id,
+      groupId: STARGATE_DEFINITION.groups.farm.id,
+      network,
+      resolveChefContract: ({ contractAddress }) =>
+        this.contractFactory.stargateChef({ 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.masterChefDefaultClaimableBalanceStrategy.build({
+        resolveClaimableBalance: ({ multicall, contract, contractPosition, address }) =>
+          multicall.wrap(contract).pendingStargate(contractPosition.dataProps.poolIndex, address),
+      }),
+    });
+  }
+
+  async getBalances(address: string) {
+    const [poolTokenBalances, stakedBalances] = await Promise.all([
+      this.getPoolTokenBalances(address),
+      this.getStakedBalances(address),
+    ]);
+
+    return presentBalanceFetcherResponse([
+      {
+        label: 'Pools',
+        assets: poolTokenBalances,
+      },
+      {
+        label: 'Farms',
+        assets: stakedBalances,
+      },
+    ]);
+  }
+}

src/apps/stargate/avalanche/stargate.farm.contract-position-fetcher.ts

@@ -0,0 +1,49 @@
+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 { StargateChef, StargateContractFactory } from '../contracts';
+import { STARGATE_DEFINITION } from '../stargate.definition';
+
+const appId = STARGATE_DEFINITION.id;
+const groupId = STARGATE_DEFINITION.groups.farm.id;
+const network = Network.AVALANCHE_MAINNET;
+
+@Register.ContractPositionFetcher({ appId, groupId, network })
+export class AvalancheStargateFarmContractPositionFetcher implements PositionFetcher<ContractPosition> {
+  constructor(
+    @Inject(APP_TOOLKIT) private readonly appToolkit: IAppToolkit,
+    @Inject(StargateContractFactory) private readonly contractFactory: StargateContractFactory,
+  ) {}
+
+  async getPositions() {
+    return this.appToolkit.helpers.masterChefContractPositionHelper.getContractPositions<StargateChef>({
+      address: '0x8731d54e9d02c286767d56ac03e8037c07e01e98',
+      appId,
+      groupId,
+      network,
+      dependencies: [{ appId: STARGATE_DEFINITION.id, groupIds: [STARGATE_DEFINITION.groups.pool.id], network }],
+      resolveContract: ({ address, network }) => this.contractFactory.stargateChef({ address, network }),
+      resolvePoolLength: ({ multicall, contract }) => multicall.wrap(contract).poolLength(),
+      resolveDepositTokenAddress: ({ poolIndex, contract, multicall }) =>
+        multicall
+          .wrap(contract)
+          .poolInfo(poolIndex)
+          .then(v => v.lpToken),
+      resolveRewardTokenAddresses: ({ multicall, contract }) => multicall.wrap(contract).stargate(),
+      resolveRewardRate: this.appToolkit.helpers.masterChefDefaultRewardsPerBlockStrategy.build({
+        resolvePoolAllocPoints: async ({ poolIndex, contract, multicall }) =>
+          multicall
+            .wrap(contract)
+            .poolInfo(poolIndex)
+            .then(v => v.allocPoint),
+        resolveTotalAllocPoints: ({ multicall, contract }) => multicall.wrap(contract).totalAllocPoint(),
+        resolveTotalRewardRate: ({ multicall, contract }) => multicall.wrap(contract).stargatePerBlock(),
+      }),
+    });
+  }
+}

src/apps/stargate/avalanche/stargate.pool.token-fetcher.ts

@@ -0,0 +1,25 @@
+import { Inject } from '@nestjs/common';
+
+import { Register } from '~app-toolkit/decorators';
+import { PositionFetcher } from '~position/position-fetcher.interface';
+import { AppTokenPosition } from '~position/position.interface';
+import { Network } from '~types/network.interface';
+
+import { StargatePoolTokenHelper } from '../helpers/stargate.pool.token-helper';
+import { STARGATE_DEFINITION } from '../stargate.definition';
+
+const appId = STARGATE_DEFINITION.id;
+const groupId = STARGATE_DEFINITION.groups.pool.id;
+const network = Network.AVALANCHE_MAINNET;
+
+@Register.TokenPositionFetcher({ appId, groupId, network })
+export class AvalancheStargatePoolTokenFetcher implements PositionFetcher<AppTokenPosition> {
+  constructor(@Inject(StargatePoolTokenHelper) private readonly stargatePoolTokenHelper: StargatePoolTokenHelper) {}
+
+  async getPositions() {
+    return this.stargatePoolTokenHelper.getPositions({
+      factoryAddress: '0x808d7c71ad2ba3fa531b068a2417c63106bc0949',
+      network,
+    });
+  }
+}

src/apps/stargate/binance-smart-chain/stargate.balance-fetcher.ts

@@ -0,0 +1,69 @@
+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 { StargateChef, StargateContractFactory } from '../contracts';
+import { STARGATE_DEFINITION } from '../stargate.definition';
+
+const network = Network.BINANCE_SMART_CHAIN_MAINNET;
+
+@Register.BalanceFetcher(STARGATE_DEFINITION.id, network)
+export class BinanceSmartChainStargateBalanceFetcher implements BalanceFetcher {
+  constructor(
+    @Inject(APP_TOOLKIT) private readonly appToolkit: IAppToolkit,
+    @Inject(StargateContractFactory) private readonly contractFactory: StargateContractFactory,
+  ) {}
+
+  async getPoolTokenBalances(address: string) {
+    return this.appToolkit.helpers.tokenBalanceHelper.getTokenBalances({
+      address,
+      appId: STARGATE_DEFINITION.id,
+      groupId: STARGATE_DEFINITION.groups.pool.id,
+      network,
+    });
+  }
+
+  async getStakedBalances(address: string) {
+    return this.appToolkit.helpers.masterChefContractPositionBalanceHelper.getBalances<StargateChef>({
+      address,
+      appId: STARGATE_DEFINITION.id,
+      groupId: STARGATE_DEFINITION.groups.farm.id,
+      network,
+      resolveChefContract: ({ contractAddress }) =>
+        this.contractFactory.stargateChef({ 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.masterChefDefaultClaimableBalanceStrategy.build({
+        resolveClaimableBalance: ({ multicall, contract, contractPosition, address }) =>
+          multicall.wrap(contract).pendingStargate(contractPosition.dataProps.poolIndex, address),
+      }),
+    });
+  }
+
+  async getBalances(address: string) {
+    const [poolTokenBalances, stakedBalances] = await Promise.all([
+      this.getPoolTokenBalances(address),
+      this.getStakedBalances(address),
+    ]);
+
+    return presentBalanceFetcherResponse([
+      {
+        label: 'Pools',
+        assets: poolTokenBalances,
+      },
+      {
+        label: 'Farms',
+        assets: stakedBalances,
+      },
+    ]);
+  }
+}