feat(pancakeswap): Port pancakeswap into Studio

src/apps/pancakeswap/binance/pancakeswap.auto-cake.contract-position-fetcher.ts

@@ -0,0 +1,54 @@
+import { Inject } from '@nestjs/common';
+import { BigNumber } from 'ethers';
+
+import { Register } from '~app-toolkit/decorators';
+import { RewardRateUnit } from '~app-toolkit/helpers/master-chef/master-chef.contract-position-helper';
+import { APP_TOOLKIT, IAppToolkit } from '~lib';
+import { PositionFetcher } from '~position/position-fetcher.interface';
+import { ContractPosition } from '~position/position.interface';
+import { Network } from '~types/network.interface';
+
+import { PancakeswapCakeChef, PancakeswapContractFactory } from '../contracts';
+import { PANCAKESWAP_DEFINITION } from '../pancakeswap.definition';
+
+const appId = PANCAKESWAP_DEFINITION.id;
+const groupId = PANCAKESWAP_DEFINITION.groups.autoCake.id;
+const network = Network.BINANCE_SMART_CHAIN_MAINNET;
+
+@Register.ContractPositionFetcher({ appId, groupId, network })
+export class BinanceSmartChainPancakeswapAutoCakeContractPositionFetcher implements PositionFetcher<ContractPosition> {
+  constructor(
+    @Inject(APP_TOOLKIT) private readonly appToolkit: IAppToolkit,
+    @Inject(PancakeswapContractFactory)
+    private readonly contractFactory: PancakeswapContractFactory,
+  ) {}
+
+  getPositions() {
+    const chefContract = this.contractFactory.pancakeswapChef({
+      network,
+      address: '0x73feaa1ee314f8c655e354234017be2193c9e24e',
+    });
+    return this.appToolkit.helpers.masterChefContractPositionHelper.getContractPositions<PancakeswapCakeChef>({
+      network,
+      groupId,
+      appId,
+      minimumTvl: 10000,
+      address: '0xa80240eb5d7e05d3f250cf000eec0891d00b51cc',
+      resolveContract: opts => this.contractFactory.pancakeswapCakeChef(opts),
+      resolvePoolLength: async () => BigNumber.from(1),
+      resolveDepositTokenAddress: ({ multicall, contract }) => multicall.wrap(contract).token(),
+      resolveTotalValueLocked: ({ multicall, contract }) => multicall.wrap(contract).balanceOf(),
+      resolveRewardTokenAddresses: ({ multicall, contract }) => multicall.wrap(contract).token(),
+      rewardRateUnit: RewardRateUnit.BLOCK,
+      resolveRewardRate: this.appToolkit.helpers.masterChefDefaultRewardsPerBlockStrategy.build({
+        resolvePoolAllocPoints: ({ multicall }) =>
+          multicall
+            .wrap(chefContract)
+            .poolInfo(0)
+            .then(i => i.allocPoint),
+        resolveTotalAllocPoints: ({ multicall }) => multicall.wrap(chefContract).totalAllocPoint(),
+        resolveTotalRewardRate: ({ multicall }) => multicall.wrap(chefContract).cakePerBlock(),
+      }),
+    });
+  }
+}

src/apps/pancakeswap/binance/pancakeswap.balance-fetcher.ts

