From 8ac00567bfacbe08dcd189d1f1c1d9137d7a60f8 Mon Sep 17 00:00:00 2001 From: Papa Sougou Wele Date: Thu, 5 May 2022 18:06:57 -0400 Subject: [PATCH] feat: Migrate Beethoven-x to Studio --- .../beethoven-x/beethoven-x.definition.ts | 36 + src/apps/beethoven-x/beethoven-x.module.ts | 30 + .../abis/beethoven-x-masterchef.json | 348 +++++++ .../contracts/ethers/BeethovenXMasterchef.ts | 901 ++++++++++++++++++ .../beethoven-x/contracts/ethers/common.ts | 30 + .../BeethovenXMasterchef__factory.ts | 797 ++++++++++++++++ .../contracts/ethers/factories/index.ts | 4 + .../beethoven-x/contracts/ethers/index.ts | 6 + src/apps/beethoven-x/contracts/index.ts | 23 + .../fantom/beethoven-x.balance-fetcher.ts | 84 ++ .../beethoven-x.f-beets.token-fetcher.ts | 40 + ...thoven-x.farm.contract-position-fetcher.ts | 61 ++ .../fantom/beethoven-x.pool.token-fetcher.ts | 66 ++ .../fantom/beethoven-x.tvl-fetcher.ts | 41 + ...x.the-graph.pool-token-address-strategy.ts | 70 ++ .../qi-dao.farm.contract-position-fetcher.ts | 5 +- 16 files changed, 2540 insertions(+), 2 deletions(-) create mode 100644 src/apps/beethoven-x/beethoven-x.definition.ts create mode 100644 src/apps/beethoven-x/beethoven-x.module.ts create mode 100644 src/apps/beethoven-x/contracts/abis/beethoven-x-masterchef.json create mode 100644 src/apps/beethoven-x/contracts/ethers/BeethovenXMasterchef.ts create mode 100644 src/apps/beethoven-x/contracts/ethers/common.ts create mode 100644 src/apps/beethoven-x/contracts/ethers/factories/BeethovenXMasterchef__factory.ts create mode 100644 src/apps/beethoven-x/contracts/ethers/factories/index.ts create mode 100644 src/apps/beethoven-x/contracts/ethers/index.ts create mode 100644 src/apps/beethoven-x/contracts/index.ts create mode 100644 src/apps/beethoven-x/fantom/beethoven-x.balance-fetcher.ts create mode 100644 src/apps/beethoven-x/fantom/beethoven-x.f-beets.token-fetcher.ts create mode 100644 src/apps/beethoven-x/fantom/beethoven-x.farm.contract-position-fetcher.ts create mode 100644 src/apps/beethoven-x/fantom/beethoven-x.pool.token-fetcher.ts create mode 100644 src/apps/beethoven-x/fantom/beethoven-x.tvl-fetcher.ts create mode 100644 src/apps/beethoven-x/helpers/beethoven-x.the-graph.pool-token-address-strategy.ts diff --git a/src/apps/beethoven-x/beethoven-x.definition.ts b/src/apps/beethoven-x/beethoven-x.definition.ts new file mode 100644 index 000000000..b206ebcaf --- /dev/null +++ b/src/apps/beethoven-x/beethoven-x.definition.ts @@ -0,0 +1,36 @@ +import { Register } from '~app-toolkit/decorators'; +import { appDefinition, AppDefinition } from '~app/app.definition'; +import { GroupType, AppTag, AppAction } from '~app/app.interface'; +import { Network } from '~types/network.interface'; + +export const BEETHOVEN_X_DEFINITION = appDefinition({ + id: 'beethoven-x', + name: 'Beethoven-X', + description: `Beethoven X enables secure and efficient - high speed, low cost - trading. Start trading immediately, no registration required. Just connect your wallet and you’re good to go.`, + groups: { + pool: { id: 'pool', type: GroupType.TOKEN }, + farm: { id: 'farm', type: GroupType.POSITION }, + fBeets: { id: 'fBEETS', type: GroupType.TOKEN }, + }, + url: 'https://app.beets.fi/', + links: { + github: 'https://github.com/beethovenxfi', + twitter: 'https://twitter.com/beethoven_x', + discord: 'https://discord.com/invite/jedS4zGk28', + medium: 'https://beethovenxio.medium.com', + learn: 'https://docs.beets.fi', + }, + tags: [AppTag.YIELD_AGGREGATOR], + supportedNetworks: { [Network.FANTOM_OPERA_MAINNET]: [AppAction.VIEW] }, + token: { + address: '0xf24bcf4d1e507740041c9cfd2dddb29585adce1e', + network: Network.FANTOM_OPERA_MAINNET, + }, +}); + +@Register.AppDefinition(BEETHOVEN_X_DEFINITION.id) +export class BeethovenXAppDefinition extends AppDefinition { + constructor() { + super(BEETHOVEN_X_DEFINITION); + } +} diff --git a/src/apps/beethoven-x/beethoven-x.module.ts b/src/apps/beethoven-x/beethoven-x.module.ts new file mode 100644 index 000000000..942ddd4fd --- /dev/null +++ b/src/apps/beethoven-x/beethoven-x.module.ts @@ -0,0 +1,30 @@ +import { Register } from '~app-toolkit/decorators'; +import { AbstractApp } from '~app/app.dynamic-module'; +import { BalancerV2AppModule } from '~apps/balancer-v2'; + +import { BeethovenXAppDefinition, BEETHOVEN_X_DEFINITION } from './beethoven-x.definition'; +import { BeethovenXContractFactory } from './contracts'; +import { FantomBeethovenXBalanceFetcher } from './fantom/beethoven-x.balance-fetcher'; +import { FantomBeethovenXFBeetsTokenFetcher } from './fantom/beethoven-x.f-beets.token-fetcher'; +import { FantomBeethovenXFarmContractPositionFetcher } from './fantom/beethoven-x.farm.contract-position-fetcher'; +import { FantomBeethovenXPoolTokenFetcher } from './fantom/beethoven-x.pool.token-fetcher'; +import { FantomBeethovenXTvlFetcher } from './fantom/beethoven-x.tvl-fetcher'; +import { BeethovenXTheGraphPoolTokenDataStrategy } from './helpers/beethoven-x.the-graph.pool-token-address-strategy'; + +@Register.AppModule({ + appId: BEETHOVEN_X_DEFINITION.id, + imports: [BalancerV2AppModule], + providers: [ + BeethovenXAppDefinition, + BeethovenXContractFactory, + // Fantom + FantomBeethovenXFarmContractPositionFetcher, + FantomBeethovenXPoolTokenFetcher, + FantomBeethovenXFBeetsTokenFetcher, + FantomBeethovenXBalanceFetcher, + FantomBeethovenXTvlFetcher, + // Helpers + BeethovenXTheGraphPoolTokenDataStrategy, + ], +}) +export class BeethovenXAppModule extends AbstractApp() {} diff --git a/src/apps/beethoven-x/contracts/abis/beethoven-x-masterchef.json b/src/apps/beethoven-x/contracts/abis/beethoven-x-masterchef.json new file mode 100644 index 000000000..ab40d91f1 --- /dev/null +++ b/src/apps/beethoven-x/contracts/abis/beethoven-x-masterchef.json @@ -0,0 +1,348 @@ +[ + { + "inputs": [ + { "internalType": "contract BeethovenxToken", "name": "_beets", "type": "address" }, + { "internalType": "address", "name": "_treasuryAddress", "type": "address" }, + { "internalType": "uint256", "name": "_beetsPerBlock", "type": "uint256" }, + { "internalType": "uint256", "name": "_startBlock", "type": "uint256" } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "anonymous": false, + "inputs": [ + { "indexed": true, "internalType": "address", "name": "user", "type": "address" }, + { "indexed": true, "internalType": "uint256", "name": "pid", "type": "uint256" }, + { "indexed": false, "internalType": "uint256", "name": "amount", "type": "uint256" }, + { "indexed": true, "internalType": "address", "name": "to", "type": "address" } + ], + "name": "Deposit", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { "indexed": true, "internalType": "address", "name": "user", "type": "address" }, + { "indexed": true, "internalType": "uint256", "name": "pid", "type": "uint256" }, + { "indexed": false, "internalType": "uint256", "name": "amount", "type": "uint256" }, + { "indexed": true, "internalType": "address", "name": "to", "type": "address" } + ], + "name": "EmergencyWithdraw", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { "indexed": true, "internalType": "address", "name": "user", "type": "address" }, + { "indexed": true, "internalType": "uint256", "name": "pid", "type": "uint256" }, + { "indexed": false, "internalType": "uint256", "name": "amount", "type": "uint256" } + ], + "name": "Harvest", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { "indexed": true, "internalType": "uint256", "name": "pid", "type": "uint256" }, + { "indexed": false, "internalType": "uint256", "name": "allocPoint", "type": "uint256" }, + { "indexed": true, "internalType": "contract IERC20", "name": "lpToken", "type": "address" }, + { "indexed": true, "internalType": "contract IRewarder", "name": "rewarder", "type": "address" } + ], + "name": "LogPoolAddition", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { "indexed": true, "internalType": "uint256", "name": "pid", "type": "uint256" }, + { "indexed": false, "internalType": "uint256", "name": "allocPoint", "type": "uint256" }, + { "indexed": true, "internalType": "contract IRewarder", "name": "rewarder", "type": "address" }, + { "indexed": false, "internalType": "bool", "name": "overwrite", "type": "bool" } + ], + "name": "LogSetPool", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { "indexed": true, "internalType": "uint256", "name": "pid", "type": "uint256" }, + { "indexed": false, "internalType": "uint256", "name": "lastRewardBlock", "type": "uint256" }, + { "indexed": false, "internalType": "uint256", "name": "lpSupply", "type": "uint256" }, + { "indexed": false, "internalType": "uint256", "name": "accBeetsPerShare", "type": "uint256" } + ], + "name": "LogUpdatePool", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { "indexed": true, "internalType": "address", "name": "previousOwner", "type": "address" }, + { "indexed": true, "internalType": "address", "name": "newOwner", "type": "address" } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { "indexed": true, "internalType": "address", "name": "oldAddress", "type": "address" }, + { "indexed": true, "internalType": "address", "name": "newAddress", "type": "address" } + ], + "name": "SetTreasuryAddress", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { "indexed": true, "internalType": "address", "name": "user", "type": "address" }, + { "indexed": false, "internalType": "uint256", "name": "_beetsPerSec", "type": "uint256" } + ], + "name": "UpdateEmissionRate", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { "indexed": true, "internalType": "address", "name": "user", "type": "address" }, + { "indexed": true, "internalType": "uint256", "name": "pid", "type": "uint256" }, + { "indexed": false, "internalType": "uint256", "name": "amount", "type": "uint256" }, + { "indexed": true, "internalType": "address", "name": "to", "type": "address" } + ], + "name": "Withdraw", + "type": "event" + }, + { + "inputs": [], + "name": "POOL_PERCENTAGE", + "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "TREASURY_PERCENTAGE", + "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { "internalType": "uint256", "name": "_allocPoint", "type": "uint256" }, + { "internalType": "contract IERC20", "name": "_lpToken", "type": "address" }, + { "internalType": "contract IRewarder", "name": "_rewarder", "type": "address" } + ], + "name": "add", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "beets", + "outputs": [{ "internalType": "contract BeethovenxToken", "name": "", "type": "address" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "beetsPerBlock", + "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { "internalType": "uint256", "name": "_pid", "type": "uint256" }, + { "internalType": "uint256", "name": "_amount", "type": "uint256" }, + { "internalType": "address", "name": "_to", "type": "address" } + ], + "name": "deposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "uint256", "name": "_pid", "type": "uint256" }, + { "internalType": "address", "name": "_to", "type": "address" } + ], + "name": "emergencyWithdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "uint256", "name": "_pid", "type": "uint256" }, + { "internalType": "address", "name": "_to", "type": "address" } + ], + "name": "harvest", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "uint256[]", "name": "_pids", "type": "uint256[]" }, + { "internalType": "address", "name": "_to", "type": "address" } + ], + "name": "harvestAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], + "name": "lpTokens", + "outputs": [{ "internalType": "contract IERC20", "name": "", "type": "address" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [{ "internalType": "uint256[]", "name": "pids", "type": "uint256[]" }], + "name": "massUpdatePools", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "owner", + "outputs": [{ "internalType": "address", "name": "", "type": "address" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { "internalType": "uint256", "name": "_pid", "type": "uint256" }, + { "internalType": "address", "name": "_user", "type": "address" } + ], + "name": "pendingBeets", + "outputs": [{ "internalType": "uint256", "name": "pending", "type": "uint256" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], + "name": "poolInfo", + "outputs": [ + { "internalType": "uint256", "name": "allocPoint", "type": "uint256" }, + { "internalType": "uint256", "name": "lastRewardBlock", "type": "uint256" }, + { "internalType": "uint256", "name": "accBeetsPerShare", "type": "uint256" } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "poolLength", + "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], + "stateMutability": "view", + "type": "function" + }, + { "inputs": [], "name": "renounceOwnership", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, + { + "inputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], + "name": "rewarder", + "outputs": [{ "internalType": "contract IRewarder", "name": "", "type": "address" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { "internalType": "uint256", "name": "_pid", "type": "uint256" }, + { "internalType": "uint256", "name": "_allocPoint", "type": "uint256" }, + { "internalType": "contract IRewarder", "name": "_rewarder", "type": "address" }, + { "internalType": "bool", "name": "overwrite", "type": "bool" } + ], + "name": "set", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "startBlock", + "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "totalAllocPoint", + "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [{ "internalType": "address", "name": "newOwner", "type": "address" }], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [{ "internalType": "address", "name": "_treasuryAddress", "type": "address" }], + "name": "treasury", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "treasuryAddress", + "outputs": [{ "internalType": "address", "name": "", "type": "address" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [{ "internalType": "uint256", "name": "_beetsPerBlock", "type": "uint256" }], + "name": "updateEmissionRate", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [{ "internalType": "uint256", "name": "_pid", "type": "uint256" }], + "name": "updatePool", + "outputs": [ + { + "components": [ + { "internalType": "uint256", "name": "allocPoint", "type": "uint256" }, + { "internalType": "uint256", "name": "lastRewardBlock", "type": "uint256" }, + { "internalType": "uint256", "name": "accBeetsPerShare", "type": "uint256" } + ], + "internalType": "struct BeethovenxMasterChef.PoolInfo", + "name": "pool", + "type": "tuple" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "uint256", "name": "", "type": "uint256" }, + { "internalType": "address", "name": "", "type": "address" } + ], + "name": "userInfo", + "outputs": [ + { "internalType": "uint256", "name": "amount", "type": "uint256" }, + { "internalType": "uint256", "name": "rewardDebt", "type": "uint256" } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { "internalType": "uint256", "name": "_pid", "type": "uint256" }, + { "internalType": "uint256", "name": "_amount", "type": "uint256" }, + { "internalType": "address", "name": "_to", "type": "address" } + ], + "name": "withdrawAndHarvest", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } +] diff --git a/src/apps/beethoven-x/contracts/ethers/BeethovenXMasterchef.ts b/src/apps/beethoven-x/contracts/ethers/BeethovenXMasterchef.ts new file mode 100644 index 000000000..b62257a44 --- /dev/null +++ b/src/apps/beethoven-x/contracts/ethers/BeethovenXMasterchef.ts @@ -0,0 +1,901 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from 'ethers'; +import type { FunctionFragment, Result, EventFragment } from '@ethersproject/abi'; +import type { Listener, Provider } from '@ethersproject/providers'; +import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from './common'; + +export declare namespace BeethovenxMasterChef { + export type PoolInfoStruct = { + allocPoint: BigNumberish; + lastRewardBlock: BigNumberish; + accBeetsPerShare: BigNumberish; + }; + + export type PoolInfoStructOutput = [BigNumber, BigNumber, BigNumber] & { + allocPoint: BigNumber; + lastRewardBlock: BigNumber; + accBeetsPerShare: BigNumber; + }; +} + +export interface BeethovenXMasterchefInterface extends utils.Interface { + functions: { + 'POOL_PERCENTAGE()': FunctionFragment; + 'TREASURY_PERCENTAGE()': FunctionFragment; + 'add(uint256,address,address)': FunctionFragment; + 'beets()': FunctionFragment; + 'beetsPerBlock()': FunctionFragment; + 'deposit(uint256,uint256,address)': FunctionFragment; + 'emergencyWithdraw(uint256,address)': FunctionFragment; + 'harvest(uint256,address)': FunctionFragment; + 'harvestAll(uint256[],address)': FunctionFragment; + 'lpTokens(uint256)': FunctionFragment; + 'massUpdatePools(uint256[])': FunctionFragment; + 'owner()': FunctionFragment; + 'pendingBeets(uint256,address)': FunctionFragment; + 'poolInfo(uint256)': FunctionFragment; + 'poolLength()': FunctionFragment; + 'renounceOwnership()': FunctionFragment; + 'rewarder(uint256)': FunctionFragment; + 'set(uint256,uint256,address,bool)': FunctionFragment; + 'startBlock()': FunctionFragment; + 'totalAllocPoint()': FunctionFragment; + 'transferOwnership(address)': FunctionFragment; + 'treasury(address)': FunctionFragment; + 'treasuryAddress()': FunctionFragment; + 'updateEmissionRate(uint256)': FunctionFragment; + 'updatePool(uint256)': FunctionFragment; + 'userInfo(uint256,address)': FunctionFragment; + 'withdrawAndHarvest(uint256,uint256,address)': FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | 'POOL_PERCENTAGE' + | 'TREASURY_PERCENTAGE' + | 'add' + | 'beets' + | 'beetsPerBlock' + | 'deposit' + | 'emergencyWithdraw' + | 'harvest' + | 'harvestAll' + | 'lpTokens' + | 'massUpdatePools' + | 'owner' + | 'pendingBeets' + | 'poolInfo' + | 'poolLength' + | 'renounceOwnership' + | 'rewarder' + | 'set' + | 'startBlock' + | 'totalAllocPoint' + | 'transferOwnership' + | 'treasury' + | 'treasuryAddress' + | 'updateEmissionRate' + | 'updatePool' + | 'userInfo' + | 'withdrawAndHarvest', + ): FunctionFragment; + + encodeFunctionData(functionFragment: 'POOL_PERCENTAGE', values?: undefined): string; + encodeFunctionData(functionFragment: 'TREASURY_PERCENTAGE', values?: undefined): string; + encodeFunctionData(functionFragment: 'add', values: [BigNumberish, string, string]): string; + encodeFunctionData(functionFragment: 'beets', values?: undefined): string; + encodeFunctionData(functionFragment: 'beetsPerBlock', values?: undefined): string; + encodeFunctionData(functionFragment: 'deposit', values: [BigNumberish, BigNumberish, string]): string; + encodeFunctionData(functionFragment: 'emergencyWithdraw', values: [BigNumberish, string]): string; + encodeFunctionData(functionFragment: 'harvest', values: [BigNumberish, string]): string; + encodeFunctionData(functionFragment: 'harvestAll', values: [BigNumberish[], string]): string; + encodeFunctionData(functionFragment: 'lpTokens', values: [BigNumberish]): string; + encodeFunctionData(functionFragment: 'massUpdatePools', values: [BigNumberish[]]): string; + encodeFunctionData(functionFragment: 'owner', values?: undefined): string; + encodeFunctionData(functionFragment: 'pendingBeets', values: [BigNumberish, string]): string; + encodeFunctionData(functionFragment: 'poolInfo', values: [BigNumberish]): string; + encodeFunctionData(functionFragment: 'poolLength', values?: undefined): string; + encodeFunctionData(functionFragment: 'renounceOwnership', values?: undefined): string; + encodeFunctionData(functionFragment: 'rewarder', values: [BigNumberish]): string; + encodeFunctionData(functionFragment: 'set', values: [BigNumberish, BigNumberish, string, boolean]): string; + encodeFunctionData(functionFragment: 'startBlock', values?: undefined): string; + encodeFunctionData(functionFragment: 'totalAllocPoint', values?: undefined): string; + encodeFunctionData(functionFragment: 'transferOwnership', values: [string]): string; + encodeFunctionData(functionFragment: 'treasury', values: [string]): string; + encodeFunctionData(functionFragment: 'treasuryAddress', values?: undefined): string; + encodeFunctionData(functionFragment: 'updateEmissionRate', values: [BigNumberish]): string; + encodeFunctionData(functionFragment: 'updatePool', values: [BigNumberish]): string; + encodeFunctionData(functionFragment: 'userInfo', values: [BigNumberish, string]): string; + encodeFunctionData(functionFragment: 'withdrawAndHarvest', values: [BigNumberish, BigNumberish, string]): string; + + decodeFunctionResult(functionFragment: 'POOL_PERCENTAGE', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'TREASURY_PERCENTAGE', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'add', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'beets', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'beetsPerBlock', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'deposit', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'emergencyWithdraw', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'harvest', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'harvestAll', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'lpTokens', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'massUpdatePools', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'owner', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'pendingBeets', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'poolInfo', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'poolLength', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'renounceOwnership', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'rewarder', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'set', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'startBlock', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'totalAllocPoint', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'transferOwnership', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'treasury', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'treasuryAddress', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'updateEmissionRate', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'updatePool', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'userInfo', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'withdrawAndHarvest', data: BytesLike): Result; + + events: { + 'Deposit(address,uint256,uint256,address)': EventFragment; + 'EmergencyWithdraw(address,uint256,uint256,address)': EventFragment; + 'Harvest(address,uint256,uint256)': EventFragment; + 'LogPoolAddition(uint256,uint256,address,address)': EventFragment; + 'LogSetPool(uint256,uint256,address,bool)': EventFragment; + 'LogUpdatePool(uint256,uint256,uint256,uint256)': EventFragment; + 'OwnershipTransferred(address,address)': EventFragment; + 'SetTreasuryAddress(address,address)': EventFragment; + 'UpdateEmissionRate(address,uint256)': EventFragment; + 'Withdraw(address,uint256,uint256,address)': EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: 'Deposit'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'EmergencyWithdraw'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Harvest'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'LogPoolAddition'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'LogSetPool'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'LogUpdatePool'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'OwnershipTransferred'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'SetTreasuryAddress'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'UpdateEmissionRate'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Withdraw'): EventFragment; +} + +export interface DepositEventObject { + user: string; + pid: BigNumber; + amount: BigNumber; + to: string; +} +export type DepositEvent = TypedEvent<[string, BigNumber, BigNumber, string], DepositEventObject>; + +export type DepositEventFilter = TypedEventFilter; + +export interface EmergencyWithdrawEventObject { + user: string; + pid: BigNumber; + amount: BigNumber; + to: string; +} +export type EmergencyWithdrawEvent = TypedEvent<[string, BigNumber, BigNumber, string], EmergencyWithdrawEventObject>; + +export type EmergencyWithdrawEventFilter = TypedEventFilter; + +export interface HarvestEventObject { + user: string; + pid: BigNumber; + amount: BigNumber; +} +export type HarvestEvent = TypedEvent<[string, BigNumber, BigNumber], HarvestEventObject>; + +export type HarvestEventFilter = TypedEventFilter; + +export interface LogPoolAdditionEventObject { + pid: BigNumber; + allocPoint: BigNumber; + lpToken: string; + rewarder: string; +} +export type LogPoolAdditionEvent = TypedEvent<[BigNumber, BigNumber, string, string], LogPoolAdditionEventObject>; + +export type LogPoolAdditionEventFilter = TypedEventFilter; + +export interface LogSetPoolEventObject { + pid: BigNumber; + allocPoint: BigNumber; + rewarder: string; + overwrite: boolean; +} +export type LogSetPoolEvent = TypedEvent<[BigNumber, BigNumber, string, boolean], LogSetPoolEventObject>; + +export type LogSetPoolEventFilter = TypedEventFilter; + +export interface LogUpdatePoolEventObject { + pid: BigNumber; + lastRewardBlock: BigNumber; + lpSupply: BigNumber; + accBeetsPerShare: BigNumber; +} +export type LogUpdatePoolEvent = TypedEvent<[BigNumber, BigNumber, BigNumber, BigNumber], LogUpdatePoolEventObject>; + +export type LogUpdatePoolEventFilter = TypedEventFilter; + +export interface OwnershipTransferredEventObject { + previousOwner: string; + newOwner: string; +} +export type OwnershipTransferredEvent = TypedEvent<[string, string], OwnershipTransferredEventObject>; + +export type OwnershipTransferredEventFilter = TypedEventFilter; + +export interface SetTreasuryAddressEventObject { + oldAddress: string; + newAddress: string; +} +export type SetTreasuryAddressEvent = TypedEvent<[string, string], SetTreasuryAddressEventObject>; + +export type SetTreasuryAddressEventFilter = TypedEventFilter; + +export interface UpdateEmissionRateEventObject { + user: string; + _beetsPerSec: BigNumber; +} +export type UpdateEmissionRateEvent = TypedEvent<[string, BigNumber], UpdateEmissionRateEventObject>; + +export type UpdateEmissionRateEventFilter = TypedEventFilter; + +export interface WithdrawEventObject { + user: string; + pid: BigNumber; + amount: BigNumber; + to: string; +} +export type WithdrawEvent = TypedEvent<[string, BigNumber, BigNumber, string], WithdrawEventObject>; + +export type WithdrawEventFilter = TypedEventFilter; + +export interface BeethovenXMasterchef extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: BeethovenXMasterchefInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined, + ): Promise>; + + listeners(eventFilter?: TypedEventFilter): Array>; + listeners(eventName?: string): Array; + removeAllListeners(eventFilter: TypedEventFilter): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + POOL_PERCENTAGE(overrides?: CallOverrides): Promise<[BigNumber]>; + + TREASURY_PERCENTAGE(overrides?: CallOverrides): Promise<[BigNumber]>; + + add( + _allocPoint: BigNumberish, + _lpToken: string, + _rewarder: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + beets(overrides?: CallOverrides): Promise<[string]>; + + beetsPerBlock(overrides?: CallOverrides): Promise<[BigNumber]>; + + deposit( + _pid: BigNumberish, + _amount: BigNumberish, + _to: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + emergencyWithdraw( + _pid: BigNumberish, + _to: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + harvest( + _pid: BigNumberish, + _to: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + harvestAll( + _pids: BigNumberish[], + _to: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + lpTokens(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>; + + massUpdatePools( + pids: BigNumberish[], + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + owner(overrides?: CallOverrides): Promise<[string]>; + + pendingBeets( + _pid: BigNumberish, + _user: string, + overrides?: CallOverrides, + ): Promise<[BigNumber] & { pending: BigNumber }>; + + poolInfo( + arg0: BigNumberish, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber, BigNumber] & { + allocPoint: BigNumber; + lastRewardBlock: BigNumber; + accBeetsPerShare: BigNumber; + } + >; + + poolLength(overrides?: CallOverrides): Promise<[BigNumber]>; + + renounceOwnership(overrides?: Overrides & { from?: string | Promise }): Promise; + + rewarder(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>; + + set( + _pid: BigNumberish, + _allocPoint: BigNumberish, + _rewarder: string, + overwrite: boolean, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + startBlock(overrides?: CallOverrides): Promise<[BigNumber]>; + + totalAllocPoint(overrides?: CallOverrides): Promise<[BigNumber]>; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + treasury( + _treasuryAddress: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + treasuryAddress(overrides?: CallOverrides): Promise<[string]>; + + updateEmissionRate( + _beetsPerBlock: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updatePool( + _pid: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + userInfo( + arg0: BigNumberish, + arg1: string, + overrides?: CallOverrides, + ): Promise<[BigNumber, BigNumber] & { amount: BigNumber; rewardDebt: BigNumber }>; + + withdrawAndHarvest( + _pid: BigNumberish, + _amount: BigNumberish, + _to: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + }; + + POOL_PERCENTAGE(overrides?: CallOverrides): Promise; + + TREASURY_PERCENTAGE(overrides?: CallOverrides): Promise; + + add( + _allocPoint: BigNumberish, + _lpToken: string, + _rewarder: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + beets(overrides?: CallOverrides): Promise; + + beetsPerBlock(overrides?: CallOverrides): Promise; + + deposit( + _pid: BigNumberish, + _amount: BigNumberish, + _to: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + emergencyWithdraw( + _pid: BigNumberish, + _to: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + harvest( + _pid: BigNumberish, + _to: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + harvestAll( + _pids: BigNumberish[], + _to: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + lpTokens(arg0: BigNumberish, overrides?: CallOverrides): Promise; + + massUpdatePools( + pids: BigNumberish[], + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + pendingBeets(_pid: BigNumberish, _user: string, overrides?: CallOverrides): Promise; + + poolInfo( + arg0: BigNumberish, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber, BigNumber] & { + allocPoint: BigNumber; + lastRewardBlock: BigNumber; + accBeetsPerShare: BigNumber; + } + >; + + poolLength(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: Overrides & { from?: string | Promise }): Promise; + + rewarder(arg0: BigNumberish, overrides?: CallOverrides): Promise; + + set( + _pid: BigNumberish, + _allocPoint: BigNumberish, + _rewarder: string, + overwrite: boolean, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + startBlock(overrides?: CallOverrides): Promise; + + totalAllocPoint(overrides?: CallOverrides): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + treasury( + _treasuryAddress: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + treasuryAddress(overrides?: CallOverrides): Promise; + + updateEmissionRate( + _beetsPerBlock: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updatePool( + _pid: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + userInfo( + arg0: BigNumberish, + arg1: string, + overrides?: CallOverrides, + ): Promise<[BigNumber, BigNumber] & { amount: BigNumber; rewardDebt: BigNumber }>; + + withdrawAndHarvest( + _pid: BigNumberish, + _amount: BigNumberish, + _to: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + callStatic: { + POOL_PERCENTAGE(overrides?: CallOverrides): Promise; + + TREASURY_PERCENTAGE(overrides?: CallOverrides): Promise; + + add(_allocPoint: BigNumberish, _lpToken: string, _rewarder: string, overrides?: CallOverrides): Promise; + + beets(overrides?: CallOverrides): Promise; + + beetsPerBlock(overrides?: CallOverrides): Promise; + + deposit(_pid: BigNumberish, _amount: BigNumberish, _to: string, overrides?: CallOverrides): Promise; + + emergencyWithdraw(_pid: BigNumberish, _to: string, overrides?: CallOverrides): Promise; + + harvest(_pid: BigNumberish, _to: string, overrides?: CallOverrides): Promise; + + harvestAll(_pids: BigNumberish[], _to: string, overrides?: CallOverrides): Promise; + + lpTokens(arg0: BigNumberish, overrides?: CallOverrides): Promise; + + massUpdatePools(pids: BigNumberish[], overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + pendingBeets(_pid: BigNumberish, _user: string, overrides?: CallOverrides): Promise; + + poolInfo( + arg0: BigNumberish, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber, BigNumber] & { + allocPoint: BigNumber; + lastRewardBlock: BigNumber; + accBeetsPerShare: BigNumber; + } + >; + + poolLength(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: CallOverrides): Promise; + + rewarder(arg0: BigNumberish, overrides?: CallOverrides): Promise; + + set( + _pid: BigNumberish, + _allocPoint: BigNumberish, + _rewarder: string, + overwrite: boolean, + overrides?: CallOverrides, + ): Promise; + + startBlock(overrides?: CallOverrides): Promise; + + totalAllocPoint(overrides?: CallOverrides): Promise; + + transferOwnership(newOwner: string, overrides?: CallOverrides): Promise; + + treasury(_treasuryAddress: string, overrides?: CallOverrides): Promise; + + treasuryAddress(overrides?: CallOverrides): Promise; + + updateEmissionRate(_beetsPerBlock: BigNumberish, overrides?: CallOverrides): Promise; + + updatePool(_pid: BigNumberish, overrides?: CallOverrides): Promise; + + userInfo( + arg0: BigNumberish, + arg1: string, + overrides?: CallOverrides, + ): Promise<[BigNumber, BigNumber] & { amount: BigNumber; rewardDebt: BigNumber }>; + + withdrawAndHarvest( + _pid: BigNumberish, + _amount: BigNumberish, + _to: string, + overrides?: CallOverrides, + ): Promise; + }; + + filters: { + 'Deposit(address,uint256,uint256,address)'( + user?: string | null, + pid?: BigNumberish | null, + amount?: null, + to?: string | null, + ): DepositEventFilter; + Deposit(user?: string | null, pid?: BigNumberish | null, amount?: null, to?: string | null): DepositEventFilter; + + 'EmergencyWithdraw(address,uint256,uint256,address)'( + user?: string | null, + pid?: BigNumberish | null, + amount?: null, + to?: string | null, + ): EmergencyWithdrawEventFilter; + EmergencyWithdraw( + user?: string | null, + pid?: BigNumberish | null, + amount?: null, + to?: string | null, + ): EmergencyWithdrawEventFilter; + + 'Harvest(address,uint256,uint256)'( + user?: string | null, + pid?: BigNumberish | null, + amount?: null, + ): HarvestEventFilter; + Harvest(user?: string | null, pid?: BigNumberish | null, amount?: null): HarvestEventFilter; + + 'LogPoolAddition(uint256,uint256,address,address)'( + pid?: BigNumberish | null, + allocPoint?: null, + lpToken?: string | null, + rewarder?: string | null, + ): LogPoolAdditionEventFilter; + LogPoolAddition( + pid?: BigNumberish | null, + allocPoint?: null, + lpToken?: string | null, + rewarder?: string | null, + ): LogPoolAdditionEventFilter; + + 'LogSetPool(uint256,uint256,address,bool)'( + pid?: BigNumberish | null, + allocPoint?: null, + rewarder?: string | null, + overwrite?: null, + ): LogSetPoolEventFilter; + LogSetPool( + pid?: BigNumberish | null, + allocPoint?: null, + rewarder?: string | null, + overwrite?: null, + ): LogSetPoolEventFilter; + + 'LogUpdatePool(uint256,uint256,uint256,uint256)'( + pid?: BigNumberish | null, + lastRewardBlock?: null, + lpSupply?: null, + accBeetsPerShare?: null, + ): LogUpdatePoolEventFilter; + LogUpdatePool( + pid?: BigNumberish | null, + lastRewardBlock?: null, + lpSupply?: null, + accBeetsPerShare?: null, + ): LogUpdatePoolEventFilter; + + 'OwnershipTransferred(address,address)'( + previousOwner?: string | null, + newOwner?: string | null, + ): OwnershipTransferredEventFilter; + OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter; + + 'SetTreasuryAddress(address,address)'( + oldAddress?: string | null, + newAddress?: string | null, + ): SetTreasuryAddressEventFilter; + SetTreasuryAddress(oldAddress?: string | null, newAddress?: string | null): SetTreasuryAddressEventFilter; + + 'UpdateEmissionRate(address,uint256)'(user?: string | null, _beetsPerSec?: null): UpdateEmissionRateEventFilter; + UpdateEmissionRate(user?: string | null, _beetsPerSec?: null): UpdateEmissionRateEventFilter; + + 'Withdraw(address,uint256,uint256,address)'( + user?: string | null, + pid?: BigNumberish | null, + amount?: null, + to?: string | null, + ): WithdrawEventFilter; + Withdraw(user?: string | null, pid?: BigNumberish | null, amount?: null, to?: string | null): WithdrawEventFilter; + }; + + estimateGas: { + POOL_PERCENTAGE(overrides?: CallOverrides): Promise; + + TREASURY_PERCENTAGE(overrides?: CallOverrides): Promise; + + add( + _allocPoint: BigNumberish, + _lpToken: string, + _rewarder: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + beets(overrides?: CallOverrides): Promise; + + beetsPerBlock(overrides?: CallOverrides): Promise; + + deposit( + _pid: BigNumberish, + _amount: BigNumberish, + _to: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + emergencyWithdraw( + _pid: BigNumberish, + _to: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + harvest( + _pid: BigNumberish, + _to: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + harvestAll( + _pids: BigNumberish[], + _to: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + lpTokens(arg0: BigNumberish, overrides?: CallOverrides): Promise; + + massUpdatePools( + pids: BigNumberish[], + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + pendingBeets(_pid: BigNumberish, _user: string, overrides?: CallOverrides): Promise; + + poolInfo(arg0: BigNumberish, overrides?: CallOverrides): Promise; + + poolLength(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: Overrides & { from?: string | Promise }): Promise; + + rewarder(arg0: BigNumberish, overrides?: CallOverrides): Promise; + + set( + _pid: BigNumberish, + _allocPoint: BigNumberish, + _rewarder: string, + overwrite: boolean, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + startBlock(overrides?: CallOverrides): Promise; + + totalAllocPoint(overrides?: CallOverrides): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + treasury(_treasuryAddress: string, overrides?: Overrides & { from?: string | Promise }): Promise; + + treasuryAddress(overrides?: CallOverrides): Promise; + + updateEmissionRate( + _beetsPerBlock: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updatePool(_pid: BigNumberish, overrides?: Overrides & { from?: string | Promise }): Promise; + + userInfo(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise; + + withdrawAndHarvest( + _pid: BigNumberish, + _amount: BigNumberish, + _to: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + }; + + populateTransaction: { + POOL_PERCENTAGE(overrides?: CallOverrides): Promise; + + TREASURY_PERCENTAGE(overrides?: CallOverrides): Promise; + + add( + _allocPoint: BigNumberish, + _lpToken: string, + _rewarder: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + beets(overrides?: CallOverrides): Promise; + + beetsPerBlock(overrides?: CallOverrides): Promise; + + deposit( + _pid: BigNumberish, + _amount: BigNumberish, + _to: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + emergencyWithdraw( + _pid: BigNumberish, + _to: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + harvest( + _pid: BigNumberish, + _to: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + harvestAll( + _pids: BigNumberish[], + _to: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + lpTokens(arg0: BigNumberish, overrides?: CallOverrides): Promise; + + massUpdatePools( + pids: BigNumberish[], + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + pendingBeets(_pid: BigNumberish, _user: string, overrides?: CallOverrides): Promise; + + poolInfo(arg0: BigNumberish, overrides?: CallOverrides): Promise; + + poolLength(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: Overrides & { from?: string | Promise }): Promise; + + rewarder(arg0: BigNumberish, overrides?: CallOverrides): Promise; + + set( + _pid: BigNumberish, + _allocPoint: BigNumberish, + _rewarder: string, + overwrite: boolean, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + startBlock(overrides?: CallOverrides): Promise; + + totalAllocPoint(overrides?: CallOverrides): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + treasury( + _treasuryAddress: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + treasuryAddress(overrides?: CallOverrides): Promise; + + updateEmissionRate( + _beetsPerBlock: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updatePool( + _pid: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + userInfo(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise; + + withdrawAndHarvest( + _pid: BigNumberish, + _amount: BigNumberish, + _to: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + }; +} diff --git a/src/apps/beethoven-x/contracts/ethers/common.ts b/src/apps/beethoven-x/contracts/ethers/common.ts new file mode 100644 index 000000000..6cfb10425 --- /dev/null +++ b/src/apps/beethoven-x/contracts/ethers/common.ts @@ -0,0 +1,30 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { Listener } from '@ethersproject/providers'; +import type { Event, EventFilter } from 'ethers'; + +export interface TypedEvent = any, TArgsObject = any> extends Event { + args: TArgsArray & TArgsObject; +} + +export interface TypedEventFilter<_TEvent extends TypedEvent> extends EventFilter {} + +export interface TypedListener { + (...listenerArg: [...__TypechainArgsArray, TEvent]): void; +} + +type __TypechainArgsArray = T extends TypedEvent ? U : never; + +export interface OnEvent { + (eventFilter: TypedEventFilter, listener: TypedListener): TRes; + (eventName: string, listener: Listener): TRes; +} + +export type MinEthersFactory = { + deploy(...a: ARGS[]): Promise; +}; + +export type GetContractTypeFromFactory = F extends MinEthersFactory ? C : never; + +export type GetARGsTypeFromFactory = F extends MinEthersFactory ? Parameters : never; diff --git a/src/apps/beethoven-x/contracts/ethers/factories/BeethovenXMasterchef__factory.ts b/src/apps/beethoven-x/contracts/ethers/factories/BeethovenXMasterchef__factory.ts new file mode 100644 index 000000000..dcf3cf550 --- /dev/null +++ b/src/apps/beethoven-x/contracts/ethers/factories/BeethovenXMasterchef__factory.ts @@ -0,0 +1,797 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from 'ethers'; +import type { Provider } from '@ethersproject/providers'; +import type { BeethovenXMasterchef, BeethovenXMasterchefInterface } from '../BeethovenXMasterchef'; + +const _abi = [ + { + inputs: [ + { + internalType: 'contract BeethovenxToken', + name: '_beets', + type: 'address', + }, + { + internalType: 'address', + name: '_treasuryAddress', + type: 'address', + }, + { + internalType: 'uint256', + name: '_beetsPerBlock', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_startBlock', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'constructor', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'user', + type: 'address', + }, + { + indexed: true, + internalType: 'uint256', + name: 'pid', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + { + indexed: true, + internalType: 'address', + name: 'to', + type: 'address', + }, + ], + name: 'Deposit', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'user', + type: 'address', + }, + { + indexed: true, + internalType: 'uint256', + name: 'pid', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + { + indexed: true, + internalType: 'address', + name: 'to', + type: 'address', + }, + ], + name: 'EmergencyWithdraw', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'user', + type: 'address', + }, + { + indexed: true, + internalType: 'uint256', + name: 'pid', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + ], + name: 'Harvest', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'uint256', + name: 'pid', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'allocPoint', + type: 'uint256', + }, + { + indexed: true, + internalType: 'contract IERC20', + name: 'lpToken', + type: 'address', + }, + { + indexed: true, + internalType: 'contract IRewarder', + name: 'rewarder', + type: 'address', + }, + ], + name: 'LogPoolAddition', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'uint256', + name: 'pid', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'allocPoint', + type: 'uint256', + }, + { + indexed: true, + internalType: 'contract IRewarder', + name: 'rewarder', + type: 'address', + }, + { + indexed: false, + internalType: 'bool', + name: 'overwrite', + type: 'bool', + }, + ], + name: 'LogSetPool', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'uint256', + name: 'pid', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'lastRewardBlock', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'lpSupply', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'accBeetsPerShare', + type: 'uint256', + }, + ], + name: 'LogUpdatePool', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'previousOwner', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'newOwner', + type: 'address', + }, + ], + name: 'OwnershipTransferred', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'oldAddress', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'newAddress', + type: 'address', + }, + ], + name: 'SetTreasuryAddress', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'user', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: '_beetsPerSec', + type: 'uint256', + }, + ], + name: 'UpdateEmissionRate', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'user', + type: 'address', + }, + { + indexed: true, + internalType: 'uint256', + name: 'pid', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + { + indexed: true, + internalType: 'address', + name: 'to', + type: 'address', + }, + ], + name: 'Withdraw', + type: 'event', + }, + { + inputs: [], + name: 'POOL_PERCENTAGE', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'TREASURY_PERCENTAGE', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_allocPoint', + type: 'uint256', + }, + { + internalType: 'contract IERC20', + name: '_lpToken', + type: 'address', + }, + { + internalType: 'contract IRewarder', + name: '_rewarder', + type: 'address', + }, + ], + name: 'add', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'beets', + outputs: [ + { + internalType: 'contract BeethovenxToken', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'beetsPerBlock', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_amount', + type: 'uint256', + }, + { + internalType: 'address', + name: '_to', + type: 'address', + }, + ], + name: 'deposit', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + internalType: 'address', + name: '_to', + type: 'address', + }, + ], + name: 'emergencyWithdraw', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + internalType: 'address', + name: '_to', + type: 'address', + }, + ], + name: 'harvest', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256[]', + name: '_pids', + type: 'uint256[]', + }, + { + internalType: 'address', + name: '_to', + type: 'address', + }, + ], + name: 'harvestAll', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'lpTokens', + outputs: [ + { + internalType: 'contract IERC20', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256[]', + name: 'pids', + type: 'uint256[]', + }, + ], + name: 'massUpdatePools', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'owner', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + internalType: 'address', + name: '_user', + type: 'address', + }, + ], + name: 'pendingBeets', + outputs: [ + { + internalType: 'uint256', + name: 'pending', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'poolInfo', + outputs: [ + { + internalType: 'uint256', + name: 'allocPoint', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'lastRewardBlock', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'accBeetsPerShare', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'poolLength', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'renounceOwnership', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'rewarder', + outputs: [ + { + internalType: 'contract IRewarder', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_allocPoint', + type: 'uint256', + }, + { + internalType: 'contract IRewarder', + name: '_rewarder', + type: 'address', + }, + { + internalType: 'bool', + name: 'overwrite', + type: 'bool', + }, + ], + name: 'set', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'startBlock', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'totalAllocPoint', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'newOwner', + type: 'address', + }, + ], + name: 'transferOwnership', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_treasuryAddress', + type: 'address', + }, + ], + name: 'treasury', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'treasuryAddress', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_beetsPerBlock', + type: 'uint256', + }, + ], + name: 'updateEmissionRate', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + ], + name: 'updatePool', + outputs: [ + { + components: [ + { + internalType: 'uint256', + name: 'allocPoint', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'lastRewardBlock', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'accBeetsPerShare', + type: 'uint256', + }, + ], + internalType: 'struct BeethovenxMasterChef.PoolInfo', + name: 'pool', + type: 'tuple', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + name: 'userInfo', + outputs: [ + { + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'rewardDebt', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_amount', + type: 'uint256', + }, + { + internalType: 'address', + name: '_to', + type: 'address', + }, + ], + name: 'withdrawAndHarvest', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, +]; + +export class BeethovenXMasterchef__factory { + static readonly abi = _abi; + static createInterface(): BeethovenXMasterchefInterface { + return new utils.Interface(_abi) as BeethovenXMasterchefInterface; + } + static connect(address: string, signerOrProvider: Signer | Provider): BeethovenXMasterchef { + return new Contract(address, _abi, signerOrProvider) as BeethovenXMasterchef; + } +} diff --git a/src/apps/beethoven-x/contracts/ethers/factories/index.ts b/src/apps/beethoven-x/contracts/ethers/factories/index.ts new file mode 100644 index 000000000..8644a26dd --- /dev/null +++ b/src/apps/beethoven-x/contracts/ethers/factories/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { BeethovenXMasterchef__factory } from './BeethovenXMasterchef__factory'; diff --git a/src/apps/beethoven-x/contracts/ethers/index.ts b/src/apps/beethoven-x/contracts/ethers/index.ts new file mode 100644 index 000000000..b3f6cb388 --- /dev/null +++ b/src/apps/beethoven-x/contracts/ethers/index.ts @@ -0,0 +1,6 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { BeethovenXMasterchef } from './BeethovenXMasterchef'; +export * as factories from './factories'; +export { BeethovenXMasterchef__factory } from './factories/BeethovenXMasterchef__factory'; diff --git a/src/apps/beethoven-x/contracts/index.ts b/src/apps/beethoven-x/contracts/index.ts new file mode 100644 index 000000000..b72714de8 --- /dev/null +++ b/src/apps/beethoven-x/contracts/index.ts @@ -0,0 +1,23 @@ +import { Injectable, Inject } from '@nestjs/common'; + +import { IAppToolkit, APP_TOOLKIT } from '~app-toolkit/app-toolkit.interface'; +import { ContractFactory } from '~contract/contracts'; +import { Network } from '~types/network.interface'; + +import { BeethovenXMasterchef__factory } from './ethers'; + +// eslint-disable-next-line +type ContractOpts = { address: string; network: Network }; + +@Injectable() +export class BeethovenXContractFactory extends ContractFactory { + constructor(@Inject(APP_TOOLKIT) protected readonly appToolkit: IAppToolkit) { + super((network: Network) => appToolkit.getNetworkProvider(network)); + } + + beethovenXMasterchef({ address, network }: ContractOpts) { + return BeethovenXMasterchef__factory.connect(address, this.appToolkit.getNetworkProvider(network)); + } +} + +export type { BeethovenXMasterchef } from './ethers'; diff --git a/src/apps/beethoven-x/fantom/beethoven-x.balance-fetcher.ts b/src/apps/beethoven-x/fantom/beethoven-x.balance-fetcher.ts new file mode 100644 index 000000000..396143ec3 --- /dev/null +++ b/src/apps/beethoven-x/fantom/beethoven-x.balance-fetcher.ts @@ -0,0 +1,84 @@ +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 { BEETHOVEN_X_DEFINITION } from '../beethoven-x.definition'; +import { BeethovenXContractFactory, BeethovenXMasterchef } from '../contracts'; + +const appId = BEETHOVEN_X_DEFINITION.id; +const network = Network.FANTOM_OPERA_MAINNET; + +@Register.BalanceFetcher(appId, network) +export class FantomBeethovenXBalanceFetcher implements BalanceFetcher { + constructor( + @Inject(APP_TOOLKIT) private readonly appToolkit: IAppToolkit, + @Inject(BeethovenXContractFactory) private readonly contractFactory: BeethovenXContractFactory, + ) {} + + private async getStakedBalances(address: string) { + return this.appToolkit.helpers.tokenBalanceHelper.getTokenBalances({ + address, + network, + appId, + groupId: BEETHOVEN_X_DEFINITION.groups.fBeets.id, + }); + } + + async getPoolBalances(address: string) { + return this.appToolkit.helpers.tokenBalanceHelper.getTokenBalances({ + address, + network, + appId, + groupId: BEETHOVEN_X_DEFINITION.groups.pool.id, + }); + } + + async getFarmBalances(address: string) { + return this.appToolkit.helpers.masterChefContractPositionBalanceHelper.getBalances({ + address, + appId, + groupId: BEETHOVEN_X_DEFINITION.groups.farm.id, + network, + resolveChefContract: ({ contractAddress }) => + this.contractFactory.beethovenXMasterchef({ 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).pendingBeets(contractPosition.dataProps.poolIndex, address), + }), + }); + } + + async getBalances(address: string) { + const [poolBalances, farmBalances, stakedBalances] = await Promise.all([ + this.getPoolBalances(address), + this.getFarmBalances(address), + this.getStakedBalances(address), + ]); + + return presentBalanceFetcherResponse([ + { + label: 'Pools', + assets: poolBalances, + }, + { + label: 'Farms', + assets: farmBalances, + }, + { + label: 'Staking', + assets: stakedBalances, + }, + ]); + } +} diff --git a/src/apps/beethoven-x/fantom/beethoven-x.f-beets.token-fetcher.ts b/src/apps/beethoven-x/fantom/beethoven-x.f-beets.token-fetcher.ts new file mode 100644 index 000000000..0ee9392f5 --- /dev/null +++ b/src/apps/beethoven-x/fantom/beethoven-x.f-beets.token-fetcher.ts @@ -0,0 +1,40 @@ +import { Inject } from '@nestjs/common'; + +import { APP_TOOLKIT, IAppToolkit } from '~app-toolkit/app-toolkit.interface'; +import { Register } from '~app-toolkit/decorators'; +import { getTokenImg } from '~app-toolkit/helpers/presentation/image.present'; +import { PositionFetcher } from '~position/position-fetcher.interface'; +import { AppTokenPosition } from '~position/position.interface'; +import { Network } from '~types/network.interface'; + +import { BEETHOVEN_X_DEFINITION } from '../beethoven-x.definition'; +import { BeethovenXContractFactory } from '../contracts'; + +const F_BEETS_ADDRESS = '0xfcef8a994209d6916eb2c86cdd2afd60aa6f54b1'; +const BPT_BEETS_FTM_POOL_ADDRESS = '0xcde5a11a4acb4ee4c805352cec57e236bdbc3837'; + +const appId = BEETHOVEN_X_DEFINITION.id; +const groupId = BEETHOVEN_X_DEFINITION.groups.fBeets.id; +const network = Network.FANTOM_OPERA_MAINNET; + +@Register.TokenPositionFetcher({ appId, groupId, network }) +export class FantomBeethovenXFBeetsTokenFetcher implements PositionFetcher { + constructor( + @Inject(APP_TOOLKIT) private readonly appToolkit: IAppToolkit, + @Inject(BeethovenXContractFactory) + private readonly beethovenXContractFactory: BeethovenXContractFactory, + ) {} + + async getPositions(): Promise { + return this.appToolkit.helpers.singleVaultTokenHelper.getTokens({ + network, + appId, + groupId, + dependencies: [{ appId, groupIds: [BEETHOVEN_X_DEFINITION.groups.pool.id], network }], + address: F_BEETS_ADDRESS, + resolveContract: ({ address, network }) => this.beethovenXContractFactory.erc20({ address, network }), + resolveUnderlyingTokenAddress: () => BPT_BEETS_FTM_POOL_ADDRESS, + resolveImages: () => [getTokenImg(BEETHOVEN_X_DEFINITION.token!.address, network)], + }); + } +} diff --git a/src/apps/beethoven-x/fantom/beethoven-x.farm.contract-position-fetcher.ts b/src/apps/beethoven-x/fantom/beethoven-x.farm.contract-position-fetcher.ts new file mode 100644 index 000000000..3eba9387f --- /dev/null +++ b/src/apps/beethoven-x/fantom/beethoven-x.farm.contract-position-fetcher.ts @@ -0,0 +1,61 @@ +import { Inject } from '@nestjs/common'; +import { compact } from 'lodash'; + +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 { BEETHOVEN_X_DEFINITION } from '../beethoven-x.definition'; +import { BeethovenXContractFactory, BeethovenXMasterchef } from '../contracts'; + +const appId = BEETHOVEN_X_DEFINITION.id; +const groupId = BEETHOVEN_X_DEFINITION.groups.farm.id; +const network = Network.FANTOM_OPERA_MAINNET; + +@Register.ContractPositionFetcher({ appId, groupId, network }) +export class FantomBeethovenXFarmContractPositionFetcher implements PositionFetcher { + constructor( + @Inject(APP_TOOLKIT) private readonly appToolkit: IAppToolkit, + @Inject(BeethovenXContractFactory) private readonly contractFactory: BeethovenXContractFactory, + ) {} + + async getPositions() { + const contractPositions = + await this.appToolkit.helpers.masterChefContractPositionHelper.getContractPositions({ + address: '0x8166994d9ebbe5829ec86bd81258149b87facfd3', + appId, + groupId, + network, + dependencies: [ + { + appId, + groupIds: [BEETHOVEN_X_DEFINITION.groups.pool.id], + network, + }, + { + appId, + groupIds: [BEETHOVEN_X_DEFINITION.groups.fBeets.id], + network, + }, + ], + resolveContract: ({ address, network }) => this.contractFactory.beethovenXMasterchef({ address, network }), + resolvePoolLength: ({ multicall, contract }) => multicall.wrap(contract).poolLength(), + resolveDepositTokenAddress: ({ poolIndex, contract, multicall }) => + multicall.wrap(contract).lpTokens(poolIndex), + resolveRewardTokenAddresses: ({ multicall, contract }) => multicall.wrap(contract).beets(), + 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).beetsPerBlock(), + }), + }); + + return compact(contractPositions); + } +} diff --git a/src/apps/beethoven-x/fantom/beethoven-x.pool.token-fetcher.ts b/src/apps/beethoven-x/fantom/beethoven-x.pool.token-fetcher.ts new file mode 100644 index 000000000..32fec3c23 --- /dev/null +++ b/src/apps/beethoven-x/fantom/beethoven-x.pool.token-fetcher.ts @@ -0,0 +1,66 @@ +import { Inject } from '@nestjs/common'; +import { compact } from 'lodash'; + +import { APP_TOOLKIT, IAppToolkit } from '~app-toolkit/app-toolkit.interface'; +import { Register } from '~app-toolkit/decorators'; +import { BalancerV2PoolLabelStrategy, BalancerV2PoolTokensHelper } from '~apps/balancer-v2'; +import { OLYMPUS_DEFINITION } from '~apps/olympus'; +import { PositionFetcher } from '~position/position-fetcher.interface'; +import { AppTokenPosition } from '~position/position.interface'; +import { Network } from '~types/network.interface'; + +import { BEETHOVEN_X_DEFINITION } from '../beethoven-x.definition'; +import { BeethovenXTheGraphPoolTokenDataStrategy } from '../helpers/beethoven-x.the-graph.pool-token-address-strategy'; + +const appId = BEETHOVEN_X_DEFINITION.id; +const groupId = BEETHOVEN_X_DEFINITION.groups.pool.id; +const network = Network.FANTOM_OPERA_MAINNET; + +@Register.TokenPositionFetcher({ appId, groupId, network }) +export class FantomBeethovenXPoolTokenFetcher implements PositionFetcher { + constructor( + @Inject(APP_TOOLKIT) private readonly appToolkit: IAppToolkit, + @Inject(BalancerV2PoolTokensHelper) private readonly poolTokensHelper: BalancerV2PoolTokensHelper, + @Inject(BeethovenXTheGraphPoolTokenDataStrategy) + private readonly beethovenXTheGraphPoolTokenDataStrategy: BeethovenXTheGraphPoolTokenDataStrategy, + ) {} + + async getPositions() { + const tokens = await this.poolTokensHelper.getTokenMarketData({ + network, + appId, + groupId, + appTokenDependencies: [ + { + appId: OLYMPUS_DEFINITION.id, + groupIds: [OLYMPUS_DEFINITION.groups.gOhm.id], + network, + }, + { + appId: BEETHOVEN_X_DEFINITION.id, + groupIds: [BEETHOVEN_X_DEFINITION.groups.fBeets.id], + network, + }, + { + appId: 'wonderland', + groupIds: ['w-memo'], + network, + }, + { + appId: 'popsicle', + groupIds: ['nIce'], + network, + }, + ], + vaultAddress: '0x20dd72ed959b6147912c2e529f0a0c651c33c9ce', + minLiquidity: 10000, + resolvePoolLabelStrategy: () => BalancerV2PoolLabelStrategy.POOL_NAME, + resolvePoolTokenAddresses: this.beethovenXTheGraphPoolTokenDataStrategy.build({ + subgraphUrl: 'https://backend.beets-ftm-node.com/graphql', + minLiquidity: 10000, + }), + }); + + return compact(tokens); + } +} diff --git a/src/apps/beethoven-x/fantom/beethoven-x.tvl-fetcher.ts b/src/apps/beethoven-x/fantom/beethoven-x.tvl-fetcher.ts new file mode 100644 index 000000000..ad48912e3 --- /dev/null +++ b/src/apps/beethoven-x/fantom/beethoven-x.tvl-fetcher.ts @@ -0,0 +1,41 @@ +import { Inject } from '@nestjs/common'; +import { gql } from 'graphql-request'; +import { sumBy } from 'lodash'; + +import { APP_TOOLKIT, IAppToolkit } from '~app-toolkit/app-toolkit.interface'; +import { Register } from '~app-toolkit/decorators'; +import { TvlFetcher } from '~stats/tvl/tvl-fetcher.interface'; +import { Network } from '~types/network.interface'; + +import { BEETHOVEN_X_DEFINITION } from '../beethoven-x.definition'; + +type QueryResponse = { + pools: { totalLiquidity: string }[]; +}; +const QUERY = gql` + { + pools { + totalLiquidity + } + } +`; +const subgraphUrl = 'https://backend.beets-ftm-node.com/graphql'; + +@Register.TvlFetcher({ appId: BEETHOVEN_X_DEFINITION.id, network: Network.FANTOM_OPERA_MAINNET }) +export class FantomBeethovenXTvlFetcher implements TvlFetcher { + constructor(@Inject(APP_TOOLKIT) private readonly appToolkit: IAppToolkit) {} + + async getTvl() { + const graphHelper = this.appToolkit.helpers.theGraphHelper; + const response = await graphHelper.request({ + endpoint: subgraphUrl, + query: QUERY, + variables: {}, + headers: { 'Content-Type': 'application/json' }, + }); + + const tvl = sumBy(response.pools, pool => Number(pool.totalLiquidity)); + + return tvl; + } +} diff --git a/src/apps/beethoven-x/helpers/beethoven-x.the-graph.pool-token-address-strategy.ts b/src/apps/beethoven-x/helpers/beethoven-x.the-graph.pool-token-address-strategy.ts new file mode 100644 index 000000000..53bae427a --- /dev/null +++ b/src/apps/beethoven-x/helpers/beethoven-x.the-graph.pool-token-address-strategy.ts @@ -0,0 +1,70 @@ +import { Inject, Injectable } from '@nestjs/common'; +import { gql } from 'graphql-request'; + +import { APP_TOOLKIT, IAppToolkit } from '~app-toolkit/app-toolkit.interface'; +import { Cache } from '~cache/cache.decorator'; +import { Network } from '~types/network.interface'; + +type PoolsResponse = { + pools: { + address: string; + totalLiquidity: string; + volume24h: string; + }[]; +}; + +const DEFAULT_POOLS_QUERY = gql` + { + pools { + address + totalLiquidity + volume24h + } + } +`; + +type BeethovenXTheGraphPoolTokenDataStrategyParams = { + subgraphUrl: string; + minLiquidity?: number; + poolsQuery?: string; +}; + +@Injectable() +export class BeethovenXTheGraphPoolTokenDataStrategy { + constructor(@Inject(APP_TOOLKIT) private readonly appToolkit: IAppToolkit) {} + + @Cache({ + instance: 'business', + key: (network: Network) => `studio-beethoven-x-events-pool-token-addresses:${network}:beethoven-x`, + ttl: 5 * 60, + }) + async getPoolAddresses(subgraphUrl: string, minLiquidity: number, poolsQuery: string) { + const graphHelper = this.appToolkit.helpers.theGraphHelper; + + const poolsResponse = await graphHelper.request({ + endpoint: subgraphUrl, + query: poolsQuery, + variables: {}, + headers: { 'Content-Type': 'application/json' }, + }); + + return poolsResponse.pools + .filter(v => Number(v.totalLiquidity) > minLiquidity) + .map(v => ({ + address: v.address, + volume: Number(v.volume24h), + })); + } + + build({ + subgraphUrl, + minLiquidity = 0, + poolsQuery = DEFAULT_POOLS_QUERY, + }: BeethovenXTheGraphPoolTokenDataStrategyParams) { + return async () => { + const poolAddresses = await this.getPoolAddresses(subgraphUrl, minLiquidity, poolsQuery); + + return poolAddresses; + }; + } +} diff --git a/src/apps/qi-dao/fantom/qi-dao.farm.contract-position-fetcher.ts b/src/apps/qi-dao/fantom/qi-dao.farm.contract-position-fetcher.ts index 9a68e3b51..28119182e 100644 --- a/src/apps/qi-dao/fantom/qi-dao.farm.contract-position-fetcher.ts +++ b/src/apps/qi-dao/fantom/qi-dao.farm.contract-position-fetcher.ts @@ -2,6 +2,7 @@ import { Inject } from '@nestjs/common'; import { APP_TOOLKIT, IAppToolkit } from '~app-toolkit/app-toolkit.interface'; import { Register } from '~app-toolkit/decorators'; +import { BEETHOVEN_X_DEFINITION } from '~apps/beethoven-x/beethoven-x.definition'; import { CURVE_DEFINITION } from '~apps/curve'; import { PositionFetcher } from '~position/position-fetcher.interface'; import { ContractPosition } from '~position/position.interface'; @@ -17,8 +18,8 @@ const FARMS: { chefAddress: string; dependencies?: AppGroupsDefinition[] }[] = [ chefAddress: '0x230917f8a262bf9f2c3959ec495b11d1b7e1affc', dependencies: [ { - appId: 'beethoven-x', - groupIds: ['pool'], + appId: BEETHOVEN_X_DEFINITION.id, + groupIds: [BEETHOVEN_X_DEFINITION.groups.pool.id], network: Network.FANTOM_OPERA_MAINNET, }, ],