@@ -0,0 +1,170 @@
+import { Inject } from '@nestjs/common';
+import { BigNumber } from 'bignumber.js';
+
+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 { APP_TOOLKIT, IAppToolkit } from '~lib';
+import { Network } from '~types/network.interface';
+
+import {
+  PancakeswapCakeChef,
+  PancakeswapChef,
+  PancakeswapContractFactory,
+  PancakeswapIfoChef,
+  PancakeswapSmartChef,
+} from '../contracts';
+import { PANCAKESWAP_DEFINITION } from '../pancakeswap.definition';
+
+const appId = PANCAKESWAP_DEFINITION.id;
+const network = Network.BINANCE_SMART_CHAIN_MAINNET;
+
+@Register.BalanceFetcher(appId, network)
+export class BinanceSmartChainPancakeSwapBalanceFetcher implements BalanceFetcher {
+  constructor(
+    @Inject(APP_TOOLKIT) private readonly appToolkit: IAppToolkit,
+    @Inject(PancakeswapContractFactory)
+    private readonly contractFactory: PancakeswapContractFactory,
+  ) {}
+
+  private async getPoolBalances(address: string) {
+    return this.appToolkit.helpers.tokenBalanceHelper.getTokenBalances({
+      address,
+      appId,
+      network,
+      groupId: PANCAKESWAP_DEFINITION.groups.pool.id,
+    });
+  }
+
+  private async getFarmBalances(address: string) {
+    // LP and Manual Cake Farms
+    return this.appToolkit.helpers.masterChefContractPositionBalanceHelper.getBalances<PancakeswapChef>({
+      address,
+      appId,
+      network,
+      groupId: PANCAKESWAP_DEFINITION.groups.farm.id,
+      resolveChefContract: ({ contractAddress }) =>
+        this.contractFactory.pancakeswapChef({ network, address: contractAddress }),
+      resolveStakedTokenBalance: this.appToolkit.helpers.masterChefDefaultStakedBalanceStrategy.build({
+        resolveStakedBalance: ({ multicall, contract, contractPosition }) =>
+          multicall
+            .wrap(contract)
+            .userInfo(contractPosition.dataProps.poolIndex, address)
+            .then(v => v.amount),
+      }),
+      resolveClaimableTokenBalances: this.appToolkit.helpers.masterChefDefaultClaimableBalanceStrategy.build({
+        resolveClaimableBalance: ({ multicall, contract, contractPosition }) =>
+          multicall.wrap(contract).pendingCake(contractPosition.dataProps.poolIndex, address),
+      }),
+    });
+  }
+
+  private async getIfoCakeBalances(address: string) {
+    // IFO Cake Farm
+    return this.appToolkit.helpers.masterChefContractPositionBalanceHelper.getBalances<PancakeswapIfoChef>({
+      address,
+      appId,
+      network,
+      groupId: PANCAKESWAP_DEFINITION.groups.ifoCake.id,
+      resolveChefContract: ({ contractAddress }) =>
+        this.contractFactory.pancakeswapIfoChef({ network, address: contractAddress }),
+      resolveStakedTokenBalance: this.appToolkit.helpers.masterChefDefaultStakedBalanceStrategy.build({
+        resolveStakedBalance: async ({ multicall, contract }) => {
+          const [userInfo, pricePerShareRaw] = await Promise.all([
+            multicall.wrap(contract).userInfo(address),
+            multicall.wrap(contract).getPricePerFullShare(),
+          ]);
+
+          const shares = userInfo.shares.toString();
+          const pricePerShare = Number(pricePerShareRaw) / 10 ** 18;
+          return new BigNumber(shares).times(pricePerShare).toFixed(0);
+        },
+      }),
+      resolveClaimableTokenBalances: this.appToolkit.helpers.masterChefDefaultClaimableBalanceStrategy.build({
+        resolveClaimableBalance: async () => 0, // Autocompounding
+      }),
+    });
+  }
+
+  private async getAutoCakeBalances(address: string) {
+    // Autocompounding Cake Farm
+    return this.appToolkit.helpers.masterChefContractPositionBalanceHelper.getBalances<PancakeswapCakeChef>({
+      address,
+      appId,
+      network,
+      groupId: PANCAKESWAP_DEFINITION.groups.autoCake.id,
+      resolveChefContract: ({ contractAddress }) =>
+        this.contractFactory.pancakeswapCakeChef({ network, address: contractAddress }),
+      resolveStakedTokenBalance: this.appToolkit.helpers.masterChefDefaultStakedBalanceStrategy.build({
+        resolveStakedBalance: async ({ multicall, contract, address }) => {
+          const [userInfo, pricePerShareRaw] = await Promise.all([
+            multicall.wrap(contract).userInfo(address),
+            multicall.wrap(contract).getPricePerFullShare(),
+          ]);
+
+          const shares = userInfo.shares.toString();
+          const pricePerShare = Number(pricePerShareRaw) / 10 ** 18;
+          return new BigNumber(shares).times(pricePerShare).toFixed(0);
+        },
+      }),
+      resolveClaimableTokenBalances: this.appToolkit.helpers.masterChefDefaultClaimableBalanceStrategy.build({
+        resolveClaimableBalance: async () => 0, // Autocompounding
+      }),
+    });
+  }
+
+  private async getSyrupPoolBalances(address: string) {
+    // Syrup Pools (single-staking)
+    return this.appToolkit.helpers.masterChefContractPositionBalanceHelper.getBalances<PancakeswapSmartChef>({
+      address,
+      appId,
+      network,
+      groupId: PANCAKESWAP_DEFINITION.groups.syrupStaking.id,
+      resolveChefContract: ({ contractAddress }) =>
+        this.contractFactory.pancakeswapSmartChef({ network, address: contractAddress }),
+      resolveStakedTokenBalance: this.appToolkit.helpers.masterChefDefaultStakedBalanceStrategy.build({
+        resolveStakedBalance: ({ multicall, contract, address }) =>
+          multicall
+            .wrap(contract)
+            .userInfo(address)
+            .then(v => v.amount),
+      }),
+      resolveClaimableTokenBalances: this.appToolkit.helpers.masterChefDefaultClaimableBalanceStrategy.build({
+        resolveClaimableBalance: ({ multicall, contract, address }) => multicall.wrap(contract).pendingReward(address),
+      }),
+    });
+  }
+
+  async getBalances(address: string) {
+    const [poolBalances, farmBalances, autoCakeBalances, ifoCakeBalances, syrupPoolBalances] = await Promise.all([
+      this.getPoolBalances(address),
+      this.getFarmBalances(address),
+      this.getAutoCakeBalances(address),
+      this.getIfoCakeBalances(address),
+      this.getSyrupPoolBalances(address),
+    ]);
+
+    return presentBalanceFetcherResponse([
+      {
+        label: 'Pools',
+        assets: poolBalances,
+      },
+      {
+        label: 'Auto CAKE',
+        assets: autoCakeBalances,
+      },
+      {
+        label: 'IFO CAKE',
+        assets: ifoCakeBalances,
+      },
+      {
+        label: 'Farms',
+        assets: farmBalances,
+      },
+      {
+        label: 'Syrup Pools',
+        assets: syrupPoolBalances,
+      },
+    ]);
+  }
+}

src/apps/pancakeswap/binance/pancakeswap.farm.contract-position-fetcher.ts

@@ -0,0 +1,66 @@
+import { Inject } from '@nestjs/common';
+
+import { Register } from '~app-toolkit/decorators';
+import { RewardRateUnit } from '~app-toolkit/helpers/master-chef/master-chef.contract-position-helper';
+import { APP_TOOLKIT, IAppToolkit } from '~lib';
+import { PositionFetcher } from '~position/position-fetcher.interface';
+import { ContractPosition } from '~position/position.interface';
+import { Network } from '~types/network.interface';
+
+import { PancakeswapChef, PancakeswapContractFactory } from '../contracts';
+import { PANCAKESWAP_DEFINITION } from '../pancakeswap.definition';
+
+const appId = PANCAKESWAP_DEFINITION.id;
+const groupId = PANCAKESWAP_DEFINITION.groups.farm.id;
+const network = Network.BINANCE_SMART_CHAIN_MAINNET;
+
+@Register.ContractPositionFetcher({ appId, groupId, network })
+export class BinanceSmartChainPancakeswapFarmContractPositionFetcher implements PositionFetcher<ContractPosition> {
+  constructor(
+    @Inject(APP_TOOLKIT) private readonly appToolkit: IAppToolkit,
+    @Inject(PancakeswapContractFactory) private readonly contractFactory: PancakeswapContractFactory,
+  ) {}
+
+  getPositions() {
+    return this.appToolkit.helpers.masterChefContractPositionHelper.getContractPositions<PancakeswapChef>({
+      network,
+      groupId,
+      appId,
+      minimumTvl: 10000,
+      address: '0x73feaa1ee314f8c655e354234017be2193c9e24e',
+      dependencies: [{ appId, groupIds: [PANCAKESWAP_DEFINITION.groups.pool.id], network }],
+      resolveContract: opts => this.contractFactory.pancakeswapChef(opts),
+      resolvePoolLength: async ({ multicall, contract }) => multicall.wrap(contract).poolLength(),
+      resolveDepositTokenAddress: ({ multicall, contract, poolIndex }) =>
+        multicall
+          .wrap(contract)
+          .poolInfo(poolIndex)
+          .then(i => i.lpToken),
+      resolveTotalValueLocked: async ({ multicall, depositTokenAddress, address, poolIndex }) => {
+        const tokenContract = this.contractFactory.erc20({ network, address: depositTokenAddress });
+        const balanceRaw = await multicall.wrap(tokenContract).balanceOf(address);
+        if (poolIndex !== 0) return balanceRaw;
+
+        const autoCakeChefContract = this.contractFactory.pancakeswapCakeChef({
+          network,
+          address: '0xa80240eb5d7e05d3f250cf000eec0891d00b51cc',
+        });
+
+        // Subtract the balance reserve for Auto CAKE staking
+        const autoCakeVaultBalanceRaw = await multicall.wrap(autoCakeChefContract).balanceOf();
+        return balanceRaw.sub(autoCakeVaultBalanceRaw);
+      },
+      resolveRewardTokenAddresses: ({ multicall, contract }) => multicall.wrap(contract).cake(),
+      rewardRateUnit: RewardRateUnit.BLOCK,
+      resolveRewardRate: this.appToolkit.helpers.masterChefDefaultRewardsPerBlockStrategy.build({
+        resolvePoolAllocPoints: ({ multicall, contract, poolIndex }) =>
+          multicall
+            .wrap(contract)
+            .poolInfo(poolIndex)
+            .then(i => i.allocPoint),
+        resolveTotalAllocPoints: ({ multicall, contract }) => multicall.wrap(contract).totalAllocPoint(),
+        resolveTotalRewardRate: ({ multicall, contract }) => multicall.wrap(contract).cakePerBlock(),
+      }),
+    });
+  }
+}

src/apps/pancakeswap/binance/pancakeswap.ifo-cake.contract-position-fetcher.ts

@@ -0,0 +1,58 @@
+import { Inject } from '@nestjs/common';
+import { BigNumber } from 'ethers';
+
+import { Register } from '~app-toolkit/decorators';
+import { RewardRateUnit } from '~app-toolkit/helpers/master-chef/master-chef.contract-position-helper';
+import { APP_TOOLKIT, IAppToolkit } from '~lib';
+import { PositionFetcher } from '~position/position-fetcher.interface';
+import { ContractPosition } from '~position/position.interface';
+import { Network } from '~types/network.interface';
+
+import { PancakeswapContractFactory, PancakeswapIfoChef } from '../contracts';
+import { PANCAKESWAP_DEFINITION } from '../pancakeswap.definition';
+
+const appId = PANCAKESWAP_DEFINITION.id;
+const groupId = PANCAKESWAP_DEFINITION.groups.ifoCake.id;
+const network = Network.BINANCE_SMART_CHAIN_MAINNET;
+
+@Register.ContractPositionFetcher({ appId, groupId, network })
+export class BinanceSmartChainPancakeswapIfoCakeContractPositionFetcher implements PositionFetcher<ContractPosition> {
+  constructor(
+    @Inject(APP_TOOLKIT) private readonly appToolkit: IAppToolkit,
+    @Inject(PancakeswapContractFactory) private readonly contractFactory: PancakeswapContractFactory,
+  ) {}
+
+  getPositions() {
+    const cakeChefContract = this.contractFactory.pancakeswapCakeChef({
+      network,
+      address: '0xa80240eb5d7e05d3f250cf000eec0891d00b51cc',
+    });
+
+    const chefContract = this.contractFactory.pancakeswapChef({
+      network,
+      address: '0x73feaa1ee314f8c655e354234017be2193c9e24e',
+    });
+    return this.appToolkit.helpers.masterChefContractPositionHelper.getContractPositions<PancakeswapIfoChef>({
+      network,
+      groupId,
+      appId,
+      minimumTvl: 10000,
+      address: '0x1b2a2f6ed4a1401e8c73b4c2b6172455ce2f78e8',
+      resolveContract: opts => this.contractFactory.pancakeswapIfoChef(opts),
+      resolvePoolLength: async () => BigNumber.from(1),
+      resolveDepositTokenAddress: ({ multicall, contract }) => multicall.wrap(contract).token(),
+      resolveTotalValueLocked: ({ multicall }) => multicall.wrap(cakeChefContract).balanceOf(),
+      rewardRateUnit: RewardRateUnit.BLOCK,
+      resolveRewardTokenAddresses: ({ multicall, contract }) => multicall.wrap(contract).token(),
+      resolveRewardRate: this.appToolkit.helpers.masterChefDefaultRewardsPerBlockStrategy.build({
+        resolvePoolAllocPoints: ({ multicall }) =>
+          multicall
+            .wrap(chefContract)
+            .poolInfo(0)
+            .then(i => i.allocPoint),
+        resolveTotalAllocPoints: ({ multicall }) => multicall.wrap(chefContract).totalAllocPoint(),
+        resolveTotalRewardRate: ({ multicall }) => multicall.wrap(chefContract).cakePerBlock(),
+      }),
+    });
+  }
+}