From cb2c1dbdf10299360d724891801b0ca13d35f8d6 Mon Sep 17 00:00:00 2001 From: dev Date: Sun, 6 Aug 2023 23:10:53 -0400 Subject: [PATCH] feat(y2k finance): add y2k positions adapter for v1 and v2, add vlY2k adapter, add farms adapter for v1 --- ...nance.farm-v1.contract-position-fetcher.ts | 82 + ...nance.mint-v1.contract-position-fetcher.ts | 102 + ...nance.mint-v2.contract-position-fetcher.ts | 97 + ...voting-locked.contract-position-fetcher.ts | 83 + src/apps/y2k-finance/assets/logo.png | Bin 0 -> 61128 bytes .../abis/y-2-k-finance-carousel-factory.json | 829 ++++++ .../abis/y-2-k-finance-carousel.json | 1949 ++++++++++++++ .../abis/y-2-k-finance-rewards-factory.json | 172 ++ .../abis/y-2-k-finance-staking-rewards.json | 717 ++++++ .../abis/y-2-k-finance-vault-factory-v-1.json | 615 +++++ .../abis/y-2-k-finance-vault-v-1.json | 1078 ++++++++ .../abis/y-2-k-finance-voting-locked.json | 1224 +++++++++ .../contracts/ethers/Y2KFinanceCarousel.ts | 2236 +++++++++++++++++ .../ethers/Y2KFinanceCarouselFactory.ts | 958 +++++++ .../ethers/Y2KFinanceRewardsFactory.ts | 232 ++ .../ethers/Y2KFinanceStakingRewards.ts | 874 +++++++ .../ethers/Y2KFinanceVaultFactoryV1.ts | 729 ++++++ .../contracts/ethers/Y2KFinanceVaultV1.ts | 1214 +++++++++ .../ethers/Y2KFinanceVotingLocked.ts | 1337 ++++++++++ .../y2k-finance/contracts/ethers/common.ts | 32 + .../Y2KFinanceCarouselFactory__factory.ts | 847 +++++++ .../factories/Y2KFinanceCarousel__factory.ts | 1967 +++++++++++++++ .../Y2KFinanceRewardsFactory__factory.ts | 190 ++ .../Y2KFinanceStakingRewards__factory.ts | 735 ++++++ .../Y2KFinanceVaultFactoryV1__factory.ts | 633 +++++ .../factories/Y2KFinanceVaultV1__factory.ts | 1096 ++++++++ .../Y2KFinanceVotingLocked__factory.ts | 1242 +++++++++ .../contracts/ethers/factories/index.ts | 10 + .../y2k-finance/contracts/ethers/index.ts | 18 + src/apps/y2k-finance/contracts/index.ts | 55 + src/apps/y2k-finance/y2k-finance.module.ts | 21 + 31 files changed, 21374 insertions(+) create mode 100644 src/apps/y2k-finance/arbitrum/y2k-finance.farm-v1.contract-position-fetcher.ts create mode 100644 src/apps/y2k-finance/arbitrum/y2k-finance.mint-v1.contract-position-fetcher.ts create mode 100644 src/apps/y2k-finance/arbitrum/y2k-finance.mint-v2.contract-position-fetcher.ts create mode 100644 src/apps/y2k-finance/arbitrum/y2k-finance.voting-locked.contract-position-fetcher.ts create mode 100644 src/apps/y2k-finance/assets/logo.png create mode 100644 src/apps/y2k-finance/contracts/abis/y-2-k-finance-carousel-factory.json create mode 100644 src/apps/y2k-finance/contracts/abis/y-2-k-finance-carousel.json create mode 100644 src/apps/y2k-finance/contracts/abis/y-2-k-finance-rewards-factory.json create mode 100644 src/apps/y2k-finance/contracts/abis/y-2-k-finance-staking-rewards.json create mode 100644 src/apps/y2k-finance/contracts/abis/y-2-k-finance-vault-factory-v-1.json create mode 100644 src/apps/y2k-finance/contracts/abis/y-2-k-finance-vault-v-1.json create mode 100644 src/apps/y2k-finance/contracts/abis/y-2-k-finance-voting-locked.json create mode 100644 src/apps/y2k-finance/contracts/ethers/Y2KFinanceCarousel.ts create mode 100644 src/apps/y2k-finance/contracts/ethers/Y2KFinanceCarouselFactory.ts create mode 100644 src/apps/y2k-finance/contracts/ethers/Y2KFinanceRewardsFactory.ts create mode 100644 src/apps/y2k-finance/contracts/ethers/Y2KFinanceStakingRewards.ts create mode 100644 src/apps/y2k-finance/contracts/ethers/Y2KFinanceVaultFactoryV1.ts create mode 100644 src/apps/y2k-finance/contracts/ethers/Y2KFinanceVaultV1.ts create mode 100644 src/apps/y2k-finance/contracts/ethers/Y2KFinanceVotingLocked.ts create mode 100644 src/apps/y2k-finance/contracts/ethers/common.ts create mode 100644 src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceCarouselFactory__factory.ts create mode 100644 src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceCarousel__factory.ts create mode 100644 src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceRewardsFactory__factory.ts create mode 100644 src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceStakingRewards__factory.ts create mode 100644 src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceVaultFactoryV1__factory.ts create mode 100644 src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceVaultV1__factory.ts create mode 100644 src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceVotingLocked__factory.ts create mode 100644 src/apps/y2k-finance/contracts/ethers/factories/index.ts create mode 100644 src/apps/y2k-finance/contracts/ethers/index.ts create mode 100644 src/apps/y2k-finance/contracts/index.ts create mode 100644 src/apps/y2k-finance/y2k-finance.module.ts diff --git a/src/apps/y2k-finance/arbitrum/y2k-finance.farm-v1.contract-position-fetcher.ts b/src/apps/y2k-finance/arbitrum/y2k-finance.farm-v1.contract-position-fetcher.ts new file mode 100644 index 000000000..6b7afdeed --- /dev/null +++ b/src/apps/y2k-finance/arbitrum/y2k-finance.farm-v1.contract-position-fetcher.ts @@ -0,0 +1,82 @@ +import { Inject } from '@nestjs/common'; +import { BigNumberish } from 'ethers'; + +import { APP_TOOLKIT, IAppToolkit } from '~app-toolkit/app-toolkit.interface'; +import { PositionTemplate } from '~app-toolkit/decorators/position-template.decorator'; +import { DefaultDataProps } from '~position/display.interface'; +import { MetaType } from '~position/position.interface'; +import { ContractPositionTemplatePositionFetcher } from '~position/template/contract-position.template.position-fetcher'; +import { + GetDefinitionsParams, + DefaultContractPositionDefinition, + GetTokenDefinitionsParams, + UnderlyingTokenDefinition, + GetDisplayPropsParams, + GetTokenBalancesParams, +} from '~position/template/contract-position.template.types'; + +import { Y2KFinanceContractFactory, Y2KFinanceStakingRewards } from '../contracts'; + +const rewardsFactory = '0x9889fca1d9a5d131f5d4306a2bc2f293cafad2f3'; +const fromBlock = 33934362; + +@PositionTemplate() +export class ArbitrumY2KFinanceFarmV1ContractPositionFetcher extends ContractPositionTemplatePositionFetcher { + groupLabel = 'Farms'; + + constructor( + @Inject(APP_TOOLKIT) protected readonly appToolkit: IAppToolkit, + @Inject(Y2KFinanceContractFactory) protected readonly contractFactory: Y2KFinanceContractFactory, + ) { + super(appToolkit); + } + + getContract(address: string): Y2KFinanceStakingRewards { + return this.contractFactory.y2KFinanceStakingRewards({ address, network: this.network }); + } + + async getDefinitions(_params: GetDefinitionsParams): Promise { + const factory = this.contractFactory.y2KFinanceRewardsFactory({ address: rewardsFactory, network: this.network }); + const filter = factory.filters.CreatedStakingReward(); + const events = await factory.queryFilter(filter, fromBlock); + const farms = events.map(e => [e.args.hedgeFarm, e.args.riskFarm]).flat(); + return farms.map(farm => ({ address: farm })); + } + + async getTokenDefinitions( + params: GetTokenDefinitionsParams, + ): Promise { + return [ + { + metaType: MetaType.SUPPLIED, + address: await params.contract.stakingToken(), + network: this.network, + tokenId: (await params.contract.id()).toNumber(), + }, + { + metaType: MetaType.CLAIMABLE, + address: await params.contract.rewardsToken(), + network: this.network, + }, + ]; + } + + async getLabel( + params: GetDisplayPropsParams, + ): Promise { + const vault = this.contractFactory.y2KFinanceVaultV1({ + address: await params.contract.stakingToken(), + network: this.network, + }); + const name = await vault.name(); + return `${name} Farming`; + } + + async getTokenBalancesPerPosition( + params: GetTokenBalancesParams, + ): Promise { + const supply = await params.contract.balanceOf(params.address); + const rewards = await params.contract.earned(params.address); + return [supply, rewards]; + } +} diff --git a/src/apps/y2k-finance/arbitrum/y2k-finance.mint-v1.contract-position-fetcher.ts b/src/apps/y2k-finance/arbitrum/y2k-finance.mint-v1.contract-position-fetcher.ts new file mode 100644 index 000000000..5802506fc --- /dev/null +++ b/src/apps/y2k-finance/arbitrum/y2k-finance.mint-v1.contract-position-fetcher.ts @@ -0,0 +1,102 @@ +import { Inject } from '@nestjs/common'; +import { BigNumber, BigNumberish } from 'ethers'; + +import { APP_TOOLKIT, IAppToolkit } from '~app-toolkit/app-toolkit.interface'; +import { PositionTemplate } from '~app-toolkit/decorators/position-template.decorator'; +import { IMulticallWrapper } from '~multicall'; +import { DefaultDataProps } from '~position/display.interface'; +import { MetaType } from '~position/position.interface'; +import { ContractPositionTemplatePositionFetcher } from '~position/template/contract-position.template.position-fetcher'; +import { + GetDefinitionsParams, + DefaultContractPositionDefinition, + GetTokenDefinitionsParams, + UnderlyingTokenDefinition, + GetDisplayPropsParams, + GetTokenBalancesParams, +} from '~position/template/contract-position.template.types'; + +import { Y2KFinanceContractFactory, Y2KFinanceVaultV1 } from '../contracts'; + +const vaultFactory = '0x984e0eb8fb687afa53fc8b33e12e04967560e092'; + +@PositionTemplate() +export class ArbitrumY2KFinanceMintV1ContractPositionFetcher extends ContractPositionTemplatePositionFetcher { + groupLabel = 'Positions'; + + constructor( + @Inject(APP_TOOLKIT) protected readonly appToolkit: IAppToolkit, + @Inject(Y2KFinanceContractFactory) protected readonly contractFactory: Y2KFinanceContractFactory, + ) { + super(appToolkit); + } + + async getEpochIds(multicall: IMulticallWrapper, contract: Y2KFinanceVaultV1): Promise { + const vault = multicall.wrap(contract); + const epochsLength = await vault.epochsLength(); + const epochIds = await Promise.all( + Array.from(Array(Number(epochsLength)).keys()).map(async i => await vault.epochs(i)), + ); + return epochIds; + } + + getContract(address: string): Y2KFinanceVaultV1 { + return this.contractFactory.y2KFinanceVaultV1({ address, network: this.network }); + } + + async getDefinitions(params: GetDefinitionsParams): Promise { + const factory = params.multicall.wrap( + this.contractFactory.y2KFinanceVaultFactoryV1({ address: vaultFactory, network: this.network }), + ); + const poolLength = await factory.marketIndex(); + const vaults = ( + await Promise.all(Array.from(Array(Number(poolLength)).keys()).map(async i => await factory.getVaults(i))) + ).flat(); + return vaults.map(vault => ({ address: vault })); + } + + async getTokenDefinitions( + params: GetTokenDefinitionsParams, + ): Promise { + const epochIds = await this.getEpochIds(params.multicall, params.contract); + const claimableAsset = await params.contract.asset(); + return epochIds + .map(id => [ + { + metaType: MetaType.SUPPLIED, + address: params.contract.address, + network: this.network, + tokenId: id.toNumber(), + }, + { + metaType: MetaType.CLAIMABLE, + address: claimableAsset, + network: this.network, + tokenId: id.toNumber(), + }, + ]) + .flat(); + } + + async getLabel( + params: GetDisplayPropsParams, + ): Promise { + const name = await params.contract.name(); + return name; + } + + async getTokenBalancesPerPosition( + params: GetTokenBalancesParams, + ): Promise { + const epochIds = await this.getEpochIds(params.multicall, params.contract); + const vault = params.multicall.wrap(params.contract); + const results = await Promise.all( + epochIds.map(async id => { + const balance = await vault.balanceOf(params.address, id); + const claimable = await vault.previewWithdraw(id, balance); + return [balance, claimable]; + }), + ); + return results.flat(); + } +} diff --git a/src/apps/y2k-finance/arbitrum/y2k-finance.mint-v2.contract-position-fetcher.ts b/src/apps/y2k-finance/arbitrum/y2k-finance.mint-v2.contract-position-fetcher.ts new file mode 100644 index 000000000..668c3c091 --- /dev/null +++ b/src/apps/y2k-finance/arbitrum/y2k-finance.mint-v2.contract-position-fetcher.ts @@ -0,0 +1,97 @@ +import { Inject } from '@nestjs/common'; +import { BigNumberish } from 'ethers'; + +import { APP_TOOLKIT, IAppToolkit } from '~app-toolkit/app-toolkit.interface'; +import { PositionTemplate } from '~app-toolkit/decorators/position-template.decorator'; +import { DefaultDataProps } from '~position/display.interface'; +import { MetaType } from '~position/position.interface'; +import { ContractPositionTemplatePositionFetcher } from '~position/template/contract-position.template.position-fetcher'; +import { + GetDefinitionsParams, + DefaultContractPositionDefinition, + GetTokenDefinitionsParams, + UnderlyingTokenDefinition, + GetDisplayPropsParams, + GetTokenBalancesParams, +} from '~position/template/contract-position.template.types'; + +import { Y2KFinanceCarousel, Y2KFinanceContractFactory } from '../contracts'; + +const carouselFactory = '0xc3179ac01b7d68aed4f27a19510ffe2bfb78ab3e'; +const fromBlock = 96059531; + +@PositionTemplate() +export class ArbitrumY2KFinanceMintV2ContractPositionFetcher extends ContractPositionTemplatePositionFetcher { + groupLabel = 'Positions'; + + constructor( + @Inject(APP_TOOLKIT) protected readonly appToolkit: IAppToolkit, + @Inject(Y2KFinanceContractFactory) protected readonly contractFactory: Y2KFinanceContractFactory, + ) { + super(appToolkit); + } + + getContract(address: string): Y2KFinanceCarousel { + return this.contractFactory.y2KFinanceCarousel({ address, network: this.network }); + } + + async getDefinitions(_params: GetDefinitionsParams): Promise { + const factory = this.contractFactory.y2KFinanceCarouselFactory({ address: carouselFactory, network: this.network }); + const filter = factory.filters.MarketCreated(); + const events = await factory.queryFilter(filter, fromBlock); + const vaults = events.map(e => [e.args.premium, e.args.collateral]).flat(); + return vaults.map(vault => ({ address: vault })); + } + + async getTokenDefinitions( + params: GetTokenDefinitionsParams, + ): Promise { + const epochIds = await params.contract.getAllEpochs(); + const claimableAsset = await params.contract.asset(); + const emission = await params.contract.emissionsToken(); + return epochIds + .map(id => [ + { + metaType: MetaType.SUPPLIED, + address: params.contract.address, + network: this.network, + tokenId: id.toNumber(), + }, + { + metaType: MetaType.CLAIMABLE, + address: claimableAsset, + network: this.network, + tokenId: id.toNumber(), + }, + { + metaType: MetaType.CLAIMABLE, + address: emission, + network: this.network, + }, + ]) + .flat(); + } + + async getLabel( + params: GetDisplayPropsParams, + ): Promise { + const name = await params.contract.name(); + return name; + } + + async getTokenBalancesPerPosition( + params: GetTokenBalancesParams, + ): Promise { + const epochIds = await params.contract.getAllEpochs(); + const vault = params.multicall.wrap(params.contract); + const results = await Promise.all( + epochIds.map(async id => { + const balance = await vault.balanceOf(params.address, id); + const claimable = await vault.previewWithdraw(id, balance); + const emission = await vault.previewEmissionsWithdraw(id, balance); + return [balance, claimable, emission]; + }), + ); + return results.flat(); + } +} diff --git a/src/apps/y2k-finance/arbitrum/y2k-finance.voting-locked.contract-position-fetcher.ts b/src/apps/y2k-finance/arbitrum/y2k-finance.voting-locked.contract-position-fetcher.ts new file mode 100644 index 000000000..e7499dc2b --- /dev/null +++ b/src/apps/y2k-finance/arbitrum/y2k-finance.voting-locked.contract-position-fetcher.ts @@ -0,0 +1,83 @@ +import { Inject } from '@nestjs/common'; +import { BigNumberish } from 'ethers'; + +import { APP_TOOLKIT, IAppToolkit } from '~app-toolkit/app-toolkit.interface'; +import { PositionTemplate } from '~app-toolkit/decorators/position-template.decorator'; +import { DefaultDataProps } from '~position/display.interface'; +import { MetaType } from '~position/position.interface'; +import { ContractPositionTemplatePositionFetcher } from '~position/template/contract-position.template.position-fetcher'; +import { + GetDefinitionsParams, + DefaultContractPositionDefinition, + GetTokenDefinitionsParams, + UnderlyingTokenDefinition, + GetDisplayPropsParams, + GetTokenBalancesParams, +} from '~position/template/contract-position.template.types'; + +import { Y2KFinanceContractFactory, Y2KFinanceVotingLocked } from '../contracts'; + +const VLY2K = [ + { + address: '0xbdaa858fd7b0dc05f8256330facb35de86283ca0', + }, + { + address: '0xaefd22d0153e69f3316dca9095e7279b3a2f8af2', + }, +]; + +@PositionTemplate() +export class ArbitrumY2KFinanceVotingLockedContractPositionFetcher extends ContractPositionTemplatePositionFetcher { + groupLabel = 'Vote Locked Y2K'; + + constructor( + @Inject(APP_TOOLKIT) protected readonly appToolkit: IAppToolkit, + @Inject(Y2KFinanceContractFactory) protected readonly contractFactory: Y2KFinanceContractFactory, + ) { + super(appToolkit); + } + + getContract(address: string): Y2KFinanceVotingLocked { + return this.contractFactory.y2KFinanceVotingLocked({ address, network: this.network }); + } + + async getDefinitions(_params: GetDefinitionsParams): Promise { + return VLY2K; + } + + async getTokenDefinitions( + params: GetTokenDefinitionsParams, + ): Promise { + return [ + { + metaType: MetaType.SUPPLIED, + address: await params.contract.lockToken(), + network: this.network, + }, + { + metaType: MetaType.CLAIMABLE, + address: (await params.contract.rewardToken(0)).addr, + network: this.network, + }, + { + metaType: MetaType.CLAIMABLE, + address: (await params.contract.rewardToken(1)).addr, + network: this.network, + }, + ]; + } + + async getLabel( + params: GetDisplayPropsParams, + ): Promise { + const epochs = await params.contract.minEpochs(); + return `Lock${epochs.toString()}Rewards`; + } + + async getTokenBalancesPerPosition( + params: GetTokenBalancesParams, + ): Promise { + const info = await params.contract.getAccount(params.address); + return [info.balance, info.rewards1, info.rewards2]; + } +} diff --git a/src/apps/y2k-finance/assets/logo.png b/src/apps/y2k-finance/assets/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..95fa7217113dd45a4d4e67b403d51571e3ecb98c GIT binary patch literal 61128 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%0D2|zxus!j|B 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 BIKBV? literal 0 HcmV?d00001 diff --git a/src/apps/y2k-finance/contracts/abis/y-2-k-finance-carousel-factory.json b/src/apps/y2k-finance/contracts/abis/y-2-k-finance-carousel-factory.json new file mode 100644 index 000000000..202b4487c --- /dev/null +++ b/src/apps/y2k-finance/contracts/abis/y-2-k-finance-carousel-factory.json @@ -0,0 +1,829 @@ +[ + { + "inputs": [ + { + "internalType": "address", + "name": "_weth", + "type": "address" + }, + { + "internalType": "address", + "name": "_treasury", + "type": "address" + }, + { + "internalType": "address", + "name": "_timelocker", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [], + "name": "AddressZero", + "type": "error" + }, + { + "inputs": [], + "name": "ControllerNotSet", + "type": "error" + }, + { + "inputs": [], + "name": "FeeCannotBe0", + "type": "error" + }, + { + "inputs": [], + "name": "MarketAlreadyExists", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "marketId", + "type": "uint256" + } + ], + "name": "MarketDoesNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "NotAuthorized", + "type": "error" + }, + { + "inputs": [], + "name": "NotTimeLocker", + "type": "error" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "_wAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "_marketId", + "type": "uint256" + } + ], + "name": "AddressWhitelisted", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "marketId", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "controller", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "premium", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "collateral", + "type": "address" + } + ], + "name": "ControllerChanged", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "_controller", + "type": "address" + } + ], + "name": "ControllerWhitelisted", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "marketId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint40", + "name": "startEpoch", + "type": "uint40" + }, + { + "indexed": false, + "internalType": "uint40", + "name": "endEpoch", + "type": "uint40" + }, + { + "indexed": false, + "internalType": "address", + "name": "premium", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "collateral", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "strike", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint16", + "name": "withdrawalFee", + "type": "uint16" + } + ], + "name": "EpochCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "marketId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "premium", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "collateral", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "underlyingAsset", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "indexed": false, + "internalType": "string", + "name": "name", + "type": "string" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "strike", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "controller", + "type": "address" + } + ], + "name": "MarketCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "_marketId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "_oracle", + "type": "address" + } + ], + "name": "OracleChanged", + "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": false, + "internalType": "address", + "name": "_treasury", + "type": "address" + } + ], + "name": "TreasurySet", + "type": "event" + }, + { + "inputs": [], + "name": "WETH", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_marketId", + "type": "uint256" + }, + { + "internalType": "address", + "name": "_controller", + "type": "address" + } + ], + "name": "changeController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_marketId", + "type": "uint256" + }, + { + "internalType": "address", + "name": "_oracle", + "type": "address" + } + ], + "name": "changeOracle", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "name": "controllers", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_marketId", + "type": "uint256" + }, + { + "internalType": "uint40", + "name": "_epochBegin", + "type": "uint40" + }, + { + "internalType": "uint40", + "name": "_epochEnd", + "type": "uint40" + }, + { + "internalType": "uint16", + "name": "_withdrawalFee", + "type": "uint16" + } + ], + "name": "createEpoch", + "outputs": [ + { + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + }, + { + "internalType": "address[2]", + "name": "vaults", + "type": "address[2]" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "strike", + "type": "uint256" + }, + { + "internalType": "address", + "name": "oracle", + "type": "address" + }, + { + "internalType": "address", + "name": "underlyingAsset", + "type": "address" + }, + { + "internalType": "string", + "name": "name", + "type": "string" + }, + { + "internalType": "string", + "name": "tokenURI", + "type": "string" + }, + { + "internalType": "address", + "name": "controller", + "type": "address" + } + ], + "internalType": "struct VaultFactoryV2.MarketConfigurationCalldata", + "name": "_marketCalldata", + "type": "tuple" + } + ], + "name": "createNewMarket", + "outputs": [ + { + "internalType": "address", + "name": "premium", + "type": "address" + }, + { + "internalType": "address", + "name": "collateral", + "type": "address" + }, + { + "internalType": "uint256", + "name": "marketId", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "epochFee", + "outputs": [ + { + "internalType": "uint16", + "name": "", + "type": "uint16" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + } + ], + "name": "getEpochFee", + "outputs": [ + { + "internalType": "uint16", + "name": "fee", + "type": "uint16" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "marketId", + "type": "uint256" + }, + { + "internalType": "uint40", + "name": "epochBegin", + "type": "uint40" + }, + { + "internalType": "uint40", + "name": "epochEnd", + "type": "uint40" + } + ], + "name": "getEpochId", + "outputs": [ + { + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + } + ], + "stateMutability": "pure", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "marketId", + "type": "uint256" + } + ], + "name": "getEpochsByMarketId", + "outputs": [ + { + "internalType": "uint256[]", + "name": "", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "_strikePrice", + "type": "uint256" + }, + { + "internalType": "address", + "name": "_underlying", + "type": "address" + } + ], + "name": "getMarketId", + "outputs": [ + { + "internalType": "uint256", + "name": "marketId", + "type": "uint256" + } + ], + "stateMutability": "pure", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_marketId", + "type": "uint256" + } + ], + "name": "getMarketInfo", + "outputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "strike", + "type": "uint256" + }, + { + "internalType": "address", + "name": "underlyingAsset", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "index", + "type": "uint256" + } + ], + "name": "getVaults", + "outputs": [ + { + "internalType": "address[2]", + "name": "vaults", + "type": "address[2]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "marketIdInfo", + "outputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "strike", + "type": "uint256" + }, + { + "internalType": "address", + "name": "underlyingAsset", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "marketIdToEpochs", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "marketIdToVaults", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "marketToOracle", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "renounceOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_treasury", + "type": "address" + } + ], + "name": "setTreasury", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "timelocker", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_owner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "treasury", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_marketId", + "type": "uint256" + }, + { + "internalType": "address", + "name": "_wAddress", + "type": "address" + } + ], + "name": "whitelistAddressOnMarket", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_controller", + "type": "address" + } + ], + "name": "whitelistController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } +] diff --git a/src/apps/y2k-finance/contracts/abis/y-2-k-finance-carousel.json b/src/apps/y2k-finance/contracts/abis/y-2-k-finance-carousel.json new file mode 100644 index 000000000..d80c1a903 --- /dev/null +++ b/src/apps/y2k-finance/contracts/abis/y-2-k-finance-carousel.json @@ -0,0 +1,1949 @@ +[ + { + "inputs": [ + { + "components": [ + { + "internalType": "bool", + "name": "isWETH", + "type": "bool" + }, + { + "internalType": "address", + "name": "assetAddress", + "type": "address" + }, + { + "internalType": "string", + "name": "name", + "type": "string" + }, + { + "internalType": "string", + "name": "symbol", + "type": "string" + }, + { + "internalType": "string", + "name": "tokenURI", + "type": "string" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "strike", + "type": "uint256" + }, + { + "internalType": "address", + "name": "controller", + "type": "address" + }, + { + "internalType": "address", + "name": "emissionsToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "relayerFee", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "depositFee", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "minQueueDeposit", + "type": "uint256" + } + ], + "internalType": "struct Carousel.ConstructorArgs", + "name": "_data", + "type": "tuple" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_contract", + "type": "address" + } + ], + "name": "AddressNotController", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_contract", + "type": "address" + } + ], + "name": "AddressNotFactory", + "type": "error" + }, + { + "inputs": [], + "name": "AddressZero", + "type": "error" + }, + { + "inputs": [], + "name": "AlreadyInitialized", + "type": "error" + }, + { + "inputs": [], + "name": "AlreadyRollingOver", + "type": "error" + }, + { + "inputs": [], + "name": "AmountExceedsTVL", + "type": "error" + }, + { + "inputs": [], + "name": "BPSToHigh", + "type": "error" + }, + { + "inputs": [], + "name": "CanNotDepositETH", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_counterparty", + "type": "address" + } + ], + "name": "DestinationNotAuthorized", + "type": "error" + }, + { + "inputs": [], + "name": "EpochAlreadyEnded", + "type": "error" + }, + { + "inputs": [], + "name": "EpochAlreadyExists", + "type": "error" + }, + { + "inputs": [], + "name": "EpochAlreadyStarted", + "type": "error" + }, + { + "inputs": [], + "name": "EpochDoesNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "EpochEndMustBeAfterBegin", + "type": "error" + }, + { + "inputs": [], + "name": "EpochNotResolved", + "type": "error" + }, + { + "inputs": [], + "name": "EpochNotStarted", + "type": "error" + }, + { + "inputs": [], + "name": "InsufficientBalance", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidEpoch", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidEpochId", + "type": "error" + }, + { + "inputs": [], + "name": "MinDeposit", + "type": "error" + }, + { + "inputs": [], + "name": "NoRolloverQueued", + "type": "error" + }, + { + "inputs": [], + "name": "OverflowQueue", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_sender", + "type": "address" + }, + { + "internalType": "address", + "name": "_owner", + "type": "address" + } + ], + "name": "OwnerDidNotAuthorize", + "type": "error" + }, + { + "inputs": [], + "name": "RelayerFeeToLow", + "type": "error" + }, + { + "inputs": [], + "name": "ZeroValue", + "type": "error" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "account", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "operator", + "type": "address" + }, + { + "indexed": false, + "internalType": "bool", + "name": "approved", + "type": "bool" + } + ], + "name": "ApprovalForAll", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "caller", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "owner", + "type": "address" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "assets", + "type": "uint256" + } + ], + "name": "Deposit", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "receiver", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "assets", + "type": "uint256" + } + ], + "name": "DepositInQueue", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "operations", + "type": "uint256" + } + ], + "name": "RelayerMinted", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "assets", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + } + ], + "name": "RolloverQueued", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "operator", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "from", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256[]", + "name": "ids", + "type": "uint256[]" + }, + { + "indexed": false, + "internalType": "uint256[]", + "name": "values", + "type": "uint256[]" + } + ], + "name": "TransferBatch", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "operator", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "from", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + } + ], + "name": "TransferSingle", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "string", + "name": "value", + "type": "string" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "id", + "type": "uint256" + } + ], + "name": "URI", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "caller", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "receiver", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "owner", + "type": "address" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "assets", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "shares", + "type": "uint256" + } + ], + "name": "Withdraw", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "caller", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "receiver", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "owner", + "type": "address" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "assets", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "shares", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "emissions", + "type": "uint256" + } + ], + "name": "WithdrawWithEmissions", + "type": "event" + }, + { + "inputs": [], + "name": "asset", + "outputs": [ + { + "internalType": "contract IERC20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + }, + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + } + ], + "name": "balanceOf", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + }, + { + "internalType": "uint256[]", + "name": "ids", + "type": "uint256[]" + } + ], + "name": "balanceOfBatch", + "outputs": [ + { + "internalType": "uint256[]", + "name": "", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "int256", + "name": "minX", + "type": "int256" + }, + { + "internalType": "int256", + "name": "maxX", + "type": "int256" + } + ], + "name": "calculateFeePercent", + "outputs": [ + { + "internalType": "uint256", + "name": "_y", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_controller", + "type": "address" + } + ], + "name": "changeController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_depositFee", + "type": "uint256" + } + ], + "name": "changeDepositFee", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_relayerFee", + "type": "uint256" + } + ], + "name": "changeRelayerFee", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "claimTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "_addressesToDelist", + "type": "address[]" + } + ], + "name": "cleanUpRolloverQueue", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "controller", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "counterPartyVault", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_owner", + "type": "address" + } + ], + "name": "delistInRollover", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "_assets", + "type": "uint256" + }, + { + "internalType": "address", + "name": "_receiver", + "type": "address" + } + ], + "name": "deposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_id", + "type": "uint256" + }, + { + "internalType": "address", + "name": "_receiver", + "type": "address" + } + ], + "name": "depositETH", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [], + "name": "depositFee", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "depositQueue", + "outputs": [ + { + "internalType": "uint256", + "name": "shares", + "type": "uint256" + }, + { + "internalType": "address", + "name": "receiver", + "type": "address" + }, + { + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "emissions", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "emissionsToken", + "outputs": [ + { + "internalType": "contract IERC20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_epochId", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "_shares", + "type": "uint256" + }, + { + "internalType": "address", + "name": "_receiver", + "type": "address" + } + ], + "name": "enlistInRollover", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "epochAccounting", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "epochConfig", + "outputs": [ + { + "internalType": "uint40", + "name": "epochBegin", + "type": "uint40" + }, + { + "internalType": "uint40", + "name": "epochEnd", + "type": "uint40" + }, + { + "internalType": "uint40", + "name": "epochCreation", + "type": "uint40" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "epochExists", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "epochNull", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "epochResolved", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "epochs", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + } + ], + "name": "exists", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "factory", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "finalTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getAllEpochs", + "outputs": [ + { + "internalType": "uint256[]", + "name": "", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getDepositQueueLength", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getDepositQueueTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "tvl", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_id", + "type": "uint256" + } + ], + "name": "getEpochConfig", + "outputs": [ + { + "internalType": "uint40", + "name": "epochBegin", + "type": "uint40" + }, + { + "internalType": "uint40", + "name": "epochEnd", + "type": "uint40" + }, + { + "internalType": "uint40", + "name": "epochCreation", + "type": "uint40" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "_assets", + "type": "uint256" + } + ], + "name": "getEpochDepositFee", + "outputs": [ + { + "internalType": "uint256", + "name": "feeAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "assetsAfterFee", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getEpochsLength", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_owner", + "type": "address" + } + ], + "name": "getRolloverIndex", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_owner", + "type": "address" + } + ], + "name": "getRolloverPosition", + "outputs": [ + { + "internalType": "uint256", + "name": "shares", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_index", + "type": "uint256" + } + ], + "name": "getRolloverQueueItem", + "outputs": [ + { + "internalType": "address", + "name": "receiver", + "type": "address" + }, + { + "internalType": "uint256", + "name": "shares", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getRolloverQueueLength", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getRolloverTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "tvl", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_epochId", + "type": "uint256" + } + ], + "name": "getRolloverTVLByEpochId", + "outputs": [ + { + "internalType": "uint256", + "name": "tvl", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + }, + { + "internalType": "address", + "name": "operator", + "type": "address" + } + ], + "name": "isApprovedForAll", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_owner", + "type": "address" + } + ], + "name": "isEnlistedInRolloverQueue", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "isWETH", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "minQueueDeposit", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_epochId", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "_operations", + "type": "uint256" + } + ], + "name": "mintDepositInQueue", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_epochId", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "_operations", + "type": "uint256" + } + ], + "name": "mintRollovers", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "name", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "name": "ownerToRollOverQueueIndex", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "_assets", + "type": "uint256" + } + ], + "name": "previewAmountInShares", + "outputs": [ + { + "internalType": "uint256", + "name": "entitledShareAmount", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "_assets", + "type": "uint256" + } + ], + "name": "previewEmissionsWithdraw", + "outputs": [ + { + "internalType": "uint256", + "name": "entitledAmount", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "_shares", + "type": "uint256" + } + ], + "name": "previewWithdraw", + "outputs": [ + { + "internalType": "uint256", + "name": "entitledAssets", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "relayerFee", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_id", + "type": "uint256" + } + ], + "name": "resolveEpoch", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "rolloverAccounting", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "rolloverQueue", + "outputs": [ + { + "internalType": "uint256", + "name": "shares", + "type": "uint256" + }, + { + "internalType": "address", + "name": "receiver", + "type": "address" + }, + { + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + }, + { + "internalType": "address", + "name": "", + "type": "address" + }, + { + "internalType": "uint256[]", + "name": "", + "type": "uint256[]" + }, + { + "internalType": "uint256[]", + "name": "", + "type": "uint256[]" + }, + { + "internalType": "bytes", + "name": "", + "type": "bytes" + } + ], + "name": "safeBatchTransferFrom", + "outputs": [], + "stateMutability": "pure", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "from", + "type": "address" + }, + { + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "bytes", + "name": "data", + "type": "bytes" + } + ], + "name": "safeTransferFrom", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "_amount", + "type": "uint256" + }, + { + "internalType": "address", + "name": "_receiver", + "type": "address" + } + ], + "name": "sendTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "operator", + "type": "address" + }, + { + "internalType": "bool", + "name": "approved", + "type": "bool" + } + ], + "name": "setApprovalForAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "_claimTVL", + "type": "uint256" + } + ], + "name": "setClaimTVL", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_counterPartyVault", + "type": "address" + } + ], + "name": "setCounterPartyVault", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_epochId", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "_emissionAmount", + "type": "uint256" + } + ], + "name": "setEmissions", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint40", + "name": "_epochBegin", + "type": "uint40" + }, + { + "internalType": "uint40", + "name": "_epochEnd", + "type": "uint40" + }, + { + "internalType": "uint256", + "name": "_epochId", + "type": "uint256" + } + ], + "name": "setEpoch", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_id", + "type": "uint256" + } + ], + "name": "setEpochNull", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "strike", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "symbol", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "token", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_id", + "type": "uint256" + } + ], + "name": "totalAssets", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + } + ], + "name": "totalSupply", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "treasury", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "uri", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_wAddress", + "type": "address" + } + ], + "name": "whiteListAddress", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "name": "whitelistedAddresses", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "_shares", + "type": "uint256" + }, + { + "internalType": "address", + "name": "_receiver", + "type": "address" + }, + { + "internalType": "address", + "name": "_owner", + "type": "address" + } + ], + "name": "withdraw", + "outputs": [ + { + "internalType": "uint256", + "name": "assets", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + } +] diff --git a/src/apps/y2k-finance/contracts/abis/y-2-k-finance-rewards-factory.json b/src/apps/y2k-finance/contracts/abis/y-2-k-finance-rewards-factory.json new file mode 100644 index 000000000..2296f3b9d --- /dev/null +++ b/src/apps/y2k-finance/contracts/abis/y-2-k-finance-rewards-factory.json @@ -0,0 +1,172 @@ +[ + { + "inputs": [ + { + "internalType": "address", + "name": "_govToken", + "type": "address" + }, + { + "internalType": "address", + "name": "_factory", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [], + "name": "EpochDoesNotExist", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "marketId", + "type": "uint256" + } + ], + "name": "MarketDoesNotExist", + "type": "error" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "marketEpochId", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "mIndex", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "hedgeFarm", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "riskFarm", + "type": "address" + } + ], + "name": "CreatedStakingReward", + "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" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_marketIndex", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "_epochEnd", + "type": "uint256" + } + ], + "name": "createStakingRewards", + "outputs": [ + { + "internalType": "address", + "name": "insr", + "type": "address" + }, + { + "internalType": "address", + "name": "risk", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "factory", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "govToken", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "renounceOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } +] diff --git a/src/apps/y2k-finance/contracts/abis/y-2-k-finance-staking-rewards.json b/src/apps/y2k-finance/contracts/abis/y-2-k-finance-staking-rewards.json new file mode 100644 index 000000000..0b7845083 --- /dev/null +++ b/src/apps/y2k-finance/contracts/abis/y-2-k-finance-staking-rewards.json @@ -0,0 +1,717 @@ +[ + { + "inputs": [ + { + "internalType": "address", + "name": "_owner", + "type": "address" + }, + { + "internalType": "address", + "name": "_rewardsDistribution", + "type": "address" + }, + { + "internalType": "address", + "name": "_rewardsToken", + "type": "address" + }, + { + "internalType": "address", + "name": "_stakingToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "_epochEnd", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "oldOwner", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnerChanged", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnerNominated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "Recovered", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + } + ], + "name": "RewardAdded", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "user", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + } + ], + "name": "RewardPaid", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint256", + "name": "newDuration", + "type": "uint256" + } + ], + "name": "RewardsDurationUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "user", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "Staked", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "Unpaused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "user", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "Withdrawn", + "type": "event" + }, + { + "inputs": [], + "name": "acceptOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "balanceOf", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "earned", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "exit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getReward", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getRewardForDuration", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "id", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "lastTimeRewardApplicable", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "lastUpdateTime", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_owner", + "type": "address" + } + ], + "name": "nominateNewOwner", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "nominatedOwner", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "reward", + "type": "uint256" + } + ], + "name": "notifyRewardAmount", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + }, + { + "internalType": "address", + "name": "", + "type": "address" + }, + { + "internalType": "uint256[]", + "name": "", + "type": "uint256[]" + }, + { + "internalType": "uint256[]", + "name": "", + "type": "uint256[]" + }, + { + "internalType": "bytes", + "name": "", + "type": "bytes" + } + ], + "name": "onERC1155BatchReceived", + "outputs": [ + { + "internalType": "bytes4", + "name": "", + "type": "bytes4" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + }, + { + "internalType": "address", + "name": "", + "type": "address" + }, + { + "internalType": "uint256", + "name": "", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "", + "type": "uint256" + }, + { + "internalType": "bytes", + "name": "", + "type": "bytes" + } + ], + "name": "onERC1155Received", + "outputs": [ + { + "internalType": "bytes4", + "name": "", + "type": "bytes4" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "paused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "periodFinish", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "tokenAmount", + "type": "uint256" + } + ], + "name": "recoverERC20", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "rewardPerToken", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "rewardPerTokenStored", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "rewardRate", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "name": "rewards", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "rewardsDistribution", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "rewardsDuration", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "rewardsToken", + "outputs": [ + { + "internalType": "contract ERC20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_rewardsDistribution", + "type": "address" + } + ], + "name": "setRewardsDistribution", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_rewardsDuration", + "type": "uint256" + } + ], + "name": "setRewardsDuration", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "stake", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "stakingToken", + "outputs": [ + { + "internalType": "contract IERC1155", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "totalSupply", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "unpause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "name": "userRewardPerTokenPaid", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "withdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } +] diff --git a/src/apps/y2k-finance/contracts/abis/y-2-k-finance-vault-factory-v-1.json b/src/apps/y2k-finance/contracts/abis/y-2-k-finance-vault-factory-v-1.json new file mode 100644 index 000000000..f943237b1 --- /dev/null +++ b/src/apps/y2k-finance/contracts/abis/y-2-k-finance-vault-factory-v-1.json @@ -0,0 +1,615 @@ +[ + { + "inputs": [ + { + "internalType": "address", + "name": "_treasury", + "type": "address" + }, + { + "internalType": "address", + "name": "_weth", + "type": "address" + }, + { + "internalType": "address", + "name": "_policy", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [], + "name": "AddressFactoryNotInController", + "type": "error" + }, + { + "inputs": [], + "name": "AddressNotController", + "type": "error" + }, + { + "inputs": [], + "name": "AddressZero", + "type": "error" + }, + { + "inputs": [], + "name": "ControllerAlreadySet", + "type": "error" + }, + { + "inputs": [], + "name": "ControllerNotSet", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "marketIndex", + "type": "uint256" + } + ], + "name": "MarketDoesNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "NotTimeLocker", + "type": "error" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "marketEpochId", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "mIndex", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "startEpoch", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "endEpoch", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "hedge", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "risk", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "indexed": false, + "internalType": "string", + "name": "name", + "type": "string" + }, + { + "indexed": false, + "internalType": "int256", + "name": "strikePrice", + "type": "int256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "withdrawalFee", + "type": "uint256" + } + ], + "name": "EpochCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "mIndex", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "hedge", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "risk", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "indexed": false, + "internalType": "string", + "name": "name", + "type": "string" + }, + { + "indexed": false, + "internalType": "int256", + "name": "strikePrice", + "type": "int256" + } + ], + "name": "MarketCreated", + "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": "uint256", + "name": "_marketIndex", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "controller", + "type": "address" + } + ], + "name": "changedController", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "_token", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "_oracle", + "type": "address" + } + ], + "name": "changedOracle", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "_treasury", + "type": "address" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "_marketIndex", + "type": "uint256" + } + ], + "name": "changedTreasury", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "_marketIndex", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "_feeRate", + "type": "uint256" + } + ], + "name": "changedVaultFee", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "newController", + "type": "address" + } + ], + "name": "controllerSet", + "type": "event" + }, + { + "inputs": [], + "name": "WETH", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_marketIndex", + "type": "uint256" + }, + { + "internalType": "address", + "name": "_controller", + "type": "address" + } + ], + "name": "changeController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_token", + "type": "address" + }, + { + "internalType": "address", + "name": "_oracle", + "type": "address" + } + ], + "name": "changeOracle", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_treasury", + "type": "address" + }, + { + "internalType": "uint256", + "name": "_marketIndex", + "type": "uint256" + } + ], + "name": "changeTreasury", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "controller", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_withdrawalFee", + "type": "uint256" + }, + { + "internalType": "address", + "name": "_token", + "type": "address" + }, + { + "internalType": "int256", + "name": "_strikePrice", + "type": "int256" + }, + { + "internalType": "uint256", + "name": "epochBegin", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "epochEnd", + "type": "uint256" + }, + { + "internalType": "address", + "name": "_oracle", + "type": "address" + }, + { + "internalType": "string", + "name": "_name", + "type": "string" + } + ], + "name": "createNewMarket", + "outputs": [ + { + "internalType": "address", + "name": "insr", + "type": "address" + }, + { + "internalType": "address", + "name": "rsk", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "index", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "epochBegin", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "epochEnd", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "_withdrawalFee", + "type": "uint256" + } + ], + "name": "deployMoreAssets", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "index", + "type": "uint256" + } + ], + "name": "getVaults", + "outputs": [ + { + "internalType": "address[]", + "name": "vaults", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "indexEpochs", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "indexVaults", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "marketIndex", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "renounceOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_controller", + "type": "address" + } + ], + "name": "setController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "timelocker", + "outputs": [ + { + "internalType": "contract TimeLock", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "name": "tokenToOracle", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "treasury", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + } +] diff --git a/src/apps/y2k-finance/contracts/abis/y-2-k-finance-vault-v-1.json b/src/apps/y2k-finance/contracts/abis/y-2-k-finance-vault-v-1.json new file mode 100644 index 000000000..747069c48 --- /dev/null +++ b/src/apps/y2k-finance/contracts/abis/y-2-k-finance-vault-v-1.json @@ -0,0 +1,1078 @@ +[ + { + "inputs": [ + { + "internalType": "address", + "name": "_assetAddress", + "type": "address" + }, + { + "internalType": "string", + "name": "_name", + "type": "string" + }, + { + "internalType": "string", + "name": "_symbol", + "type": "string" + }, + { + "internalType": "address", + "name": "_treasury", + "type": "address" + }, + { + "internalType": "address", + "name": "_token", + "type": "address" + }, + { + "internalType": "int256", + "name": "_strikePrice", + "type": "int256" + }, + { + "internalType": "address", + "name": "_controller", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_contract", + "type": "address" + } + ], + "name": "AddressNotController", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_contract", + "type": "address" + } + ], + "name": "AddressNotFactory", + "type": "error" + }, + { + "inputs": [], + "name": "AddressZero", + "type": "error" + }, + { + "inputs": [], + "name": "EpochAlreadyStarted", + "type": "error" + }, + { + "inputs": [], + "name": "EpochEndMustBeAfterBegin", + "type": "error" + }, + { + "inputs": [], + "name": "EpochNotFinished", + "type": "error" + }, + { + "inputs": [], + "name": "FeeCannotBe0", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_fee", + "type": "uint256" + } + ], + "name": "FeeMoreThan150", + "type": "error" + }, + { + "inputs": [], + "name": "MarketEpochDoesNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "MarketEpochExists", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_sender", + "type": "address" + }, + { + "internalType": "address", + "name": "_owner", + "type": "address" + } + ], + "name": "OwnerDidNotAuthorize", + "type": "error" + }, + { + "inputs": [], + "name": "ZeroValue", + "type": "error" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "account", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "operator", + "type": "address" + }, + { + "indexed": false, + "internalType": "bool", + "name": "approved", + "type": "bool" + } + ], + "name": "ApprovalForAll", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "caller", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "owner", + "type": "address" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "assets", + "type": "uint256" + } + ], + "name": "Deposit", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "operator", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "from", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256[]", + "name": "ids", + "type": "uint256[]" + }, + { + "indexed": false, + "internalType": "uint256[]", + "name": "values", + "type": "uint256[]" + } + ], + "name": "TransferBatch", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "operator", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "from", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "value", + "type": "uint256" + } + ], + "name": "TransferSingle", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "string", + "name": "value", + "type": "string" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "id", + "type": "uint256" + } + ], + "name": "URI", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "caller", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "receiver", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "owner", + "type": "address" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "assets", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "shares", + "type": "uint256" + } + ], + "name": "Withdraw", + "type": "event" + }, + { + "inputs": [], + "name": "asset", + "outputs": [ + { + "internalType": "contract ERC20", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + }, + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + } + ], + "name": "balanceOf", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address[]", + "name": "accounts", + "type": "address[]" + }, + { + "internalType": "uint256[]", + "name": "ids", + "type": "uint256[]" + } + ], + "name": "balanceOfBatch", + "outputs": [ + { + "internalType": "uint256[]", + "name": "", + "type": "uint256[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "_epoch", + "type": "uint256" + } + ], + "name": "calculateWithdrawalFeeValue", + "outputs": [ + { + "internalType": "uint256", + "name": "feeValue", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_controller", + "type": "address" + } + ], + "name": "changeController", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_treasury", + "type": "address" + } + ], + "name": "changeTreasury", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "controller", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "epochBegin", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "epochEnd", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "_withdrawalFee", + "type": "uint256" + } + ], + "name": "createAssets", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "assets", + "type": "uint256" + }, + { + "internalType": "address", + "name": "receiver", + "type": "address" + } + ], + "name": "deposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "address", + "name": "receiver", + "type": "address" + } + ], + "name": "depositETH", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + } + ], + "name": "endEpoch", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "epochFee", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "epochNull", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "epochs", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "epochsLength", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + } + ], + "name": "exists", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "factory", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "idClaimTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "idEpochBegin", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "idEpochEnded", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "idExists", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "idFinalTVL", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + }, + { + "internalType": "address", + "name": "operator", + "type": "address" + } + ], + "name": "isApprovedForAll", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "name", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "assets", + "type": "uint256" + } + ], + "name": "previewWithdraw", + "outputs": [ + { + "internalType": "uint256", + "name": "entitledAmount", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "from", + "type": "address" + }, + { + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "internalType": "uint256[]", + "name": "ids", + "type": "uint256[]" + }, + { + "internalType": "uint256[]", + "name": "amounts", + "type": "uint256[]" + }, + { + "internalType": "bytes", + "name": "data", + "type": "bytes" + } + ], + "name": "safeBatchTransferFrom", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "from", + "type": "address" + }, + { + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "bytes", + "name": "data", + "type": "bytes" + } + ], + "name": "safeTransferFrom", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "address", + "name": "_counterparty", + "type": "address" + } + ], + "name": "sendTokens", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "operator", + "type": "address" + }, + { + "internalType": "bool", + "name": "approved", + "type": "bool" + } + ], + "name": "setApprovalForAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "claimTVL", + "type": "uint256" + } + ], + "name": "setClaimTVL", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + } + ], + "name": "setEpochNull", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "strikePrice", + "outputs": [ + { + "internalType": "int256", + "name": "", + "type": "int256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes4", + "name": "interfaceId", + "type": "bytes4" + } + ], + "name": "supportsInterface", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "symbol", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "tokenInsured", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_id", + "type": "uint256" + } + ], + "name": "totalAssets", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + } + ], + "name": "totalSupply", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "treasury", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "uri", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "id", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "assets", + "type": "uint256" + }, + { + "internalType": "address", + "name": "receiver", + "type": "address" + }, + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "name": "withdraw", + "outputs": [ + { + "internalType": "uint256", + "name": "shares", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + } +] diff --git a/src/apps/y2k-finance/contracts/abis/y-2-k-finance-voting-locked.json b/src/apps/y2k-finance/contracts/abis/y-2-k-finance-voting-locked.json new file mode 100644 index 000000000..e101cf063 --- /dev/null +++ b/src/apps/y2k-finance/contracts/abis/y-2-k-finance-voting-locked.json @@ -0,0 +1,1224 @@ +[ + { + "inputs": [ + { + "internalType": "address", + "name": "_lockToken", + "type": "address" + }, + { + "internalType": "address", + "name": "_rewardAddr1", + "type": "address" + }, + { + "internalType": "address", + "name": "_rewardAddr2", + "type": "address" + }, + { + "internalType": "uint256", + "name": "_maxEpochs", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "_minEpochs", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "governanceToken", + "type": "address" + } + ], + "name": "CannotWhitelistGovernanceToken", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "maxEpochs", + "type": "uint256" + } + ], + "name": "EpochMaxReached", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "epochStart", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "now", + "type": "uint256" + } + ], + "name": "EpochStartInvalid", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "balance", + "type": "uint256" + } + ], + "name": "FundsInLockPeriod", + "type": "error" + }, + { + "inputs": [], + "name": "IncreaseLockEpochsNotGTZero", + "type": "error" + }, + { + "inputs": [], + "name": "InsufficientAmount", + "type": "error" + }, + { + "inputs": [], + "name": "InsufficientBalance", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "available", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "rewardAmount", + "type": "uint256" + } + ], + "name": "InsufficientFundsForRewards", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "maxEpochs", + "type": "uint256" + } + ], + "name": "LockEpochsMax", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "minEpochs", + "type": "uint256" + } + ], + "name": "LockEpochsMin", + "type": "error" + }, + { + "inputs": [], + "name": "NotWhitelisted", + "type": "error" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "indexed": false, + "internalType": "bool", + "name": "tokenState", + "type": "bool" + } + ], + "name": "ChangeERC20Whiltelist", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "currentTime", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "flag", + "type": "bool" + } + ], + "name": "ChangeEnforceTime", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "currentTime", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "oldEpochs", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "newEpochs", + "type": "uint256" + } + ], + "name": "ChangeMaxLockEpochs", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "user", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "lockedEpochs", + "type": "uint256" + } + ], + "name": "Deposit", + "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": false, + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "RecoveredERC20", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "RecoveredERC721", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "user", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "totalBalance", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "lockedEpochs", + "type": "uint256" + } + ], + "name": "Relock", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "user", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward", + "type": "uint256" + } + ], + "name": "RewardPaid", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward1", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "reward2", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "start", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "finish", + "type": "uint256" + } + ], + "name": "SetNextReward", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "Unpaused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint256", + "name": "currentId", + "type": "uint256" + } + ], + "name": "UpdatedEpoch", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "user", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "Withdrawn", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "name": "accounts", + "outputs": [ + { + "internalType": "uint256", + "name": "balance", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "lockEpochs", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "lastEpochPaid", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "rewards1", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "rewards2", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "name": "balanceOf", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + }, + { + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + } + ], + "name": "balanceOfInEpoch", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bool", + "name": "flag", + "type": "bool" + } + ], + "name": "changeEnforceTime", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_maxEpochs", + "type": "uint256" + } + ], + "name": "changeMaxEpochs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "bool", + "name": "flag", + "type": "bool" + } + ], + "name": "changeRecoverWhitelist", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "claimReward", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "currentEpoch", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "lockEpochs", + "type": "uint256" + } + ], + "name": "deposit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "enforceTime", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "epochs", + "outputs": [ + { + "internalType": "uint256", + "name": "start", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "finish", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "totalLocked", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "rewards1", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "rewards2", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "isSet", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "exit", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "name": "getAccount", + "outputs": [ + { + "internalType": "uint256", + "name": "balance", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "lockEpochs", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "lastEpochPaid", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "rewards1", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "rewards2", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getCurrentEpoch", + "outputs": [ + { + "internalType": "uint256", + "name": "start", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "finish", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "locked", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "rewards1", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "rewards2", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "isSet", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + } + ], + "name": "getEpoch", + "outputs": [ + { + "internalType": "uint256", + "name": "start", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "finish", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "locked", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "rewards1", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "rewards2", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "isSet", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + }, + { + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + } + ], + "name": "getEpochAccountInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "balance", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "start", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "finish", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "locked", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "userRewards1", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "userRewards2", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "isSet", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getNextEpoch", + "outputs": [ + { + "internalType": "uint256", + "name": "start", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "finish", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "locked", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "rewards1", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "rewards2", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "isSet", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "lockToken", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "maxEpochs", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "minEpochs", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "nextUnsetEpoch", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "pause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "paused", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "tokenAmount", + "type": "uint256" + } + ], + "name": "recoverERC20", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "tokenAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "recoverERC721", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "renounceOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "rewardToken", + "outputs": [ + { + "internalType": "address", + "name": "addr", + "type": "address" + }, + { + "internalType": "uint256", + "name": "rewards", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "rewardsPaid", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "reward1", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "reward2", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "epochDurationInDays", + "type": "uint256" + } + ], + "name": "setNextEpoch", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "reward1", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "reward2", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "epochDurationInDays", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "epochStart", + "type": "uint256" + } + ], + "name": "setNextEpoch_start", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "totalAssets", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "totalLocked", + "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": [], + "name": "unpause", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "updateAccount", + "outputs": [ + { + "internalType": "uint256", + "name": "balance", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "lockEpochs", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "lastEpochPaid", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "rewards1", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "rewards2", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "updateEpochs", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "name": "whitelistRecoverERC20", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "withdraw", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } +] diff --git a/src/apps/y2k-finance/contracts/ethers/Y2KFinanceCarousel.ts b/src/apps/y2k-finance/contracts/ethers/Y2KFinanceCarousel.ts new file mode 100644 index 000000000..d73bd6b75 --- /dev/null +++ b/src/apps/y2k-finance/contracts/ethers/Y2KFinanceCarousel.ts @@ -0,0 +1,2236 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + 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, PromiseOrValue } from './common'; + +export declare namespace Carousel { + export type ConstructorArgsStruct = { + isWETH: PromiseOrValue; + assetAddress: PromiseOrValue; + name: PromiseOrValue; + symbol: PromiseOrValue; + tokenURI: PromiseOrValue; + token: PromiseOrValue; + strike: PromiseOrValue; + controller: PromiseOrValue; + emissionsToken: PromiseOrValue; + relayerFee: PromiseOrValue; + depositFee: PromiseOrValue; + minQueueDeposit: PromiseOrValue; + }; + + export type ConstructorArgsStructOutput = [ + boolean, + string, + string, + string, + string, + string, + BigNumber, + string, + string, + BigNumber, + BigNumber, + BigNumber, + ] & { + isWETH: boolean; + assetAddress: string; + name: string; + symbol: string; + tokenURI: string; + token: string; + strike: BigNumber; + controller: string; + emissionsToken: string; + relayerFee: BigNumber; + depositFee: BigNumber; + minQueueDeposit: BigNumber; + }; +} + +export interface Y2KFinanceCarouselInterface extends utils.Interface { + functions: { + 'asset()': FunctionFragment; + 'balanceOf(address,uint256)': FunctionFragment; + 'balanceOfBatch(address[],uint256[])': FunctionFragment; + 'calculateFeePercent(int256,int256)': FunctionFragment; + 'changeController(address)': FunctionFragment; + 'changeDepositFee(uint256)': FunctionFragment; + 'changeRelayerFee(uint256)': FunctionFragment; + 'claimTVL(uint256)': FunctionFragment; + 'cleanUpRolloverQueue(address[])': FunctionFragment; + 'controller()': FunctionFragment; + 'counterPartyVault()': FunctionFragment; + 'delistInRollover(address)': FunctionFragment; + 'deposit(uint256,uint256,address)': FunctionFragment; + 'depositETH(uint256,address)': FunctionFragment; + 'depositFee()': FunctionFragment; + 'depositQueue(uint256)': FunctionFragment; + 'emissions(uint256)': FunctionFragment; + 'emissionsToken()': FunctionFragment; + 'enlistInRollover(uint256,uint256,address)': FunctionFragment; + 'epochAccounting(uint256)': FunctionFragment; + 'epochConfig(uint256)': FunctionFragment; + 'epochExists(uint256)': FunctionFragment; + 'epochNull(uint256)': FunctionFragment; + 'epochResolved(uint256)': FunctionFragment; + 'epochs(uint256)': FunctionFragment; + 'exists(uint256)': FunctionFragment; + 'factory()': FunctionFragment; + 'finalTVL(uint256)': FunctionFragment; + 'getAllEpochs()': FunctionFragment; + 'getDepositQueueLength()': FunctionFragment; + 'getDepositQueueTVL()': FunctionFragment; + 'getEpochConfig(uint256)': FunctionFragment; + 'getEpochDepositFee(uint256,uint256)': FunctionFragment; + 'getEpochsLength()': FunctionFragment; + 'getRolloverIndex(address)': FunctionFragment; + 'getRolloverPosition(address)': FunctionFragment; + 'getRolloverQueueItem(uint256)': FunctionFragment; + 'getRolloverQueueLength()': FunctionFragment; + 'getRolloverTVL()': FunctionFragment; + 'getRolloverTVLByEpochId(uint256)': FunctionFragment; + 'isApprovedForAll(address,address)': FunctionFragment; + 'isEnlistedInRolloverQueue(address)': FunctionFragment; + 'isWETH()': FunctionFragment; + 'minQueueDeposit()': FunctionFragment; + 'mintDepositInQueue(uint256,uint256)': FunctionFragment; + 'mintRollovers(uint256,uint256)': FunctionFragment; + 'name()': FunctionFragment; + 'ownerToRollOverQueueIndex(address)': FunctionFragment; + 'previewAmountInShares(uint256,uint256)': FunctionFragment; + 'previewEmissionsWithdraw(uint256,uint256)': FunctionFragment; + 'previewWithdraw(uint256,uint256)': FunctionFragment; + 'relayerFee()': FunctionFragment; + 'resolveEpoch(uint256)': FunctionFragment; + 'rolloverAccounting(uint256)': FunctionFragment; + 'rolloverQueue(uint256)': FunctionFragment; + 'safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)': FunctionFragment; + 'safeTransferFrom(address,address,uint256,uint256,bytes)': FunctionFragment; + 'sendTokens(uint256,uint256,address)': FunctionFragment; + 'setApprovalForAll(address,bool)': FunctionFragment; + 'setClaimTVL(uint256,uint256)': FunctionFragment; + 'setCounterPartyVault(address)': FunctionFragment; + 'setEmissions(uint256,uint256)': FunctionFragment; + 'setEpoch(uint40,uint40,uint256)': FunctionFragment; + 'setEpochNull(uint256)': FunctionFragment; + 'strike()': FunctionFragment; + 'supportsInterface(bytes4)': FunctionFragment; + 'symbol()': FunctionFragment; + 'token()': FunctionFragment; + 'totalAssets(uint256)': FunctionFragment; + 'totalSupply(uint256)': FunctionFragment; + 'treasury()': FunctionFragment; + 'uri(uint256)': FunctionFragment; + 'whiteListAddress(address)': FunctionFragment; + 'whitelistedAddresses(address)': FunctionFragment; + 'withdraw(uint256,uint256,address,address)': FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | 'asset' + | 'balanceOf' + | 'balanceOfBatch' + | 'calculateFeePercent' + | 'changeController' + | 'changeDepositFee' + | 'changeRelayerFee' + | 'claimTVL' + | 'cleanUpRolloverQueue' + | 'controller' + | 'counterPartyVault' + | 'delistInRollover' + | 'deposit' + | 'depositETH' + | 'depositFee' + | 'depositQueue' + | 'emissions' + | 'emissionsToken' + | 'enlistInRollover' + | 'epochAccounting' + | 'epochConfig' + | 'epochExists' + | 'epochNull' + | 'epochResolved' + | 'epochs' + | 'exists' + | 'factory' + | 'finalTVL' + | 'getAllEpochs' + | 'getDepositQueueLength' + | 'getDepositQueueTVL' + | 'getEpochConfig' + | 'getEpochDepositFee' + | 'getEpochsLength' + | 'getRolloverIndex' + | 'getRolloverPosition' + | 'getRolloverQueueItem' + | 'getRolloverQueueLength' + | 'getRolloverTVL' + | 'getRolloverTVLByEpochId' + | 'isApprovedForAll' + | 'isEnlistedInRolloverQueue' + | 'isWETH' + | 'minQueueDeposit' + | 'mintDepositInQueue' + | 'mintRollovers' + | 'name' + | 'ownerToRollOverQueueIndex' + | 'previewAmountInShares' + | 'previewEmissionsWithdraw' + | 'previewWithdraw' + | 'relayerFee' + | 'resolveEpoch' + | 'rolloverAccounting' + | 'rolloverQueue' + | 'safeBatchTransferFrom' + | 'safeTransferFrom' + | 'sendTokens' + | 'setApprovalForAll' + | 'setClaimTVL' + | 'setCounterPartyVault' + | 'setEmissions' + | 'setEpoch' + | 'setEpochNull' + | 'strike' + | 'supportsInterface' + | 'symbol' + | 'token' + | 'totalAssets' + | 'totalSupply' + | 'treasury' + | 'uri' + | 'whiteListAddress' + | 'whitelistedAddresses' + | 'withdraw', + ): FunctionFragment; + + encodeFunctionData(functionFragment: 'asset', values?: undefined): string; + encodeFunctionData( + functionFragment: 'balanceOf', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData( + functionFragment: 'balanceOfBatch', + values: [PromiseOrValue[], PromiseOrValue[]], + ): string; + encodeFunctionData( + functionFragment: 'calculateFeePercent', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'changeController', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'changeDepositFee', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'changeRelayerFee', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'claimTVL', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'cleanUpRolloverQueue', values: [PromiseOrValue[]]): string; + encodeFunctionData(functionFragment: 'controller', values?: undefined): string; + encodeFunctionData(functionFragment: 'counterPartyVault', values?: undefined): string; + encodeFunctionData(functionFragment: 'delistInRollover', values: [PromiseOrValue]): string; + encodeFunctionData( + functionFragment: 'deposit', + values: [PromiseOrValue, PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData( + functionFragment: 'depositETH', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'depositFee', values?: undefined): string; + encodeFunctionData(functionFragment: 'depositQueue', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'emissions', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'emissionsToken', values?: undefined): string; + encodeFunctionData( + functionFragment: 'enlistInRollover', + values: [PromiseOrValue, PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'epochAccounting', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'epochConfig', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'epochExists', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'epochNull', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'epochResolved', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'epochs', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'exists', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'factory', values?: undefined): string; + encodeFunctionData(functionFragment: 'finalTVL', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'getAllEpochs', values?: undefined): string; + encodeFunctionData(functionFragment: 'getDepositQueueLength', values?: undefined): string; + encodeFunctionData(functionFragment: 'getDepositQueueTVL', values?: undefined): string; + encodeFunctionData(functionFragment: 'getEpochConfig', values: [PromiseOrValue]): string; + encodeFunctionData( + functionFragment: 'getEpochDepositFee', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'getEpochsLength', values?: undefined): string; + encodeFunctionData(functionFragment: 'getRolloverIndex', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'getRolloverPosition', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'getRolloverQueueItem', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'getRolloverQueueLength', values?: undefined): string; + encodeFunctionData(functionFragment: 'getRolloverTVL', values?: undefined): string; + encodeFunctionData(functionFragment: 'getRolloverTVLByEpochId', values: [PromiseOrValue]): string; + encodeFunctionData( + functionFragment: 'isApprovedForAll', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'isEnlistedInRolloverQueue', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'isWETH', values?: undefined): string; + encodeFunctionData(functionFragment: 'minQueueDeposit', values?: undefined): string; + encodeFunctionData( + functionFragment: 'mintDepositInQueue', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData( + functionFragment: 'mintRollovers', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'name', values?: undefined): string; + encodeFunctionData(functionFragment: 'ownerToRollOverQueueIndex', values: [PromiseOrValue]): string; + encodeFunctionData( + functionFragment: 'previewAmountInShares', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData( + functionFragment: 'previewEmissionsWithdraw', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData( + functionFragment: 'previewWithdraw', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'relayerFee', values?: undefined): string; + encodeFunctionData(functionFragment: 'resolveEpoch', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'rolloverAccounting', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'rolloverQueue', values: [PromiseOrValue]): string; + encodeFunctionData( + functionFragment: 'safeBatchTransferFrom', + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue, + ], + ): string; + encodeFunctionData( + functionFragment: 'safeTransferFrom', + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + ], + ): string; + encodeFunctionData( + functionFragment: 'sendTokens', + values: [PromiseOrValue, PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData( + functionFragment: 'setApprovalForAll', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData( + functionFragment: 'setClaimTVL', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'setCounterPartyVault', values: [PromiseOrValue]): string; + encodeFunctionData( + functionFragment: 'setEmissions', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData( + functionFragment: 'setEpoch', + values: [PromiseOrValue, PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'setEpochNull', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'strike', values?: undefined): string; + encodeFunctionData(functionFragment: 'supportsInterface', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'symbol', values?: undefined): string; + encodeFunctionData(functionFragment: 'token', values?: undefined): string; + encodeFunctionData(functionFragment: 'totalAssets', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'totalSupply', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'treasury', values?: undefined): string; + encodeFunctionData(functionFragment: 'uri', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'whiteListAddress', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'whitelistedAddresses', values: [PromiseOrValue]): string; + encodeFunctionData( + functionFragment: 'withdraw', + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + ], + ): string; + + decodeFunctionResult(functionFragment: 'asset', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'balanceOf', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'balanceOfBatch', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'calculateFeePercent', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'changeController', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'changeDepositFee', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'changeRelayerFee', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'claimTVL', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'cleanUpRolloverQueue', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'controller', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'counterPartyVault', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'delistInRollover', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'deposit', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'depositETH', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'depositFee', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'depositQueue', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'emissions', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'emissionsToken', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'enlistInRollover', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'epochAccounting', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'epochConfig', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'epochExists', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'epochNull', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'epochResolved', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'epochs', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'exists', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'factory', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'finalTVL', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getAllEpochs', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getDepositQueueLength', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getDepositQueueTVL', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getEpochConfig', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getEpochDepositFee', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getEpochsLength', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getRolloverIndex', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getRolloverPosition', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getRolloverQueueItem', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getRolloverQueueLength', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getRolloverTVL', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getRolloverTVLByEpochId', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'isApprovedForAll', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'isEnlistedInRolloverQueue', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'isWETH', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'minQueueDeposit', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'mintDepositInQueue', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'mintRollovers', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'name', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'ownerToRollOverQueueIndex', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'previewAmountInShares', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'previewEmissionsWithdraw', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'previewWithdraw', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'relayerFee', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'resolveEpoch', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'rolloverAccounting', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'rolloverQueue', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'safeBatchTransferFrom', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'safeTransferFrom', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'sendTokens', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'setApprovalForAll', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'setClaimTVL', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'setCounterPartyVault', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'setEmissions', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'setEpoch', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'setEpochNull', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'strike', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'supportsInterface', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'symbol', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'token', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'totalAssets', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'totalSupply', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'treasury', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'uri', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'whiteListAddress', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'whitelistedAddresses', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'withdraw', data: BytesLike): Result; + + events: { + 'ApprovalForAll(address,address,bool)': EventFragment; + 'Deposit(address,address,uint256,uint256)': EventFragment; + 'DepositInQueue(address,address,uint256,uint256)': EventFragment; + 'RelayerMinted(uint256,uint256)': EventFragment; + 'RolloverQueued(address,uint256,uint256)': EventFragment; + 'TransferBatch(address,address,address,uint256[],uint256[])': EventFragment; + 'TransferSingle(address,address,address,uint256,uint256)': EventFragment; + 'URI(string,uint256)': EventFragment; + 'Withdraw(address,address,address,uint256,uint256,uint256)': EventFragment; + 'WithdrawWithEmissions(address,address,address,uint256,uint256,uint256,uint256)': EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: 'ApprovalForAll'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Deposit'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'DepositInQueue'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'RelayerMinted'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'RolloverQueued'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'TransferBatch'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'TransferSingle'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'URI'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Withdraw'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'WithdrawWithEmissions'): EventFragment; +} + +export interface ApprovalForAllEventObject { + account: string; + operator: string; + approved: boolean; +} +export type ApprovalForAllEvent = TypedEvent<[string, string, boolean], ApprovalForAllEventObject>; + +export type ApprovalForAllEventFilter = TypedEventFilter; + +export interface DepositEventObject { + caller: string; + owner: string; + id: BigNumber; + assets: BigNumber; +} +export type DepositEvent = TypedEvent<[string, string, BigNumber, BigNumber], DepositEventObject>; + +export type DepositEventFilter = TypedEventFilter; + +export interface DepositInQueueEventObject { + sender: string; + receiver: string; + epochId: BigNumber; + assets: BigNumber; +} +export type DepositInQueueEvent = TypedEvent<[string, string, BigNumber, BigNumber], DepositInQueueEventObject>; + +export type DepositInQueueEventFilter = TypedEventFilter; + +export interface RelayerMintedEventObject { + epochId: BigNumber; + operations: BigNumber; +} +export type RelayerMintedEvent = TypedEvent<[BigNumber, BigNumber], RelayerMintedEventObject>; + +export type RelayerMintedEventFilter = TypedEventFilter; + +export interface RolloverQueuedEventObject { + sender: string; + assets: BigNumber; + epochId: BigNumber; +} +export type RolloverQueuedEvent = TypedEvent<[string, BigNumber, BigNumber], RolloverQueuedEventObject>; + +export type RolloverQueuedEventFilter = TypedEventFilter; + +export interface TransferBatchEventObject { + operator: string; + from: string; + to: string; + ids: BigNumber[]; + values: BigNumber[]; +} +export type TransferBatchEvent = TypedEvent< + [string, string, string, BigNumber[], BigNumber[]], + TransferBatchEventObject +>; + +export type TransferBatchEventFilter = TypedEventFilter; + +export interface TransferSingleEventObject { + operator: string; + from: string; + to: string; + id: BigNumber; + value: BigNumber; +} +export type TransferSingleEvent = TypedEvent<[string, string, string, BigNumber, BigNumber], TransferSingleEventObject>; + +export type TransferSingleEventFilter = TypedEventFilter; + +export interface URIEventObject { + value: string; + id: BigNumber; +} +export type URIEvent = TypedEvent<[string, BigNumber], URIEventObject>; + +export type URIEventFilter = TypedEventFilter; + +export interface WithdrawEventObject { + caller: string; + receiver: string; + owner: string; + id: BigNumber; + assets: BigNumber; + shares: BigNumber; +} +export type WithdrawEvent = TypedEvent<[string, string, string, BigNumber, BigNumber, BigNumber], WithdrawEventObject>; + +export type WithdrawEventFilter = TypedEventFilter; + +export interface WithdrawWithEmissionsEventObject { + caller: string; + receiver: string; + owner: string; + id: BigNumber; + assets: BigNumber; + shares: BigNumber; + emissions: BigNumber; +} +export type WithdrawWithEmissionsEvent = TypedEvent< + [string, string, string, BigNumber, BigNumber, BigNumber, BigNumber], + WithdrawWithEmissionsEventObject +>; + +export type WithdrawWithEmissionsEventFilter = TypedEventFilter; + +export interface Y2KFinanceCarousel extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: Y2KFinanceCarouselInterface; + + 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: { + asset(overrides?: CallOverrides): Promise<[string]>; + + balanceOf( + account: PromiseOrValue, + id: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[BigNumber]>; + + balanceOfBatch( + accounts: PromiseOrValue[], + ids: PromiseOrValue[], + overrides?: CallOverrides, + ): Promise<[BigNumber[]]>; + + calculateFeePercent( + minX: PromiseOrValue, + maxX: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[BigNumber] & { _y: BigNumber }>; + + changeController( + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeDepositFee( + _depositFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeRelayerFee( + _relayerFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + claimTVL(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; + + cleanUpRolloverQueue( + _addressesToDelist: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + controller(overrides?: CallOverrides): Promise<[string]>; + + counterPartyVault(overrides?: CallOverrides): Promise<[string]>; + + delistInRollover( + _owner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + deposit( + _id: PromiseOrValue, + _assets: PromiseOrValue, + _receiver: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + depositETH( + _id: PromiseOrValue, + _receiver: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue }, + ): Promise; + + depositFee(overrides?: CallOverrides): Promise<[BigNumber]>; + + depositQueue( + arg0: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, string, BigNumber] & { + shares: BigNumber; + receiver: string; + epochId: BigNumber; + } + >; + + emissions(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; + + emissionsToken(overrides?: CallOverrides): Promise<[string]>; + + enlistInRollover( + _epochId: PromiseOrValue, + _shares: PromiseOrValue, + _receiver: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + epochAccounting(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; + + epochConfig( + arg0: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [number, number, number] & { + epochBegin: number; + epochEnd: number; + epochCreation: number; + } + >; + + epochExists(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[boolean]>; + + epochNull(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[boolean]>; + + epochResolved(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[boolean]>; + + epochs(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; + + exists(id: PromiseOrValue, overrides?: CallOverrides): Promise<[boolean]>; + + factory(overrides?: CallOverrides): Promise<[string]>; + + finalTVL(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; + + getAllEpochs(overrides?: CallOverrides): Promise<[BigNumber[]]>; + + getDepositQueueLength(overrides?: CallOverrides): Promise<[BigNumber]>; + + getDepositQueueTVL(overrides?: CallOverrides): Promise<[BigNumber] & { tvl: BigNumber }>; + + getEpochConfig( + _id: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [number, number, number] & { + epochBegin: number; + epochEnd: number; + epochCreation: number; + } + >; + + getEpochDepositFee( + _id: PromiseOrValue, + _assets: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber] & { + feeAmount: BigNumber; + assetsAfterFee: BigNumber; + } + >; + + getEpochsLength(overrides?: CallOverrides): Promise<[BigNumber]>; + + getRolloverIndex(_owner: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; + + getRolloverPosition( + _owner: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[BigNumber, BigNumber] & { shares: BigNumber; epochId: BigNumber }>; + + getRolloverQueueItem( + _index: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [string, BigNumber, BigNumber] & { + receiver: string; + shares: BigNumber; + epochId: BigNumber; + } + >; + + getRolloverQueueLength(overrides?: CallOverrides): Promise<[BigNumber]>; + + getRolloverTVL(overrides?: CallOverrides): Promise<[BigNumber] & { tvl: BigNumber }>; + + getRolloverTVLByEpochId( + _epochId: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[BigNumber] & { tvl: BigNumber }>; + + isApprovedForAll( + account: PromiseOrValue, + operator: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[boolean]>; + + isEnlistedInRolloverQueue(_owner: PromiseOrValue, overrides?: CallOverrides): Promise<[boolean]>; + + isWETH(overrides?: CallOverrides): Promise<[boolean]>; + + minQueueDeposit(overrides?: CallOverrides): Promise<[BigNumber]>; + + mintDepositInQueue( + _epochId: PromiseOrValue, + _operations: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + mintRollovers( + _epochId: PromiseOrValue, + _operations: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + name(overrides?: CallOverrides): Promise<[string]>; + + ownerToRollOverQueueIndex(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; + + previewAmountInShares( + _id: PromiseOrValue, + _assets: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[BigNumber] & { entitledShareAmount: BigNumber }>; + + previewEmissionsWithdraw( + _id: PromiseOrValue, + _assets: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[BigNumber] & { entitledAmount: BigNumber }>; + + previewWithdraw( + _id: PromiseOrValue, + _shares: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[BigNumber] & { entitledAssets: BigNumber }>; + + relayerFee(overrides?: CallOverrides): Promise<[BigNumber]>; + + resolveEpoch( + _id: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + rolloverAccounting(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; + + rolloverQueue( + arg0: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, string, BigNumber] & { + shares: BigNumber; + receiver: string; + epochId: BigNumber; + } + >; + + safeBatchTransferFrom( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + arg2: PromiseOrValue[], + arg3: PromiseOrValue[], + arg4: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[void]>; + + safeTransferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + sendTokens( + _id: PromiseOrValue, + _amount: PromiseOrValue, + _receiver: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setApprovalForAll( + operator: PromiseOrValue, + approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setClaimTVL( + _id: PromiseOrValue, + _claimTVL: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setCounterPartyVault( + _counterPartyVault: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setEmissions( + _epochId: PromiseOrValue, + _emissionAmount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setEpoch( + _epochBegin: PromiseOrValue, + _epochEnd: PromiseOrValue, + _epochId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setEpochNull( + _id: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + strike(overrides?: CallOverrides): Promise<[BigNumber]>; + + supportsInterface(interfaceId: PromiseOrValue, overrides?: CallOverrides): Promise<[boolean]>; + + symbol(overrides?: CallOverrides): Promise<[string]>; + + token(overrides?: CallOverrides): Promise<[string]>; + + totalAssets(_id: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; + + totalSupply(id: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; + + treasury(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + uri(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[string]>; + + whiteListAddress( + _wAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + whitelistedAddresses(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[boolean]>; + + withdraw( + _id: PromiseOrValue, + _shares: PromiseOrValue, + _receiver: PromiseOrValue, + _owner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + }; + + asset(overrides?: CallOverrides): Promise; + + balanceOf( + account: PromiseOrValue, + id: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + balanceOfBatch( + accounts: PromiseOrValue[], + ids: PromiseOrValue[], + overrides?: CallOverrides, + ): Promise; + + calculateFeePercent( + minX: PromiseOrValue, + maxX: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + changeController( + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeDepositFee( + _depositFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeRelayerFee( + _relayerFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + claimTVL(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + cleanUpRolloverQueue( + _addressesToDelist: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + controller(overrides?: CallOverrides): Promise; + + counterPartyVault(overrides?: CallOverrides): Promise; + + delistInRollover( + _owner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + deposit( + _id: PromiseOrValue, + _assets: PromiseOrValue, + _receiver: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + depositETH( + _id: PromiseOrValue, + _receiver: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue }, + ): Promise; + + depositFee(overrides?: CallOverrides): Promise; + + depositQueue( + arg0: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, string, BigNumber] & { + shares: BigNumber; + receiver: string; + epochId: BigNumber; + } + >; + + emissions(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + emissionsToken(overrides?: CallOverrides): Promise; + + enlistInRollover( + _epochId: PromiseOrValue, + _shares: PromiseOrValue, + _receiver: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + epochAccounting(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochConfig( + arg0: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [number, number, number] & { + epochBegin: number; + epochEnd: number; + epochCreation: number; + } + >; + + epochExists(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochNull(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochResolved(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochs(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + exists(id: PromiseOrValue, overrides?: CallOverrides): Promise; + + factory(overrides?: CallOverrides): Promise; + + finalTVL(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + getAllEpochs(overrides?: CallOverrides): Promise; + + getDepositQueueLength(overrides?: CallOverrides): Promise; + + getDepositQueueTVL(overrides?: CallOverrides): Promise; + + getEpochConfig( + _id: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [number, number, number] & { + epochBegin: number; + epochEnd: number; + epochCreation: number; + } + >; + + getEpochDepositFee( + _id: PromiseOrValue, + _assets: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[BigNumber, BigNumber] & { feeAmount: BigNumber; assetsAfterFee: BigNumber }>; + + getEpochsLength(overrides?: CallOverrides): Promise; + + getRolloverIndex(_owner: PromiseOrValue, overrides?: CallOverrides): Promise; + + getRolloverPosition( + _owner: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[BigNumber, BigNumber] & { shares: BigNumber; epochId: BigNumber }>; + + getRolloverQueueItem( + _index: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [string, BigNumber, BigNumber] & { + receiver: string; + shares: BigNumber; + epochId: BigNumber; + } + >; + + getRolloverQueueLength(overrides?: CallOverrides): Promise; + + getRolloverTVL(overrides?: CallOverrides): Promise; + + getRolloverTVLByEpochId(_epochId: PromiseOrValue, overrides?: CallOverrides): Promise; + + isApprovedForAll( + account: PromiseOrValue, + operator: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + isEnlistedInRolloverQueue(_owner: PromiseOrValue, overrides?: CallOverrides): Promise; + + isWETH(overrides?: CallOverrides): Promise; + + minQueueDeposit(overrides?: CallOverrides): Promise; + + mintDepositInQueue( + _epochId: PromiseOrValue, + _operations: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + mintRollovers( + _epochId: PromiseOrValue, + _operations: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + name(overrides?: CallOverrides): Promise; + + ownerToRollOverQueueIndex(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + previewAmountInShares( + _id: PromiseOrValue, + _assets: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + previewEmissionsWithdraw( + _id: PromiseOrValue, + _assets: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + previewWithdraw( + _id: PromiseOrValue, + _shares: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + relayerFee(overrides?: CallOverrides): Promise; + + resolveEpoch( + _id: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + rolloverAccounting(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + rolloverQueue( + arg0: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, string, BigNumber] & { + shares: BigNumber; + receiver: string; + epochId: BigNumber; + } + >; + + safeBatchTransferFrom( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + arg2: PromiseOrValue[], + arg3: PromiseOrValue[], + arg4: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + safeTransferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + sendTokens( + _id: PromiseOrValue, + _amount: PromiseOrValue, + _receiver: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setApprovalForAll( + operator: PromiseOrValue, + approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setClaimTVL( + _id: PromiseOrValue, + _claimTVL: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setCounterPartyVault( + _counterPartyVault: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setEmissions( + _epochId: PromiseOrValue, + _emissionAmount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setEpoch( + _epochBegin: PromiseOrValue, + _epochEnd: PromiseOrValue, + _epochId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setEpochNull( + _id: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + strike(overrides?: CallOverrides): Promise; + + supportsInterface(interfaceId: PromiseOrValue, overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + token(overrides?: CallOverrides): Promise; + + totalAssets(_id: PromiseOrValue, overrides?: CallOverrides): Promise; + + totalSupply(id: PromiseOrValue, overrides?: CallOverrides): Promise; + + treasury(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + uri(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + whiteListAddress( + _wAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + whitelistedAddresses(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + withdraw( + _id: PromiseOrValue, + _shares: PromiseOrValue, + _receiver: PromiseOrValue, + _owner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + callStatic: { + asset(overrides?: CallOverrides): Promise; + + balanceOf( + account: PromiseOrValue, + id: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + balanceOfBatch( + accounts: PromiseOrValue[], + ids: PromiseOrValue[], + overrides?: CallOverrides, + ): Promise; + + calculateFeePercent( + minX: PromiseOrValue, + maxX: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + changeController(_controller: PromiseOrValue, overrides?: CallOverrides): Promise; + + changeDepositFee(_depositFee: PromiseOrValue, overrides?: CallOverrides): Promise; + + changeRelayerFee(_relayerFee: PromiseOrValue, overrides?: CallOverrides): Promise; + + claimTVL(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + cleanUpRolloverQueue(_addressesToDelist: PromiseOrValue[], overrides?: CallOverrides): Promise; + + controller(overrides?: CallOverrides): Promise; + + counterPartyVault(overrides?: CallOverrides): Promise; + + delistInRollover(_owner: PromiseOrValue, overrides?: CallOverrides): Promise; + + deposit( + _id: PromiseOrValue, + _assets: PromiseOrValue, + _receiver: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + depositETH( + _id: PromiseOrValue, + _receiver: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + depositFee(overrides?: CallOverrides): Promise; + + depositQueue( + arg0: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, string, BigNumber] & { + shares: BigNumber; + receiver: string; + epochId: BigNumber; + } + >; + + emissions(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + emissionsToken(overrides?: CallOverrides): Promise; + + enlistInRollover( + _epochId: PromiseOrValue, + _shares: PromiseOrValue, + _receiver: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + epochAccounting(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochConfig( + arg0: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [number, number, number] & { + epochBegin: number; + epochEnd: number; + epochCreation: number; + } + >; + + epochExists(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochNull(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochResolved(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochs(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + exists(id: PromiseOrValue, overrides?: CallOverrides): Promise; + + factory(overrides?: CallOverrides): Promise; + + finalTVL(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + getAllEpochs(overrides?: CallOverrides): Promise; + + getDepositQueueLength(overrides?: CallOverrides): Promise; + + getDepositQueueTVL(overrides?: CallOverrides): Promise; + + getEpochConfig( + _id: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [number, number, number] & { + epochBegin: number; + epochEnd: number; + epochCreation: number; + } + >; + + getEpochDepositFee( + _id: PromiseOrValue, + _assets: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber] & { + feeAmount: BigNumber; + assetsAfterFee: BigNumber; + } + >; + + getEpochsLength(overrides?: CallOverrides): Promise; + + getRolloverIndex(_owner: PromiseOrValue, overrides?: CallOverrides): Promise; + + getRolloverPosition( + _owner: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[BigNumber, BigNumber] & { shares: BigNumber; epochId: BigNumber }>; + + getRolloverQueueItem( + _index: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [string, BigNumber, BigNumber] & { + receiver: string; + shares: BigNumber; + epochId: BigNumber; + } + >; + + getRolloverQueueLength(overrides?: CallOverrides): Promise; + + getRolloverTVL(overrides?: CallOverrides): Promise; + + getRolloverTVLByEpochId(_epochId: PromiseOrValue, overrides?: CallOverrides): Promise; + + isApprovedForAll( + account: PromiseOrValue, + operator: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + isEnlistedInRolloverQueue(_owner: PromiseOrValue, overrides?: CallOverrides): Promise; + + isWETH(overrides?: CallOverrides): Promise; + + minQueueDeposit(overrides?: CallOverrides): Promise; + + mintDepositInQueue( + _epochId: PromiseOrValue, + _operations: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + mintRollovers( + _epochId: PromiseOrValue, + _operations: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + name(overrides?: CallOverrides): Promise; + + ownerToRollOverQueueIndex(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + previewAmountInShares( + _id: PromiseOrValue, + _assets: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + previewEmissionsWithdraw( + _id: PromiseOrValue, + _assets: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + previewWithdraw( + _id: PromiseOrValue, + _shares: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + relayerFee(overrides?: CallOverrides): Promise; + + resolveEpoch(_id: PromiseOrValue, overrides?: CallOverrides): Promise; + + rolloverAccounting(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + rolloverQueue( + arg0: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, string, BigNumber] & { + shares: BigNumber; + receiver: string; + epochId: BigNumber; + } + >; + + safeBatchTransferFrom( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + arg2: PromiseOrValue[], + arg3: PromiseOrValue[], + arg4: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + safeTransferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + sendTokens( + _id: PromiseOrValue, + _amount: PromiseOrValue, + _receiver: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + setApprovalForAll( + operator: PromiseOrValue, + approved: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + setClaimTVL( + _id: PromiseOrValue, + _claimTVL: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + setCounterPartyVault(_counterPartyVault: PromiseOrValue, overrides?: CallOverrides): Promise; + + setEmissions( + _epochId: PromiseOrValue, + _emissionAmount: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + setEpoch( + _epochBegin: PromiseOrValue, + _epochEnd: PromiseOrValue, + _epochId: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + setEpochNull(_id: PromiseOrValue, overrides?: CallOverrides): Promise; + + strike(overrides?: CallOverrides): Promise; + + supportsInterface(interfaceId: PromiseOrValue, overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + token(overrides?: CallOverrides): Promise; + + totalAssets(_id: PromiseOrValue, overrides?: CallOverrides): Promise; + + totalSupply(id: PromiseOrValue, overrides?: CallOverrides): Promise; + + treasury(overrides?: CallOverrides): Promise; + + uri(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + whiteListAddress(_wAddress: PromiseOrValue, overrides?: CallOverrides): Promise; + + whitelistedAddresses(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + withdraw( + _id: PromiseOrValue, + _shares: PromiseOrValue, + _receiver: PromiseOrValue, + _owner: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + }; + + filters: { + 'ApprovalForAll(address,address,bool)'( + account?: PromiseOrValue | null, + operator?: PromiseOrValue | null, + approved?: null, + ): ApprovalForAllEventFilter; + ApprovalForAll( + account?: PromiseOrValue | null, + operator?: PromiseOrValue | null, + approved?: null, + ): ApprovalForAllEventFilter; + + 'Deposit(address,address,uint256,uint256)'( + caller?: null, + owner?: PromiseOrValue | null, + id?: PromiseOrValue | null, + assets?: null, + ): DepositEventFilter; + Deposit( + caller?: null, + owner?: PromiseOrValue | null, + id?: PromiseOrValue | null, + assets?: null, + ): DepositEventFilter; + + 'DepositInQueue(address,address,uint256,uint256)'( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + epochId?: null, + assets?: null, + ): DepositInQueueEventFilter; + DepositInQueue( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + epochId?: null, + assets?: null, + ): DepositInQueueEventFilter; + + 'RelayerMinted(uint256,uint256)'(epochId?: null, operations?: null): RelayerMintedEventFilter; + RelayerMinted(epochId?: null, operations?: null): RelayerMintedEventFilter; + + 'RolloverQueued(address,uint256,uint256)'( + sender?: PromiseOrValue | null, + assets?: null, + epochId?: null, + ): RolloverQueuedEventFilter; + RolloverQueued(sender?: PromiseOrValue | null, assets?: null, epochId?: null): RolloverQueuedEventFilter; + + 'TransferBatch(address,address,address,uint256[],uint256[])'( + operator?: PromiseOrValue | null, + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + ids?: null, + values?: null, + ): TransferBatchEventFilter; + TransferBatch( + operator?: PromiseOrValue | null, + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + ids?: null, + values?: null, + ): TransferBatchEventFilter; + + 'TransferSingle(address,address,address,uint256,uint256)'( + operator?: PromiseOrValue | null, + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + id?: null, + value?: null, + ): TransferSingleEventFilter; + TransferSingle( + operator?: PromiseOrValue | null, + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + id?: null, + value?: null, + ): TransferSingleEventFilter; + + 'URI(string,uint256)'(value?: null, id?: PromiseOrValue | null): URIEventFilter; + URI(value?: null, id?: PromiseOrValue | null): URIEventFilter; + + 'Withdraw(address,address,address,uint256,uint256,uint256)'( + caller?: null, + receiver?: null, + owner?: PromiseOrValue | null, + id?: PromiseOrValue | null, + assets?: null, + shares?: null, + ): WithdrawEventFilter; + Withdraw( + caller?: null, + receiver?: null, + owner?: PromiseOrValue | null, + id?: PromiseOrValue | null, + assets?: null, + shares?: null, + ): WithdrawEventFilter; + + 'WithdrawWithEmissions(address,address,address,uint256,uint256,uint256,uint256)'( + caller?: null, + receiver?: null, + owner?: PromiseOrValue | null, + id?: PromiseOrValue | null, + assets?: null, + shares?: null, + emissions?: null, + ): WithdrawWithEmissionsEventFilter; + WithdrawWithEmissions( + caller?: null, + receiver?: null, + owner?: PromiseOrValue | null, + id?: PromiseOrValue | null, + assets?: null, + shares?: null, + emissions?: null, + ): WithdrawWithEmissionsEventFilter; + }; + + estimateGas: { + asset(overrides?: CallOverrides): Promise; + + balanceOf( + account: PromiseOrValue, + id: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + balanceOfBatch( + accounts: PromiseOrValue[], + ids: PromiseOrValue[], + overrides?: CallOverrides, + ): Promise; + + calculateFeePercent( + minX: PromiseOrValue, + maxX: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + changeController( + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeDepositFee( + _depositFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeRelayerFee( + _relayerFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + claimTVL(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + cleanUpRolloverQueue( + _addressesToDelist: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + controller(overrides?: CallOverrides): Promise; + + counterPartyVault(overrides?: CallOverrides): Promise; + + delistInRollover( + _owner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + deposit( + _id: PromiseOrValue, + _assets: PromiseOrValue, + _receiver: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + depositETH( + _id: PromiseOrValue, + _receiver: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue }, + ): Promise; + + depositFee(overrides?: CallOverrides): Promise; + + depositQueue(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + emissions(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + emissionsToken(overrides?: CallOverrides): Promise; + + enlistInRollover( + _epochId: PromiseOrValue, + _shares: PromiseOrValue, + _receiver: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + epochAccounting(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochConfig(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochExists(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochNull(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochResolved(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochs(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + exists(id: PromiseOrValue, overrides?: CallOverrides): Promise; + + factory(overrides?: CallOverrides): Promise; + + finalTVL(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + getAllEpochs(overrides?: CallOverrides): Promise; + + getDepositQueueLength(overrides?: CallOverrides): Promise; + + getDepositQueueTVL(overrides?: CallOverrides): Promise; + + getEpochConfig(_id: PromiseOrValue, overrides?: CallOverrides): Promise; + + getEpochDepositFee( + _id: PromiseOrValue, + _assets: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + getEpochsLength(overrides?: CallOverrides): Promise; + + getRolloverIndex(_owner: PromiseOrValue, overrides?: CallOverrides): Promise; + + getRolloverPosition(_owner: PromiseOrValue, overrides?: CallOverrides): Promise; + + getRolloverQueueItem(_index: PromiseOrValue, overrides?: CallOverrides): Promise; + + getRolloverQueueLength(overrides?: CallOverrides): Promise; + + getRolloverTVL(overrides?: CallOverrides): Promise; + + getRolloverTVLByEpochId(_epochId: PromiseOrValue, overrides?: CallOverrides): Promise; + + isApprovedForAll( + account: PromiseOrValue, + operator: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + isEnlistedInRolloverQueue(_owner: PromiseOrValue, overrides?: CallOverrides): Promise; + + isWETH(overrides?: CallOverrides): Promise; + + minQueueDeposit(overrides?: CallOverrides): Promise; + + mintDepositInQueue( + _epochId: PromiseOrValue, + _operations: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + mintRollovers( + _epochId: PromiseOrValue, + _operations: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + name(overrides?: CallOverrides): Promise; + + ownerToRollOverQueueIndex(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + previewAmountInShares( + _id: PromiseOrValue, + _assets: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + previewEmissionsWithdraw( + _id: PromiseOrValue, + _assets: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + previewWithdraw( + _id: PromiseOrValue, + _shares: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + relayerFee(overrides?: CallOverrides): Promise; + + resolveEpoch( + _id: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + rolloverAccounting(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + rolloverQueue(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + safeBatchTransferFrom( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + arg2: PromiseOrValue[], + arg3: PromiseOrValue[], + arg4: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + safeTransferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + sendTokens( + _id: PromiseOrValue, + _amount: PromiseOrValue, + _receiver: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setApprovalForAll( + operator: PromiseOrValue, + approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setClaimTVL( + _id: PromiseOrValue, + _claimTVL: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setCounterPartyVault( + _counterPartyVault: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setEmissions( + _epochId: PromiseOrValue, + _emissionAmount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setEpoch( + _epochBegin: PromiseOrValue, + _epochEnd: PromiseOrValue, + _epochId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setEpochNull( + _id: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + strike(overrides?: CallOverrides): Promise; + + supportsInterface(interfaceId: PromiseOrValue, overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + token(overrides?: CallOverrides): Promise; + + totalAssets(_id: PromiseOrValue, overrides?: CallOverrides): Promise; + + totalSupply(id: PromiseOrValue, overrides?: CallOverrides): Promise; + + treasury(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + uri(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + whiteListAddress( + _wAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + whitelistedAddresses(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + withdraw( + _id: PromiseOrValue, + _shares: PromiseOrValue, + _receiver: PromiseOrValue, + _owner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + }; + + populateTransaction: { + asset(overrides?: CallOverrides): Promise; + + balanceOf( + account: PromiseOrValue, + id: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + balanceOfBatch( + accounts: PromiseOrValue[], + ids: PromiseOrValue[], + overrides?: CallOverrides, + ): Promise; + + calculateFeePercent( + minX: PromiseOrValue, + maxX: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + changeController( + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeDepositFee( + _depositFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeRelayerFee( + _relayerFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + claimTVL(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + cleanUpRolloverQueue( + _addressesToDelist: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + controller(overrides?: CallOverrides): Promise; + + counterPartyVault(overrides?: CallOverrides): Promise; + + delistInRollover( + _owner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + deposit( + _id: PromiseOrValue, + _assets: PromiseOrValue, + _receiver: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + depositETH( + _id: PromiseOrValue, + _receiver: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue }, + ): Promise; + + depositFee(overrides?: CallOverrides): Promise; + + depositQueue(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + emissions(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + emissionsToken(overrides?: CallOverrides): Promise; + + enlistInRollover( + _epochId: PromiseOrValue, + _shares: PromiseOrValue, + _receiver: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + epochAccounting(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochConfig(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochExists(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochNull(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochResolved(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochs(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + exists(id: PromiseOrValue, overrides?: CallOverrides): Promise; + + factory(overrides?: CallOverrides): Promise; + + finalTVL(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + getAllEpochs(overrides?: CallOverrides): Promise; + + getDepositQueueLength(overrides?: CallOverrides): Promise; + + getDepositQueueTVL(overrides?: CallOverrides): Promise; + + getEpochConfig(_id: PromiseOrValue, overrides?: CallOverrides): Promise; + + getEpochDepositFee( + _id: PromiseOrValue, + _assets: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + getEpochsLength(overrides?: CallOverrides): Promise; + + getRolloverIndex(_owner: PromiseOrValue, overrides?: CallOverrides): Promise; + + getRolloverPosition(_owner: PromiseOrValue, overrides?: CallOverrides): Promise; + + getRolloverQueueItem( + _index: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + getRolloverQueueLength(overrides?: CallOverrides): Promise; + + getRolloverTVL(overrides?: CallOverrides): Promise; + + getRolloverTVLByEpochId( + _epochId: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + isApprovedForAll( + account: PromiseOrValue, + operator: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + isEnlistedInRolloverQueue(_owner: PromiseOrValue, overrides?: CallOverrides): Promise; + + isWETH(overrides?: CallOverrides): Promise; + + minQueueDeposit(overrides?: CallOverrides): Promise; + + mintDepositInQueue( + _epochId: PromiseOrValue, + _operations: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + mintRollovers( + _epochId: PromiseOrValue, + _operations: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + name(overrides?: CallOverrides): Promise; + + ownerToRollOverQueueIndex(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + previewAmountInShares( + _id: PromiseOrValue, + _assets: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + previewEmissionsWithdraw( + _id: PromiseOrValue, + _assets: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + previewWithdraw( + _id: PromiseOrValue, + _shares: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + relayerFee(overrides?: CallOverrides): Promise; + + resolveEpoch( + _id: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + rolloverAccounting(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + rolloverQueue(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + safeBatchTransferFrom( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + arg2: PromiseOrValue[], + arg3: PromiseOrValue[], + arg4: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + safeTransferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + sendTokens( + _id: PromiseOrValue, + _amount: PromiseOrValue, + _receiver: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setApprovalForAll( + operator: PromiseOrValue, + approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setClaimTVL( + _id: PromiseOrValue, + _claimTVL: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setCounterPartyVault( + _counterPartyVault: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setEmissions( + _epochId: PromiseOrValue, + _emissionAmount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setEpoch( + _epochBegin: PromiseOrValue, + _epochEnd: PromiseOrValue, + _epochId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setEpochNull( + _id: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + strike(overrides?: CallOverrides): Promise; + + supportsInterface(interfaceId: PromiseOrValue, overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + token(overrides?: CallOverrides): Promise; + + totalAssets(_id: PromiseOrValue, overrides?: CallOverrides): Promise; + + totalSupply(id: PromiseOrValue, overrides?: CallOverrides): Promise; + + treasury(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + uri(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + whiteListAddress( + _wAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + whitelistedAddresses(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + withdraw( + _id: PromiseOrValue, + _shares: PromiseOrValue, + _receiver: PromiseOrValue, + _owner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + }; +} diff --git a/src/apps/y2k-finance/contracts/ethers/Y2KFinanceCarouselFactory.ts b/src/apps/y2k-finance/contracts/ethers/Y2KFinanceCarouselFactory.ts new file mode 100644 index 000000000..42c33e2d3 --- /dev/null +++ b/src/apps/y2k-finance/contracts/ethers/Y2KFinanceCarouselFactory.ts @@ -0,0 +1,958 @@ +/* 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, PromiseOrValue } from './common'; + +export declare namespace VaultFactoryV2 { + export type MarketConfigurationCalldataStruct = { + token: PromiseOrValue; + strike: PromiseOrValue; + oracle: PromiseOrValue; + underlyingAsset: PromiseOrValue; + name: PromiseOrValue; + tokenURI: PromiseOrValue; + controller: PromiseOrValue; + }; + + export type MarketConfigurationCalldataStructOutput = [string, BigNumber, string, string, string, string, string] & { + token: string; + strike: BigNumber; + oracle: string; + underlyingAsset: string; + name: string; + tokenURI: string; + controller: string; + }; +} + +export interface Y2KFinanceCarouselFactoryInterface extends utils.Interface { + functions: { + 'WETH()': FunctionFragment; + 'changeController(uint256,address)': FunctionFragment; + 'changeOracle(uint256,address)': FunctionFragment; + 'controllers(address)': FunctionFragment; + 'createEpoch(uint256,uint40,uint40,uint16)': FunctionFragment; + 'createNewMarket((address,uint256,address,address,string,string,address))': FunctionFragment; + 'epochFee(uint256)': FunctionFragment; + 'getEpochFee(uint256)': FunctionFragment; + 'getEpochId(uint256,uint40,uint40)': FunctionFragment; + 'getEpochsByMarketId(uint256)': FunctionFragment; + 'getMarketId(address,uint256,address)': FunctionFragment; + 'getMarketInfo(uint256)': FunctionFragment; + 'getVaults(uint256)': FunctionFragment; + 'marketIdInfo(uint256)': FunctionFragment; + 'marketIdToEpochs(uint256,uint256)': FunctionFragment; + 'marketIdToVaults(uint256,uint256)': FunctionFragment; + 'marketToOracle(uint256)': FunctionFragment; + 'owner()': FunctionFragment; + 'renounceOwnership()': FunctionFragment; + 'setTreasury(address)': FunctionFragment; + 'timelocker()': FunctionFragment; + 'transferOwnership(address)': FunctionFragment; + 'treasury()': FunctionFragment; + 'whitelistAddressOnMarket(uint256,address)': FunctionFragment; + 'whitelistController(address)': FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | 'WETH' + | 'changeController' + | 'changeOracle' + | 'controllers' + | 'createEpoch' + | 'createNewMarket' + | 'epochFee' + | 'getEpochFee' + | 'getEpochId' + | 'getEpochsByMarketId' + | 'getMarketId' + | 'getMarketInfo' + | 'getVaults' + | 'marketIdInfo' + | 'marketIdToEpochs' + | 'marketIdToVaults' + | 'marketToOracle' + | 'owner' + | 'renounceOwnership' + | 'setTreasury' + | 'timelocker' + | 'transferOwnership' + | 'treasury' + | 'whitelistAddressOnMarket' + | 'whitelistController', + ): FunctionFragment; + + encodeFunctionData(functionFragment: 'WETH', values?: undefined): string; + encodeFunctionData( + functionFragment: 'changeController', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData( + functionFragment: 'changeOracle', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'controllers', values: [PromiseOrValue]): string; + encodeFunctionData( + functionFragment: 'createEpoch', + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + ], + ): string; + encodeFunctionData( + functionFragment: 'createNewMarket', + values: [VaultFactoryV2.MarketConfigurationCalldataStruct], + ): string; + encodeFunctionData(functionFragment: 'epochFee', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'getEpochFee', values: [PromiseOrValue]): string; + encodeFunctionData( + functionFragment: 'getEpochId', + values: [PromiseOrValue, PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'getEpochsByMarketId', values: [PromiseOrValue]): string; + encodeFunctionData( + functionFragment: 'getMarketId', + values: [PromiseOrValue, PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'getMarketInfo', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'getVaults', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'marketIdInfo', values: [PromiseOrValue]): string; + encodeFunctionData( + functionFragment: 'marketIdToEpochs', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData( + functionFragment: 'marketIdToVaults', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'marketToOracle', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'owner', values?: undefined): string; + encodeFunctionData(functionFragment: 'renounceOwnership', values?: undefined): string; + encodeFunctionData(functionFragment: 'setTreasury', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'timelocker', values?: undefined): string; + encodeFunctionData(functionFragment: 'transferOwnership', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'treasury', values?: undefined): string; + encodeFunctionData( + functionFragment: 'whitelistAddressOnMarket', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'whitelistController', values: [PromiseOrValue]): string; + + decodeFunctionResult(functionFragment: 'WETH', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'changeController', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'changeOracle', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'controllers', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'createEpoch', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'createNewMarket', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'epochFee', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getEpochFee', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getEpochId', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getEpochsByMarketId', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getMarketId', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getMarketInfo', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getVaults', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'marketIdInfo', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'marketIdToEpochs', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'marketIdToVaults', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'marketToOracle', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'owner', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'renounceOwnership', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'setTreasury', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'timelocker', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'transferOwnership', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'treasury', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'whitelistAddressOnMarket', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'whitelistController', data: BytesLike): Result; + + events: { + 'AddressWhitelisted(address,uint256)': EventFragment; + 'ControllerChanged(uint256,address,address,address)': EventFragment; + 'ControllerWhitelisted(address)': EventFragment; + 'EpochCreated(uint256,uint256,uint40,uint40,address,address,address,uint256,uint16)': EventFragment; + 'MarketCreated(uint256,address,address,address,address,string,uint256,address)': EventFragment; + 'OracleChanged(uint256,address)': EventFragment; + 'OwnershipTransferred(address,address)': EventFragment; + 'TreasurySet(address)': EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: 'AddressWhitelisted'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'ControllerChanged'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'ControllerWhitelisted'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'EpochCreated'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'MarketCreated'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'OracleChanged'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'OwnershipTransferred'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'TreasurySet'): EventFragment; +} + +export interface AddressWhitelistedEventObject { + _wAddress: string; + _marketId: BigNumber; +} +export type AddressWhitelistedEvent = TypedEvent<[string, BigNumber], AddressWhitelistedEventObject>; + +export type AddressWhitelistedEventFilter = TypedEventFilter; + +export interface ControllerChangedEventObject { + marketId: BigNumber; + controller: string; + premium: string; + collateral: string; +} +export type ControllerChangedEvent = TypedEvent<[BigNumber, string, string, string], ControllerChangedEventObject>; + +export type ControllerChangedEventFilter = TypedEventFilter; + +export interface ControllerWhitelistedEventObject { + _controller: string; +} +export type ControllerWhitelistedEvent = TypedEvent<[string], ControllerWhitelistedEventObject>; + +export type ControllerWhitelistedEventFilter = TypedEventFilter; + +export interface EpochCreatedEventObject { + epochId: BigNumber; + marketId: BigNumber; + startEpoch: number; + endEpoch: number; + premium: string; + collateral: string; + token: string; + strike: BigNumber; + withdrawalFee: number; +} +export type EpochCreatedEvent = TypedEvent< + [BigNumber, BigNumber, number, number, string, string, string, BigNumber, number], + EpochCreatedEventObject +>; + +export type EpochCreatedEventFilter = TypedEventFilter; + +export interface MarketCreatedEventObject { + marketId: BigNumber; + premium: string; + collateral: string; + underlyingAsset: string; + token: string; + name: string; + strike: BigNumber; + controller: string; +} +export type MarketCreatedEvent = TypedEvent< + [BigNumber, string, string, string, string, string, BigNumber, string], + MarketCreatedEventObject +>; + +export type MarketCreatedEventFilter = TypedEventFilter; + +export interface OracleChangedEventObject { + _marketId: BigNumber; + _oracle: string; +} +export type OracleChangedEvent = TypedEvent<[BigNumber, string], OracleChangedEventObject>; + +export type OracleChangedEventFilter = TypedEventFilter; + +export interface OwnershipTransferredEventObject { + previousOwner: string; + newOwner: string; +} +export type OwnershipTransferredEvent = TypedEvent<[string, string], OwnershipTransferredEventObject>; + +export type OwnershipTransferredEventFilter = TypedEventFilter; + +export interface TreasurySetEventObject { + _treasury: string; +} +export type TreasurySetEvent = TypedEvent<[string], TreasurySetEventObject>; + +export type TreasurySetEventFilter = TypedEventFilter; + +export interface Y2KFinanceCarouselFactory extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: Y2KFinanceCarouselFactoryInterface; + + 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: { + WETH(overrides?: CallOverrides): Promise<[string]>; + + changeController( + _marketId: PromiseOrValue, + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeOracle( + _marketId: PromiseOrValue, + _oracle: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + controllers(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[boolean]>; + + createEpoch( + _marketId: PromiseOrValue, + _epochBegin: PromiseOrValue, + _epochEnd: PromiseOrValue, + _withdrawalFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + createNewMarket( + _marketCalldata: VaultFactoryV2.MarketConfigurationCalldataStruct, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + epochFee(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[number]>; + + getEpochFee(epochId: PromiseOrValue, overrides?: CallOverrides): Promise<[number] & { fee: number }>; + + getEpochId( + marketId: PromiseOrValue, + epochBegin: PromiseOrValue, + epochEnd: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[BigNumber] & { epochId: BigNumber }>; + + getEpochsByMarketId(marketId: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber[]]>; + + getMarketId( + _token: PromiseOrValue, + _strikePrice: PromiseOrValue, + _underlying: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[BigNumber] & { marketId: BigNumber }>; + + getMarketInfo( + _marketId: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [string, BigNumber, string] & { + token: string; + strike: BigNumber; + underlyingAsset: string; + } + >; + + getVaults( + index: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[[string, string]] & { vaults: [string, string] }>; + + marketIdInfo( + arg0: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [string, BigNumber, string] & { + token: string; + strike: BigNumber; + underlyingAsset: string; + } + >; + + marketIdToEpochs( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[BigNumber]>; + + marketIdToVaults( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[string]>; + + marketToOracle(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[string]>; + + owner(overrides?: CallOverrides): Promise<[string]>; + + renounceOwnership(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + setTreasury( + _treasury: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + timelocker(overrides?: CallOverrides): Promise<[string]>; + + transferOwnership( + _owner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + treasury(overrides?: CallOverrides): Promise<[string]>; + + whitelistAddressOnMarket( + _marketId: PromiseOrValue, + _wAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + whitelistController( + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + }; + + WETH(overrides?: CallOverrides): Promise; + + changeController( + _marketId: PromiseOrValue, + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeOracle( + _marketId: PromiseOrValue, + _oracle: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + controllers(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + createEpoch( + _marketId: PromiseOrValue, + _epochBegin: PromiseOrValue, + _epochEnd: PromiseOrValue, + _withdrawalFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + createNewMarket( + _marketCalldata: VaultFactoryV2.MarketConfigurationCalldataStruct, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + epochFee(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + getEpochFee(epochId: PromiseOrValue, overrides?: CallOverrides): Promise; + + getEpochId( + marketId: PromiseOrValue, + epochBegin: PromiseOrValue, + epochEnd: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + getEpochsByMarketId(marketId: PromiseOrValue, overrides?: CallOverrides): Promise; + + getMarketId( + _token: PromiseOrValue, + _strikePrice: PromiseOrValue, + _underlying: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + getMarketInfo( + _marketId: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [string, BigNumber, string] & { + token: string; + strike: BigNumber; + underlyingAsset: string; + } + >; + + getVaults(index: PromiseOrValue, overrides?: CallOverrides): Promise<[string, string]>; + + marketIdInfo( + arg0: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [string, BigNumber, string] & { + token: string; + strike: BigNumber; + underlyingAsset: string; + } + >; + + marketIdToEpochs( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + marketIdToVaults( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + marketToOracle(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + setTreasury( + _treasury: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + timelocker(overrides?: CallOverrides): Promise; + + transferOwnership( + _owner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + treasury(overrides?: CallOverrides): Promise; + + whitelistAddressOnMarket( + _marketId: PromiseOrValue, + _wAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + whitelistController( + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + callStatic: { + WETH(overrides?: CallOverrides): Promise; + + changeController( + _marketId: PromiseOrValue, + _controller: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + changeOracle( + _marketId: PromiseOrValue, + _oracle: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + controllers(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + createEpoch( + _marketId: PromiseOrValue, + _epochBegin: PromiseOrValue, + _epochEnd: PromiseOrValue, + _withdrawalFee: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, [string, string]] & { + epochId: BigNumber; + vaults: [string, string]; + } + >; + + createNewMarket( + _marketCalldata: VaultFactoryV2.MarketConfigurationCalldataStruct, + overrides?: CallOverrides, + ): Promise< + [string, string, BigNumber] & { + premium: string; + collateral: string; + marketId: BigNumber; + } + >; + + epochFee(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + getEpochFee(epochId: PromiseOrValue, overrides?: CallOverrides): Promise; + + getEpochId( + marketId: PromiseOrValue, + epochBegin: PromiseOrValue, + epochEnd: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + getEpochsByMarketId(marketId: PromiseOrValue, overrides?: CallOverrides): Promise; + + getMarketId( + _token: PromiseOrValue, + _strikePrice: PromiseOrValue, + _underlying: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + getMarketInfo( + _marketId: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [string, BigNumber, string] & { + token: string; + strike: BigNumber; + underlyingAsset: string; + } + >; + + getVaults(index: PromiseOrValue, overrides?: CallOverrides): Promise<[string, string]>; + + marketIdInfo( + arg0: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [string, BigNumber, string] & { + token: string; + strike: BigNumber; + underlyingAsset: string; + } + >; + + marketIdToEpochs( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + marketIdToVaults( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + marketToOracle(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: CallOverrides): Promise; + + setTreasury(_treasury: PromiseOrValue, overrides?: CallOverrides): Promise; + + timelocker(overrides?: CallOverrides): Promise; + + transferOwnership(_owner: PromiseOrValue, overrides?: CallOverrides): Promise; + + treasury(overrides?: CallOverrides): Promise; + + whitelistAddressOnMarket( + _marketId: PromiseOrValue, + _wAddress: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + whitelistController(_controller: PromiseOrValue, overrides?: CallOverrides): Promise; + }; + + filters: { + 'AddressWhitelisted(address,uint256)'( + _wAddress?: null, + _marketId?: PromiseOrValue | null, + ): AddressWhitelistedEventFilter; + AddressWhitelisted( + _wAddress?: null, + _marketId?: PromiseOrValue | null, + ): AddressWhitelistedEventFilter; + + 'ControllerChanged(uint256,address,address,address)'( + marketId?: PromiseOrValue | null, + controller?: PromiseOrValue | null, + premium?: null, + collateral?: null, + ): ControllerChangedEventFilter; + ControllerChanged( + marketId?: PromiseOrValue | null, + controller?: PromiseOrValue | null, + premium?: null, + collateral?: null, + ): ControllerChangedEventFilter; + + 'ControllerWhitelisted(address)'(_controller?: null): ControllerWhitelistedEventFilter; + ControllerWhitelisted(_controller?: null): ControllerWhitelistedEventFilter; + + 'EpochCreated(uint256,uint256,uint40,uint40,address,address,address,uint256,uint16)'( + epochId?: PromiseOrValue | null, + marketId?: PromiseOrValue | null, + startEpoch?: null, + endEpoch?: null, + premium?: null, + collateral?: null, + token?: null, + strike?: null, + withdrawalFee?: null, + ): EpochCreatedEventFilter; + EpochCreated( + epochId?: PromiseOrValue | null, + marketId?: PromiseOrValue | null, + startEpoch?: null, + endEpoch?: null, + premium?: null, + collateral?: null, + token?: null, + strike?: null, + withdrawalFee?: null, + ): EpochCreatedEventFilter; + + 'MarketCreated(uint256,address,address,address,address,string,uint256,address)'( + marketId?: PromiseOrValue | null, + premium?: null, + collateral?: null, + underlyingAsset?: null, + token?: null, + name?: null, + strike?: null, + controller?: null, + ): MarketCreatedEventFilter; + MarketCreated( + marketId?: PromiseOrValue | null, + premium?: null, + collateral?: null, + underlyingAsset?: null, + token?: null, + name?: null, + strike?: null, + controller?: null, + ): MarketCreatedEventFilter; + + 'OracleChanged(uint256,address)'( + _marketId?: PromiseOrValue | null, + _oracle?: null, + ): OracleChangedEventFilter; + OracleChanged(_marketId?: PromiseOrValue | null, _oracle?: null): OracleChangedEventFilter; + + 'OwnershipTransferred(address,address)'( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null, + ): OwnershipTransferredEventFilter; + OwnershipTransferred( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null, + ): OwnershipTransferredEventFilter; + + 'TreasurySet(address)'(_treasury?: null): TreasurySetEventFilter; + TreasurySet(_treasury?: null): TreasurySetEventFilter; + }; + + estimateGas: { + WETH(overrides?: CallOverrides): Promise; + + changeController( + _marketId: PromiseOrValue, + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeOracle( + _marketId: PromiseOrValue, + _oracle: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + controllers(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + createEpoch( + _marketId: PromiseOrValue, + _epochBegin: PromiseOrValue, + _epochEnd: PromiseOrValue, + _withdrawalFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + createNewMarket( + _marketCalldata: VaultFactoryV2.MarketConfigurationCalldataStruct, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + epochFee(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + getEpochFee(epochId: PromiseOrValue, overrides?: CallOverrides): Promise; + + getEpochId( + marketId: PromiseOrValue, + epochBegin: PromiseOrValue, + epochEnd: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + getEpochsByMarketId(marketId: PromiseOrValue, overrides?: CallOverrides): Promise; + + getMarketId( + _token: PromiseOrValue, + _strikePrice: PromiseOrValue, + _underlying: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + getMarketInfo(_marketId: PromiseOrValue, overrides?: CallOverrides): Promise; + + getVaults(index: PromiseOrValue, overrides?: CallOverrides): Promise; + + marketIdInfo(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + marketIdToEpochs( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + marketIdToVaults( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + marketToOracle(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + setTreasury( + _treasury: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + timelocker(overrides?: CallOverrides): Promise; + + transferOwnership( + _owner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + treasury(overrides?: CallOverrides): Promise; + + whitelistAddressOnMarket( + _marketId: PromiseOrValue, + _wAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + whitelistController( + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + }; + + populateTransaction: { + WETH(overrides?: CallOverrides): Promise; + + changeController( + _marketId: PromiseOrValue, + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeOracle( + _marketId: PromiseOrValue, + _oracle: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + controllers(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + createEpoch( + _marketId: PromiseOrValue, + _epochBegin: PromiseOrValue, + _epochEnd: PromiseOrValue, + _withdrawalFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + createNewMarket( + _marketCalldata: VaultFactoryV2.MarketConfigurationCalldataStruct, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + epochFee(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + getEpochFee(epochId: PromiseOrValue, overrides?: CallOverrides): Promise; + + getEpochId( + marketId: PromiseOrValue, + epochBegin: PromiseOrValue, + epochEnd: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + getEpochsByMarketId( + marketId: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + getMarketId( + _token: PromiseOrValue, + _strikePrice: PromiseOrValue, + _underlying: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + getMarketInfo(_marketId: PromiseOrValue, overrides?: CallOverrides): Promise; + + getVaults(index: PromiseOrValue, overrides?: CallOverrides): Promise; + + marketIdInfo(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + marketIdToEpochs( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + marketIdToVaults( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + marketToOracle(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + setTreasury( + _treasury: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + timelocker(overrides?: CallOverrides): Promise; + + transferOwnership( + _owner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + treasury(overrides?: CallOverrides): Promise; + + whitelistAddressOnMarket( + _marketId: PromiseOrValue, + _wAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + whitelistController( + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + }; +} diff --git a/src/apps/y2k-finance/contracts/ethers/Y2KFinanceRewardsFactory.ts b/src/apps/y2k-finance/contracts/ethers/Y2KFinanceRewardsFactory.ts new file mode 100644 index 000000000..2d3fa8346 --- /dev/null +++ b/src/apps/y2k-finance/contracts/ethers/Y2KFinanceRewardsFactory.ts @@ -0,0 +1,232 @@ +/* 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, PromiseOrValue } from './common'; + +export interface Y2KFinanceRewardsFactoryInterface extends utils.Interface { + functions: { + 'createStakingRewards(uint256,uint256)': FunctionFragment; + 'factory()': FunctionFragment; + 'govToken()': FunctionFragment; + 'owner()': FunctionFragment; + 'renounceOwnership()': FunctionFragment; + 'transferOwnership(address)': FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | 'createStakingRewards' + | 'factory' + | 'govToken' + | 'owner' + | 'renounceOwnership' + | 'transferOwnership', + ): FunctionFragment; + + encodeFunctionData( + functionFragment: 'createStakingRewards', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'factory', values?: undefined): string; + encodeFunctionData(functionFragment: 'govToken', values?: undefined): string; + encodeFunctionData(functionFragment: 'owner', values?: undefined): string; + encodeFunctionData(functionFragment: 'renounceOwnership', values?: undefined): string; + encodeFunctionData(functionFragment: 'transferOwnership', values: [PromiseOrValue]): string; + + decodeFunctionResult(functionFragment: 'createStakingRewards', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'factory', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'govToken', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'owner', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'renounceOwnership', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'transferOwnership', data: BytesLike): Result; + + events: { + 'CreatedStakingReward(bytes32,uint256,address,address)': EventFragment; + 'OwnershipTransferred(address,address)': EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: 'CreatedStakingReward'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'OwnershipTransferred'): EventFragment; +} + +export interface CreatedStakingRewardEventObject { + marketEpochId: string; + mIndex: BigNumber; + hedgeFarm: string; + riskFarm: string; +} +export type CreatedStakingRewardEvent = TypedEvent< + [string, BigNumber, string, string], + CreatedStakingRewardEventObject +>; + +export type CreatedStakingRewardEventFilter = TypedEventFilter; + +export interface OwnershipTransferredEventObject { + previousOwner: string; + newOwner: string; +} +export type OwnershipTransferredEvent = TypedEvent<[string, string], OwnershipTransferredEventObject>; + +export type OwnershipTransferredEventFilter = TypedEventFilter; + +export interface Y2KFinanceRewardsFactory extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: Y2KFinanceRewardsFactoryInterface; + + 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: { + createStakingRewards( + _marketIndex: PromiseOrValue, + _epochEnd: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + factory(overrides?: CallOverrides): Promise<[string]>; + + govToken(overrides?: CallOverrides): Promise<[string]>; + + owner(overrides?: CallOverrides): Promise<[string]>; + + renounceOwnership(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + }; + + createStakingRewards( + _marketIndex: PromiseOrValue, + _epochEnd: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + factory(overrides?: CallOverrides): Promise; + + govToken(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + callStatic: { + createStakingRewards( + _marketIndex: PromiseOrValue, + _epochEnd: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[string, string] & { insr: string; risk: string }>; + + factory(overrides?: CallOverrides): Promise; + + govToken(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: CallOverrides): Promise; + + transferOwnership(newOwner: PromiseOrValue, overrides?: CallOverrides): Promise; + }; + + filters: { + 'CreatedStakingReward(bytes32,uint256,address,address)'( + marketEpochId?: PromiseOrValue | null, + mIndex?: PromiseOrValue | null, + hedgeFarm?: null, + riskFarm?: null, + ): CreatedStakingRewardEventFilter; + CreatedStakingReward( + marketEpochId?: PromiseOrValue | null, + mIndex?: PromiseOrValue | null, + hedgeFarm?: null, + riskFarm?: null, + ): CreatedStakingRewardEventFilter; + + 'OwnershipTransferred(address,address)'( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null, + ): OwnershipTransferredEventFilter; + OwnershipTransferred( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null, + ): OwnershipTransferredEventFilter; + }; + + estimateGas: { + createStakingRewards( + _marketIndex: PromiseOrValue, + _epochEnd: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + factory(overrides?: CallOverrides): Promise; + + govToken(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + }; + + populateTransaction: { + createStakingRewards( + _marketIndex: PromiseOrValue, + _epochEnd: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + factory(overrides?: CallOverrides): Promise; + + govToken(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + }; +} diff --git a/src/apps/y2k-finance/contracts/ethers/Y2KFinanceStakingRewards.ts b/src/apps/y2k-finance/contracts/ethers/Y2KFinanceStakingRewards.ts new file mode 100644 index 000000000..05ce5e050 --- /dev/null +++ b/src/apps/y2k-finance/contracts/ethers/Y2KFinanceStakingRewards.ts @@ -0,0 +1,874 @@ +/* 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, PromiseOrValue } from './common'; + +export interface Y2KFinanceStakingRewardsInterface extends utils.Interface { + functions: { + 'acceptOwnership()': FunctionFragment; + 'balanceOf(address)': FunctionFragment; + 'earned(address)': FunctionFragment; + 'exit()': FunctionFragment; + 'getReward()': FunctionFragment; + 'getRewardForDuration()': FunctionFragment; + 'id()': FunctionFragment; + 'lastTimeRewardApplicable()': FunctionFragment; + 'lastUpdateTime()': FunctionFragment; + 'nominateNewOwner(address)': FunctionFragment; + 'nominatedOwner()': FunctionFragment; + 'notifyRewardAmount(uint256)': FunctionFragment; + 'onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)': FunctionFragment; + 'onERC1155Received(address,address,uint256,uint256,bytes)': FunctionFragment; + 'owner()': FunctionFragment; + 'pause()': FunctionFragment; + 'paused()': FunctionFragment; + 'periodFinish()': FunctionFragment; + 'recoverERC20(address,uint256)': FunctionFragment; + 'rewardPerToken()': FunctionFragment; + 'rewardPerTokenStored()': FunctionFragment; + 'rewardRate()': FunctionFragment; + 'rewards(address)': FunctionFragment; + 'rewardsDistribution()': FunctionFragment; + 'rewardsDuration()': FunctionFragment; + 'rewardsToken()': FunctionFragment; + 'setRewardsDistribution(address)': FunctionFragment; + 'setRewardsDuration(uint256)': FunctionFragment; + 'stake(uint256)': FunctionFragment; + 'stakingToken()': FunctionFragment; + 'supportsInterface(bytes4)': FunctionFragment; + 'totalSupply()': FunctionFragment; + 'unpause()': FunctionFragment; + 'userRewardPerTokenPaid(address)': FunctionFragment; + 'withdraw(uint256)': FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | 'acceptOwnership' + | 'balanceOf' + | 'earned' + | 'exit' + | 'getReward' + | 'getRewardForDuration' + | 'id' + | 'lastTimeRewardApplicable' + | 'lastUpdateTime' + | 'nominateNewOwner' + | 'nominatedOwner' + | 'notifyRewardAmount' + | 'onERC1155BatchReceived' + | 'onERC1155Received' + | 'owner' + | 'pause' + | 'paused' + | 'periodFinish' + | 'recoverERC20' + | 'rewardPerToken' + | 'rewardPerTokenStored' + | 'rewardRate' + | 'rewards' + | 'rewardsDistribution' + | 'rewardsDuration' + | 'rewardsToken' + | 'setRewardsDistribution' + | 'setRewardsDuration' + | 'stake' + | 'stakingToken' + | 'supportsInterface' + | 'totalSupply' + | 'unpause' + | 'userRewardPerTokenPaid' + | 'withdraw', + ): FunctionFragment; + + encodeFunctionData(functionFragment: 'acceptOwnership', values?: undefined): string; + encodeFunctionData(functionFragment: 'balanceOf', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'earned', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'exit', values?: undefined): string; + encodeFunctionData(functionFragment: 'getReward', values?: undefined): string; + encodeFunctionData(functionFragment: 'getRewardForDuration', values?: undefined): string; + encodeFunctionData(functionFragment: 'id', values?: undefined): string; + encodeFunctionData(functionFragment: 'lastTimeRewardApplicable', values?: undefined): string; + encodeFunctionData(functionFragment: 'lastUpdateTime', values?: undefined): string; + encodeFunctionData(functionFragment: 'nominateNewOwner', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'nominatedOwner', values?: undefined): string; + encodeFunctionData(functionFragment: 'notifyRewardAmount', values: [PromiseOrValue]): string; + encodeFunctionData( + functionFragment: 'onERC1155BatchReceived', + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue, + ], + ): string; + encodeFunctionData( + functionFragment: 'onERC1155Received', + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + ], + ): string; + encodeFunctionData(functionFragment: 'owner', values?: undefined): string; + encodeFunctionData(functionFragment: 'pause', values?: undefined): string; + encodeFunctionData(functionFragment: 'paused', values?: undefined): string; + encodeFunctionData(functionFragment: 'periodFinish', values?: undefined): string; + encodeFunctionData( + functionFragment: 'recoverERC20', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'rewardPerToken', values?: undefined): string; + encodeFunctionData(functionFragment: 'rewardPerTokenStored', values?: undefined): string; + encodeFunctionData(functionFragment: 'rewardRate', values?: undefined): string; + encodeFunctionData(functionFragment: 'rewards', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'rewardsDistribution', values?: undefined): string; + encodeFunctionData(functionFragment: 'rewardsDuration', values?: undefined): string; + encodeFunctionData(functionFragment: 'rewardsToken', values?: undefined): string; + encodeFunctionData(functionFragment: 'setRewardsDistribution', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'setRewardsDuration', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'stake', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'stakingToken', values?: undefined): string; + encodeFunctionData(functionFragment: 'supportsInterface', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'totalSupply', values?: undefined): string; + encodeFunctionData(functionFragment: 'unpause', values?: undefined): string; + encodeFunctionData(functionFragment: 'userRewardPerTokenPaid', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'withdraw', values: [PromiseOrValue]): string; + + decodeFunctionResult(functionFragment: 'acceptOwnership', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'balanceOf', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'earned', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'exit', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getReward', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getRewardForDuration', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'id', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'lastTimeRewardApplicable', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'lastUpdateTime', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'nominateNewOwner', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'nominatedOwner', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'notifyRewardAmount', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'onERC1155BatchReceived', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'onERC1155Received', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'owner', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'pause', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'paused', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'periodFinish', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'recoverERC20', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'rewardPerToken', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'rewardPerTokenStored', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'rewardRate', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'rewards', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'rewardsDistribution', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'rewardsDuration', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'rewardsToken', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'setRewardsDistribution', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'setRewardsDuration', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'stake', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'stakingToken', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'supportsInterface', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'totalSupply', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'unpause', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'userRewardPerTokenPaid', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'withdraw', data: BytesLike): Result; + + events: { + 'OwnerChanged(address,address)': EventFragment; + 'OwnerNominated(address)': EventFragment; + 'Paused(address)': EventFragment; + 'Recovered(address,uint256)': EventFragment; + 'RewardAdded(uint256)': EventFragment; + 'RewardPaid(address,uint256)': EventFragment; + 'RewardsDurationUpdated(uint256)': EventFragment; + 'Staked(address,uint256,uint256)': EventFragment; + 'Unpaused(address)': EventFragment; + 'Withdrawn(address,uint256,uint256)': EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: 'OwnerChanged'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'OwnerNominated'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Paused'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Recovered'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'RewardAdded'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'RewardPaid'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'RewardsDurationUpdated'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Staked'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Unpaused'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Withdrawn'): EventFragment; +} + +export interface OwnerChangedEventObject { + oldOwner: string; + newOwner: string; +} +export type OwnerChangedEvent = TypedEvent<[string, string], OwnerChangedEventObject>; + +export type OwnerChangedEventFilter = TypedEventFilter; + +export interface OwnerNominatedEventObject { + newOwner: string; +} +export type OwnerNominatedEvent = TypedEvent<[string], OwnerNominatedEventObject>; + +export type OwnerNominatedEventFilter = TypedEventFilter; + +export interface PausedEventObject { + account: string; +} +export type PausedEvent = TypedEvent<[string], PausedEventObject>; + +export type PausedEventFilter = TypedEventFilter; + +export interface RecoveredEventObject { + token: string; + amount: BigNumber; +} +export type RecoveredEvent = TypedEvent<[string, BigNumber], RecoveredEventObject>; + +export type RecoveredEventFilter = TypedEventFilter; + +export interface RewardAddedEventObject { + reward: BigNumber; +} +export type RewardAddedEvent = TypedEvent<[BigNumber], RewardAddedEventObject>; + +export type RewardAddedEventFilter = TypedEventFilter; + +export interface RewardPaidEventObject { + user: string; + reward: BigNumber; +} +export type RewardPaidEvent = TypedEvent<[string, BigNumber], RewardPaidEventObject>; + +export type RewardPaidEventFilter = TypedEventFilter; + +export interface RewardsDurationUpdatedEventObject { + newDuration: BigNumber; +} +export type RewardsDurationUpdatedEvent = TypedEvent<[BigNumber], RewardsDurationUpdatedEventObject>; + +export type RewardsDurationUpdatedEventFilter = TypedEventFilter; + +export interface StakedEventObject { + user: string; + id: BigNumber; + amount: BigNumber; +} +export type StakedEvent = TypedEvent<[string, BigNumber, BigNumber], StakedEventObject>; + +export type StakedEventFilter = TypedEventFilter; + +export interface UnpausedEventObject { + account: string; +} +export type UnpausedEvent = TypedEvent<[string], UnpausedEventObject>; + +export type UnpausedEventFilter = TypedEventFilter; + +export interface WithdrawnEventObject { + user: string; + id: BigNumber; + amount: BigNumber; +} +export type WithdrawnEvent = TypedEvent<[string, BigNumber, BigNumber], WithdrawnEventObject>; + +export type WithdrawnEventFilter = TypedEventFilter; + +export interface Y2KFinanceStakingRewards extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: Y2KFinanceStakingRewardsInterface; + + 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: { + acceptOwnership(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + balanceOf(account: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; + + earned(account: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; + + exit(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + getReward(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + getRewardForDuration(overrides?: CallOverrides): Promise<[BigNumber]>; + + id(overrides?: CallOverrides): Promise<[BigNumber]>; + + lastTimeRewardApplicable(overrides?: CallOverrides): Promise<[BigNumber]>; + + lastUpdateTime(overrides?: CallOverrides): Promise<[BigNumber]>; + + nominateNewOwner( + _owner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + nominatedOwner(overrides?: CallOverrides): Promise<[string]>; + + notifyRewardAmount( + reward: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + onERC1155BatchReceived( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + arg2: PromiseOrValue[], + arg3: PromiseOrValue[], + arg4: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + onERC1155Received( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + arg2: PromiseOrValue, + arg3: PromiseOrValue, + arg4: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + owner(overrides?: CallOverrides): Promise<[string]>; + + pause(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + paused(overrides?: CallOverrides): Promise<[boolean]>; + + periodFinish(overrides?: CallOverrides): Promise<[BigNumber]>; + + recoverERC20( + tokenAddress: PromiseOrValue, + tokenAmount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + rewardPerToken(overrides?: CallOverrides): Promise<[BigNumber]>; + + rewardPerTokenStored(overrides?: CallOverrides): Promise<[BigNumber]>; + + rewardRate(overrides?: CallOverrides): Promise<[BigNumber]>; + + rewards(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; + + rewardsDistribution(overrides?: CallOverrides): Promise<[string]>; + + rewardsDuration(overrides?: CallOverrides): Promise<[BigNumber]>; + + rewardsToken(overrides?: CallOverrides): Promise<[string]>; + + setRewardsDistribution( + _rewardsDistribution: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setRewardsDuration( + _rewardsDuration: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + stake( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + stakingToken(overrides?: CallOverrides): Promise<[string]>; + + supportsInterface(interfaceId: PromiseOrValue, overrides?: CallOverrides): Promise<[boolean]>; + + totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>; + + unpause(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + userRewardPerTokenPaid(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; + + withdraw( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + }; + + acceptOwnership(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + balanceOf(account: PromiseOrValue, overrides?: CallOverrides): Promise; + + earned(account: PromiseOrValue, overrides?: CallOverrides): Promise; + + exit(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + getReward(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + getRewardForDuration(overrides?: CallOverrides): Promise; + + id(overrides?: CallOverrides): Promise; + + lastTimeRewardApplicable(overrides?: CallOverrides): Promise; + + lastUpdateTime(overrides?: CallOverrides): Promise; + + nominateNewOwner( + _owner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + nominatedOwner(overrides?: CallOverrides): Promise; + + notifyRewardAmount( + reward: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + onERC1155BatchReceived( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + arg2: PromiseOrValue[], + arg3: PromiseOrValue[], + arg4: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + onERC1155Received( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + arg2: PromiseOrValue, + arg3: PromiseOrValue, + arg4: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + pause(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + paused(overrides?: CallOverrides): Promise; + + periodFinish(overrides?: CallOverrides): Promise; + + recoverERC20( + tokenAddress: PromiseOrValue, + tokenAmount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + rewardPerToken(overrides?: CallOverrides): Promise; + + rewardPerTokenStored(overrides?: CallOverrides): Promise; + + rewardRate(overrides?: CallOverrides): Promise; + + rewards(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + rewardsDistribution(overrides?: CallOverrides): Promise; + + rewardsDuration(overrides?: CallOverrides): Promise; + + rewardsToken(overrides?: CallOverrides): Promise; + + setRewardsDistribution( + _rewardsDistribution: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setRewardsDuration( + _rewardsDuration: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + stake( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + stakingToken(overrides?: CallOverrides): Promise; + + supportsInterface(interfaceId: PromiseOrValue, overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + unpause(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + userRewardPerTokenPaid(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + withdraw( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + callStatic: { + acceptOwnership(overrides?: CallOverrides): Promise; + + balanceOf(account: PromiseOrValue, overrides?: CallOverrides): Promise; + + earned(account: PromiseOrValue, overrides?: CallOverrides): Promise; + + exit(overrides?: CallOverrides): Promise; + + getReward(overrides?: CallOverrides): Promise; + + getRewardForDuration(overrides?: CallOverrides): Promise; + + id(overrides?: CallOverrides): Promise; + + lastTimeRewardApplicable(overrides?: CallOverrides): Promise; + + lastUpdateTime(overrides?: CallOverrides): Promise; + + nominateNewOwner(_owner: PromiseOrValue, overrides?: CallOverrides): Promise; + + nominatedOwner(overrides?: CallOverrides): Promise; + + notifyRewardAmount(reward: PromiseOrValue, overrides?: CallOverrides): Promise; + + onERC1155BatchReceived( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + arg2: PromiseOrValue[], + arg3: PromiseOrValue[], + arg4: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + onERC1155Received( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + arg2: PromiseOrValue, + arg3: PromiseOrValue, + arg4: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + pause(overrides?: CallOverrides): Promise; + + paused(overrides?: CallOverrides): Promise; + + periodFinish(overrides?: CallOverrides): Promise; + + recoverERC20( + tokenAddress: PromiseOrValue, + tokenAmount: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + rewardPerToken(overrides?: CallOverrides): Promise; + + rewardPerTokenStored(overrides?: CallOverrides): Promise; + + rewardRate(overrides?: CallOverrides): Promise; + + rewards(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + rewardsDistribution(overrides?: CallOverrides): Promise; + + rewardsDuration(overrides?: CallOverrides): Promise; + + rewardsToken(overrides?: CallOverrides): Promise; + + setRewardsDistribution(_rewardsDistribution: PromiseOrValue, overrides?: CallOverrides): Promise; + + setRewardsDuration(_rewardsDuration: PromiseOrValue, overrides?: CallOverrides): Promise; + + stake(amount: PromiseOrValue, overrides?: CallOverrides): Promise; + + stakingToken(overrides?: CallOverrides): Promise; + + supportsInterface(interfaceId: PromiseOrValue, overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + unpause(overrides?: CallOverrides): Promise; + + userRewardPerTokenPaid(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + withdraw(amount: PromiseOrValue, overrides?: CallOverrides): Promise; + }; + + filters: { + 'OwnerChanged(address,address)'(oldOwner?: null, newOwner?: null): OwnerChangedEventFilter; + OwnerChanged(oldOwner?: null, newOwner?: null): OwnerChangedEventFilter; + + 'OwnerNominated(address)'(newOwner?: null): OwnerNominatedEventFilter; + OwnerNominated(newOwner?: null): OwnerNominatedEventFilter; + + 'Paused(address)'(account?: null): PausedEventFilter; + Paused(account?: null): PausedEventFilter; + + 'Recovered(address,uint256)'(token?: null, amount?: null): RecoveredEventFilter; + Recovered(token?: null, amount?: null): RecoveredEventFilter; + + 'RewardAdded(uint256)'(reward?: null): RewardAddedEventFilter; + RewardAdded(reward?: null): RewardAddedEventFilter; + + 'RewardPaid(address,uint256)'(user?: PromiseOrValue | null, reward?: null): RewardPaidEventFilter; + RewardPaid(user?: PromiseOrValue | null, reward?: null): RewardPaidEventFilter; + + 'RewardsDurationUpdated(uint256)'(newDuration?: null): RewardsDurationUpdatedEventFilter; + RewardsDurationUpdated(newDuration?: null): RewardsDurationUpdatedEventFilter; + + 'Staked(address,uint256,uint256)'( + user?: PromiseOrValue | null, + id?: null, + amount?: null, + ): StakedEventFilter; + Staked(user?: PromiseOrValue | null, id?: null, amount?: null): StakedEventFilter; + + 'Unpaused(address)'(account?: null): UnpausedEventFilter; + Unpaused(account?: null): UnpausedEventFilter; + + 'Withdrawn(address,uint256,uint256)'( + user?: PromiseOrValue | null, + id?: null, + amount?: null, + ): WithdrawnEventFilter; + Withdrawn(user?: PromiseOrValue | null, id?: null, amount?: null): WithdrawnEventFilter; + }; + + estimateGas: { + acceptOwnership(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + balanceOf(account: PromiseOrValue, overrides?: CallOverrides): Promise; + + earned(account: PromiseOrValue, overrides?: CallOverrides): Promise; + + exit(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + getReward(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + getRewardForDuration(overrides?: CallOverrides): Promise; + + id(overrides?: CallOverrides): Promise; + + lastTimeRewardApplicable(overrides?: CallOverrides): Promise; + + lastUpdateTime(overrides?: CallOverrides): Promise; + + nominateNewOwner( + _owner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + nominatedOwner(overrides?: CallOverrides): Promise; + + notifyRewardAmount( + reward: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + onERC1155BatchReceived( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + arg2: PromiseOrValue[], + arg3: PromiseOrValue[], + arg4: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + onERC1155Received( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + arg2: PromiseOrValue, + arg3: PromiseOrValue, + arg4: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + pause(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + paused(overrides?: CallOverrides): Promise; + + periodFinish(overrides?: CallOverrides): Promise; + + recoverERC20( + tokenAddress: PromiseOrValue, + tokenAmount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + rewardPerToken(overrides?: CallOverrides): Promise; + + rewardPerTokenStored(overrides?: CallOverrides): Promise; + + rewardRate(overrides?: CallOverrides): Promise; + + rewards(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + rewardsDistribution(overrides?: CallOverrides): Promise; + + rewardsDuration(overrides?: CallOverrides): Promise; + + rewardsToken(overrides?: CallOverrides): Promise; + + setRewardsDistribution( + _rewardsDistribution: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setRewardsDuration( + _rewardsDuration: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + stake( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + stakingToken(overrides?: CallOverrides): Promise; + + supportsInterface(interfaceId: PromiseOrValue, overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + unpause(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + userRewardPerTokenPaid(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + withdraw( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + }; + + populateTransaction: { + acceptOwnership(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + balanceOf(account: PromiseOrValue, overrides?: CallOverrides): Promise; + + earned(account: PromiseOrValue, overrides?: CallOverrides): Promise; + + exit(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + getReward(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + getRewardForDuration(overrides?: CallOverrides): Promise; + + id(overrides?: CallOverrides): Promise; + + lastTimeRewardApplicable(overrides?: CallOverrides): Promise; + + lastUpdateTime(overrides?: CallOverrides): Promise; + + nominateNewOwner( + _owner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + nominatedOwner(overrides?: CallOverrides): Promise; + + notifyRewardAmount( + reward: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + onERC1155BatchReceived( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + arg2: PromiseOrValue[], + arg3: PromiseOrValue[], + arg4: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + onERC1155Received( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + arg2: PromiseOrValue, + arg3: PromiseOrValue, + arg4: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + pause(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + paused(overrides?: CallOverrides): Promise; + + periodFinish(overrides?: CallOverrides): Promise; + + recoverERC20( + tokenAddress: PromiseOrValue, + tokenAmount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + rewardPerToken(overrides?: CallOverrides): Promise; + + rewardPerTokenStored(overrides?: CallOverrides): Promise; + + rewardRate(overrides?: CallOverrides): Promise; + + rewards(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + rewardsDistribution(overrides?: CallOverrides): Promise; + + rewardsDuration(overrides?: CallOverrides): Promise; + + rewardsToken(overrides?: CallOverrides): Promise; + + setRewardsDistribution( + _rewardsDistribution: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setRewardsDuration( + _rewardsDuration: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + stake( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + stakingToken(overrides?: CallOverrides): Promise; + + supportsInterface(interfaceId: PromiseOrValue, overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + unpause(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + userRewardPerTokenPaid(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + withdraw( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + }; +} diff --git a/src/apps/y2k-finance/contracts/ethers/Y2KFinanceVaultFactoryV1.ts b/src/apps/y2k-finance/contracts/ethers/Y2KFinanceVaultFactoryV1.ts new file mode 100644 index 000000000..6f3e6eb43 --- /dev/null +++ b/src/apps/y2k-finance/contracts/ethers/Y2KFinanceVaultFactoryV1.ts @@ -0,0 +1,729 @@ +/* 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, PromiseOrValue } from './common'; + +export interface Y2KFinanceVaultFactoryV1Interface extends utils.Interface { + functions: { + 'WETH()': FunctionFragment; + 'changeController(uint256,address)': FunctionFragment; + 'changeOracle(address,address)': FunctionFragment; + 'changeTreasury(address,uint256)': FunctionFragment; + 'controller()': FunctionFragment; + 'createNewMarket(uint256,address,int256,uint256,uint256,address,string)': FunctionFragment; + 'deployMoreAssets(uint256,uint256,uint256,uint256)': FunctionFragment; + 'getVaults(uint256)': FunctionFragment; + 'indexEpochs(uint256,uint256)': FunctionFragment; + 'indexVaults(uint256,uint256)': FunctionFragment; + 'marketIndex()': FunctionFragment; + 'owner()': FunctionFragment; + 'renounceOwnership()': FunctionFragment; + 'setController(address)': FunctionFragment; + 'timelocker()': FunctionFragment; + 'tokenToOracle(address)': FunctionFragment; + 'transferOwnership(address)': FunctionFragment; + 'treasury()': FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | 'WETH' + | 'changeController' + | 'changeOracle' + | 'changeTreasury' + | 'controller' + | 'createNewMarket' + | 'deployMoreAssets' + | 'getVaults' + | 'indexEpochs' + | 'indexVaults' + | 'marketIndex' + | 'owner' + | 'renounceOwnership' + | 'setController' + | 'timelocker' + | 'tokenToOracle' + | 'transferOwnership' + | 'treasury', + ): FunctionFragment; + + encodeFunctionData(functionFragment: 'WETH', values?: undefined): string; + encodeFunctionData( + functionFragment: 'changeController', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData( + functionFragment: 'changeOracle', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData( + functionFragment: 'changeTreasury', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'controller', values?: undefined): string; + encodeFunctionData( + functionFragment: 'createNewMarket', + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + ], + ): string; + encodeFunctionData( + functionFragment: 'deployMoreAssets', + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + ], + ): string; + encodeFunctionData(functionFragment: 'getVaults', values: [PromiseOrValue]): string; + encodeFunctionData( + functionFragment: 'indexEpochs', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData( + functionFragment: 'indexVaults', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'marketIndex', values?: undefined): string; + encodeFunctionData(functionFragment: 'owner', values?: undefined): string; + encodeFunctionData(functionFragment: 'renounceOwnership', values?: undefined): string; + encodeFunctionData(functionFragment: 'setController', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'timelocker', values?: undefined): string; + encodeFunctionData(functionFragment: 'tokenToOracle', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'transferOwnership', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'treasury', values?: undefined): string; + + decodeFunctionResult(functionFragment: 'WETH', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'changeController', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'changeOracle', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'changeTreasury', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'controller', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'createNewMarket', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'deployMoreAssets', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getVaults', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'indexEpochs', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'indexVaults', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'marketIndex', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'owner', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'renounceOwnership', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'setController', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'timelocker', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'tokenToOracle', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'transferOwnership', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'treasury', data: BytesLike): Result; + + events: { + 'EpochCreated(bytes32,uint256,uint256,uint256,address,address,address,string,int256,uint256)': EventFragment; + 'MarketCreated(uint256,address,address,address,string,int256)': EventFragment; + 'OwnershipTransferred(address,address)': EventFragment; + 'changedController(uint256,address)': EventFragment; + 'changedOracle(address,address)': EventFragment; + 'changedTreasury(address,uint256)': EventFragment; + 'changedVaultFee(uint256,uint256)': EventFragment; + 'controllerSet(address)': EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: 'EpochCreated'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'MarketCreated'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'OwnershipTransferred'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'changedController'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'changedOracle'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'changedTreasury'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'changedVaultFee'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'controllerSet'): EventFragment; +} + +export interface EpochCreatedEventObject { + marketEpochId: string; + mIndex: BigNumber; + startEpoch: BigNumber; + endEpoch: BigNumber; + hedge: string; + risk: string; + token: string; + name: string; + strikePrice: BigNumber; + withdrawalFee: BigNumber; +} +export type EpochCreatedEvent = TypedEvent< + [string, BigNumber, BigNumber, BigNumber, string, string, string, string, BigNumber, BigNumber], + EpochCreatedEventObject +>; + +export type EpochCreatedEventFilter = TypedEventFilter; + +export interface MarketCreatedEventObject { + mIndex: BigNumber; + hedge: string; + risk: string; + token: string; + name: string; + strikePrice: BigNumber; +} +export type MarketCreatedEvent = TypedEvent< + [BigNumber, string, string, string, string, BigNumber], + MarketCreatedEventObject +>; + +export type MarketCreatedEventFilter = TypedEventFilter; + +export interface OwnershipTransferredEventObject { + previousOwner: string; + newOwner: string; +} +export type OwnershipTransferredEvent = TypedEvent<[string, string], OwnershipTransferredEventObject>; + +export type OwnershipTransferredEventFilter = TypedEventFilter; + +export interface changedControllerEventObject { + _marketIndex: BigNumber; + controller: string; +} +export type changedControllerEvent = TypedEvent<[BigNumber, string], changedControllerEventObject>; + +export type changedControllerEventFilter = TypedEventFilter; + +export interface changedOracleEventObject { + _token: string; + _oracle: string; +} +export type changedOracleEvent = TypedEvent<[string, string], changedOracleEventObject>; + +export type changedOracleEventFilter = TypedEventFilter; + +export interface changedTreasuryEventObject { + _treasury: string; + _marketIndex: BigNumber; +} +export type changedTreasuryEvent = TypedEvent<[string, BigNumber], changedTreasuryEventObject>; + +export type changedTreasuryEventFilter = TypedEventFilter; + +export interface changedVaultFeeEventObject { + _marketIndex: BigNumber; + _feeRate: BigNumber; +} +export type changedVaultFeeEvent = TypedEvent<[BigNumber, BigNumber], changedVaultFeeEventObject>; + +export type changedVaultFeeEventFilter = TypedEventFilter; + +export interface controllerSetEventObject { + newController: string; +} +export type controllerSetEvent = TypedEvent<[string], controllerSetEventObject>; + +export type controllerSetEventFilter = TypedEventFilter; + +export interface Y2KFinanceVaultFactoryV1 extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: Y2KFinanceVaultFactoryV1Interface; + + 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: { + WETH(overrides?: CallOverrides): Promise<[string]>; + + changeController( + _marketIndex: PromiseOrValue, + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeOracle( + _token: PromiseOrValue, + _oracle: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeTreasury( + _treasury: PromiseOrValue, + _marketIndex: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + controller(overrides?: CallOverrides): Promise<[string]>; + + createNewMarket( + _withdrawalFee: PromiseOrValue, + _token: PromiseOrValue, + _strikePrice: PromiseOrValue, + epochBegin: PromiseOrValue, + epochEnd: PromiseOrValue, + _oracle: PromiseOrValue, + _name: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + deployMoreAssets( + index: PromiseOrValue, + epochBegin: PromiseOrValue, + epochEnd: PromiseOrValue, + _withdrawalFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + getVaults( + index: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[string[]] & { vaults: string[] }>; + + indexEpochs( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[BigNumber]>; + + indexVaults( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[string]>; + + marketIndex(overrides?: CallOverrides): Promise<[BigNumber]>; + + owner(overrides?: CallOverrides): Promise<[string]>; + + renounceOwnership(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + setController( + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + timelocker(overrides?: CallOverrides): Promise<[string]>; + + tokenToOracle(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[string]>; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + treasury(overrides?: CallOverrides): Promise<[string]>; + }; + + WETH(overrides?: CallOverrides): Promise; + + changeController( + _marketIndex: PromiseOrValue, + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeOracle( + _token: PromiseOrValue, + _oracle: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeTreasury( + _treasury: PromiseOrValue, + _marketIndex: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + controller(overrides?: CallOverrides): Promise; + + createNewMarket( + _withdrawalFee: PromiseOrValue, + _token: PromiseOrValue, + _strikePrice: PromiseOrValue, + epochBegin: PromiseOrValue, + epochEnd: PromiseOrValue, + _oracle: PromiseOrValue, + _name: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + deployMoreAssets( + index: PromiseOrValue, + epochBegin: PromiseOrValue, + epochEnd: PromiseOrValue, + _withdrawalFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + getVaults(index: PromiseOrValue, overrides?: CallOverrides): Promise; + + indexEpochs( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + indexVaults( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + marketIndex(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + setController( + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + timelocker(overrides?: CallOverrides): Promise; + + tokenToOracle(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + treasury(overrides?: CallOverrides): Promise; + + callStatic: { + WETH(overrides?: CallOverrides): Promise; + + changeController( + _marketIndex: PromiseOrValue, + _controller: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + changeOracle( + _token: PromiseOrValue, + _oracle: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + changeTreasury( + _treasury: PromiseOrValue, + _marketIndex: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + controller(overrides?: CallOverrides): Promise; + + createNewMarket( + _withdrawalFee: PromiseOrValue, + _token: PromiseOrValue, + _strikePrice: PromiseOrValue, + epochBegin: PromiseOrValue, + epochEnd: PromiseOrValue, + _oracle: PromiseOrValue, + _name: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[string, string] & { insr: string; rsk: string }>; + + deployMoreAssets( + index: PromiseOrValue, + epochBegin: PromiseOrValue, + epochEnd: PromiseOrValue, + _withdrawalFee: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + getVaults(index: PromiseOrValue, overrides?: CallOverrides): Promise; + + indexEpochs( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + indexVaults( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + marketIndex(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: CallOverrides): Promise; + + setController(_controller: PromiseOrValue, overrides?: CallOverrides): Promise; + + timelocker(overrides?: CallOverrides): Promise; + + tokenToOracle(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + transferOwnership(newOwner: PromiseOrValue, overrides?: CallOverrides): Promise; + + treasury(overrides?: CallOverrides): Promise; + }; + + filters: { + 'EpochCreated(bytes32,uint256,uint256,uint256,address,address,address,string,int256,uint256)'( + marketEpochId?: PromiseOrValue | null, + mIndex?: PromiseOrValue | null, + startEpoch?: null, + endEpoch?: null, + hedge?: null, + risk?: null, + token?: null, + name?: null, + strikePrice?: null, + withdrawalFee?: null, + ): EpochCreatedEventFilter; + EpochCreated( + marketEpochId?: PromiseOrValue | null, + mIndex?: PromiseOrValue | null, + startEpoch?: null, + endEpoch?: null, + hedge?: null, + risk?: null, + token?: null, + name?: null, + strikePrice?: null, + withdrawalFee?: null, + ): EpochCreatedEventFilter; + + 'MarketCreated(uint256,address,address,address,string,int256)'( + mIndex?: PromiseOrValue | null, + hedge?: null, + risk?: null, + token?: null, + name?: null, + strikePrice?: null, + ): MarketCreatedEventFilter; + MarketCreated( + mIndex?: PromiseOrValue | null, + hedge?: null, + risk?: null, + token?: null, + name?: null, + strikePrice?: null, + ): MarketCreatedEventFilter; + + 'OwnershipTransferred(address,address)'( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null, + ): OwnershipTransferredEventFilter; + OwnershipTransferred( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null, + ): OwnershipTransferredEventFilter; + + 'changedController(uint256,address)'( + _marketIndex?: PromiseOrValue | null, + controller?: PromiseOrValue | null, + ): changedControllerEventFilter; + changedController( + _marketIndex?: PromiseOrValue | null, + controller?: PromiseOrValue | null, + ): changedControllerEventFilter; + + 'changedOracle(address,address)'(_token?: PromiseOrValue | null, _oracle?: null): changedOracleEventFilter; + changedOracle(_token?: PromiseOrValue | null, _oracle?: null): changedOracleEventFilter; + + 'changedTreasury(address,uint256)'( + _treasury?: null, + _marketIndex?: PromiseOrValue | null, + ): changedTreasuryEventFilter; + changedTreasury(_treasury?: null, _marketIndex?: PromiseOrValue | null): changedTreasuryEventFilter; + + 'changedVaultFee(uint256,uint256)'( + _marketIndex?: PromiseOrValue | null, + _feeRate?: null, + ): changedVaultFeeEventFilter; + changedVaultFee(_marketIndex?: PromiseOrValue | null, _feeRate?: null): changedVaultFeeEventFilter; + + 'controllerSet(address)'(newController?: PromiseOrValue | null): controllerSetEventFilter; + controllerSet(newController?: PromiseOrValue | null): controllerSetEventFilter; + }; + + estimateGas: { + WETH(overrides?: CallOverrides): Promise; + + changeController( + _marketIndex: PromiseOrValue, + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeOracle( + _token: PromiseOrValue, + _oracle: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeTreasury( + _treasury: PromiseOrValue, + _marketIndex: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + controller(overrides?: CallOverrides): Promise; + + createNewMarket( + _withdrawalFee: PromiseOrValue, + _token: PromiseOrValue, + _strikePrice: PromiseOrValue, + epochBegin: PromiseOrValue, + epochEnd: PromiseOrValue, + _oracle: PromiseOrValue, + _name: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + deployMoreAssets( + index: PromiseOrValue, + epochBegin: PromiseOrValue, + epochEnd: PromiseOrValue, + _withdrawalFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + getVaults(index: PromiseOrValue, overrides?: CallOverrides): Promise; + + indexEpochs( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + indexVaults( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + marketIndex(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + setController( + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + timelocker(overrides?: CallOverrides): Promise; + + tokenToOracle(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + treasury(overrides?: CallOverrides): Promise; + }; + + populateTransaction: { + WETH(overrides?: CallOverrides): Promise; + + changeController( + _marketIndex: PromiseOrValue, + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeOracle( + _token: PromiseOrValue, + _oracle: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeTreasury( + _treasury: PromiseOrValue, + _marketIndex: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + controller(overrides?: CallOverrides): Promise; + + createNewMarket( + _withdrawalFee: PromiseOrValue, + _token: PromiseOrValue, + _strikePrice: PromiseOrValue, + epochBegin: PromiseOrValue, + epochEnd: PromiseOrValue, + _oracle: PromiseOrValue, + _name: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + deployMoreAssets( + index: PromiseOrValue, + epochBegin: PromiseOrValue, + epochEnd: PromiseOrValue, + _withdrawalFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + getVaults(index: PromiseOrValue, overrides?: CallOverrides): Promise; + + indexEpochs( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + indexVaults( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + marketIndex(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + setController( + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + timelocker(overrides?: CallOverrides): Promise; + + tokenToOracle(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + treasury(overrides?: CallOverrides): Promise; + }; +} diff --git a/src/apps/y2k-finance/contracts/ethers/Y2KFinanceVaultV1.ts b/src/apps/y2k-finance/contracts/ethers/Y2KFinanceVaultV1.ts new file mode 100644 index 000000000..79dec5a27 --- /dev/null +++ b/src/apps/y2k-finance/contracts/ethers/Y2KFinanceVaultV1.ts @@ -0,0 +1,1214 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + 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, PromiseOrValue } from './common'; + +export interface Y2KFinanceVaultV1Interface extends utils.Interface { + functions: { + 'asset()': FunctionFragment; + 'balanceOf(address,uint256)': FunctionFragment; + 'balanceOfBatch(address[],uint256[])': FunctionFragment; + 'calculateWithdrawalFeeValue(uint256,uint256)': FunctionFragment; + 'changeController(address)': FunctionFragment; + 'changeTreasury(address)': FunctionFragment; + 'controller()': FunctionFragment; + 'createAssets(uint256,uint256,uint256)': FunctionFragment; + 'deposit(uint256,uint256,address)': FunctionFragment; + 'depositETH(uint256,address)': FunctionFragment; + 'endEpoch(uint256)': FunctionFragment; + 'epochFee(uint256)': FunctionFragment; + 'epochNull(uint256)': FunctionFragment; + 'epochs(uint256)': FunctionFragment; + 'epochsLength()': FunctionFragment; + 'exists(uint256)': FunctionFragment; + 'factory()': FunctionFragment; + 'idClaimTVL(uint256)': FunctionFragment; + 'idEpochBegin(uint256)': FunctionFragment; + 'idEpochEnded(uint256)': FunctionFragment; + 'idExists(uint256)': FunctionFragment; + 'idFinalTVL(uint256)': FunctionFragment; + 'isApprovedForAll(address,address)': FunctionFragment; + 'name()': FunctionFragment; + 'previewWithdraw(uint256,uint256)': FunctionFragment; + 'safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)': FunctionFragment; + 'safeTransferFrom(address,address,uint256,uint256,bytes)': FunctionFragment; + 'sendTokens(uint256,address)': FunctionFragment; + 'setApprovalForAll(address,bool)': FunctionFragment; + 'setClaimTVL(uint256,uint256)': FunctionFragment; + 'setEpochNull(uint256)': FunctionFragment; + 'strikePrice()': FunctionFragment; + 'supportsInterface(bytes4)': FunctionFragment; + 'symbol()': FunctionFragment; + 'tokenInsured()': FunctionFragment; + 'totalAssets(uint256)': FunctionFragment; + 'totalSupply(uint256)': FunctionFragment; + 'treasury()': FunctionFragment; + 'uri(uint256)': FunctionFragment; + 'withdraw(uint256,uint256,address,address)': FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | 'asset' + | 'balanceOf' + | 'balanceOfBatch' + | 'calculateWithdrawalFeeValue' + | 'changeController' + | 'changeTreasury' + | 'controller' + | 'createAssets' + | 'deposit' + | 'depositETH' + | 'endEpoch' + | 'epochFee' + | 'epochNull' + | 'epochs' + | 'epochsLength' + | 'exists' + | 'factory' + | 'idClaimTVL' + | 'idEpochBegin' + | 'idEpochEnded' + | 'idExists' + | 'idFinalTVL' + | 'isApprovedForAll' + | 'name' + | 'previewWithdraw' + | 'safeBatchTransferFrom' + | 'safeTransferFrom' + | 'sendTokens' + | 'setApprovalForAll' + | 'setClaimTVL' + | 'setEpochNull' + | 'strikePrice' + | 'supportsInterface' + | 'symbol' + | 'tokenInsured' + | 'totalAssets' + | 'totalSupply' + | 'treasury' + | 'uri' + | 'withdraw', + ): FunctionFragment; + + encodeFunctionData(functionFragment: 'asset', values?: undefined): string; + encodeFunctionData( + functionFragment: 'balanceOf', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData( + functionFragment: 'balanceOfBatch', + values: [PromiseOrValue[], PromiseOrValue[]], + ): string; + encodeFunctionData( + functionFragment: 'calculateWithdrawalFeeValue', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'changeController', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'changeTreasury', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'controller', values?: undefined): string; + encodeFunctionData( + functionFragment: 'createAssets', + values: [PromiseOrValue, PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData( + functionFragment: 'deposit', + values: [PromiseOrValue, PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData( + functionFragment: 'depositETH', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'endEpoch', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'epochFee', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'epochNull', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'epochs', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'epochsLength', values?: undefined): string; + encodeFunctionData(functionFragment: 'exists', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'factory', values?: undefined): string; + encodeFunctionData(functionFragment: 'idClaimTVL', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'idEpochBegin', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'idEpochEnded', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'idExists', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'idFinalTVL', values: [PromiseOrValue]): string; + encodeFunctionData( + functionFragment: 'isApprovedForAll', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'name', values?: undefined): string; + encodeFunctionData( + functionFragment: 'previewWithdraw', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData( + functionFragment: 'safeBatchTransferFrom', + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue, + ], + ): string; + encodeFunctionData( + functionFragment: 'safeTransferFrom', + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + ], + ): string; + encodeFunctionData( + functionFragment: 'sendTokens', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData( + functionFragment: 'setApprovalForAll', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData( + functionFragment: 'setClaimTVL', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'setEpochNull', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'strikePrice', values?: undefined): string; + encodeFunctionData(functionFragment: 'supportsInterface', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'symbol', values?: undefined): string; + encodeFunctionData(functionFragment: 'tokenInsured', values?: undefined): string; + encodeFunctionData(functionFragment: 'totalAssets', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'totalSupply', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'treasury', values?: undefined): string; + encodeFunctionData(functionFragment: 'uri', values: [PromiseOrValue]): string; + encodeFunctionData( + functionFragment: 'withdraw', + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + ], + ): string; + + decodeFunctionResult(functionFragment: 'asset', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'balanceOf', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'balanceOfBatch', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'calculateWithdrawalFeeValue', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'changeController', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'changeTreasury', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'controller', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'createAssets', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'deposit', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'depositETH', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'endEpoch', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'epochFee', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'epochNull', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'epochs', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'epochsLength', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'exists', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'factory', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'idClaimTVL', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'idEpochBegin', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'idEpochEnded', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'idExists', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'idFinalTVL', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'isApprovedForAll', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'name', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'previewWithdraw', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'safeBatchTransferFrom', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'safeTransferFrom', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'sendTokens', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'setApprovalForAll', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'setClaimTVL', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'setEpochNull', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'strikePrice', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'supportsInterface', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'symbol', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'tokenInsured', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'totalAssets', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'totalSupply', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'treasury', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'uri', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'withdraw', data: BytesLike): Result; + + events: { + 'ApprovalForAll(address,address,bool)': EventFragment; + 'Deposit(address,address,uint256,uint256)': EventFragment; + 'TransferBatch(address,address,address,uint256[],uint256[])': EventFragment; + 'TransferSingle(address,address,address,uint256,uint256)': EventFragment; + 'URI(string,uint256)': EventFragment; + 'Withdraw(address,address,address,uint256,uint256,uint256)': EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: 'ApprovalForAll'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Deposit'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'TransferBatch'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'TransferSingle'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'URI'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Withdraw'): EventFragment; +} + +export interface ApprovalForAllEventObject { + account: string; + operator: string; + approved: boolean; +} +export type ApprovalForAllEvent = TypedEvent<[string, string, boolean], ApprovalForAllEventObject>; + +export type ApprovalForAllEventFilter = TypedEventFilter; + +export interface DepositEventObject { + caller: string; + owner: string; + id: BigNumber; + assets: BigNumber; +} +export type DepositEvent = TypedEvent<[string, string, BigNumber, BigNumber], DepositEventObject>; + +export type DepositEventFilter = TypedEventFilter; + +export interface TransferBatchEventObject { + operator: string; + from: string; + to: string; + ids: BigNumber[]; + values: BigNumber[]; +} +export type TransferBatchEvent = TypedEvent< + [string, string, string, BigNumber[], BigNumber[]], + TransferBatchEventObject +>; + +export type TransferBatchEventFilter = TypedEventFilter; + +export interface TransferSingleEventObject { + operator: string; + from: string; + to: string; + id: BigNumber; + value: BigNumber; +} +export type TransferSingleEvent = TypedEvent<[string, string, string, BigNumber, BigNumber], TransferSingleEventObject>; + +export type TransferSingleEventFilter = TypedEventFilter; + +export interface URIEventObject { + value: string; + id: BigNumber; +} +export type URIEvent = TypedEvent<[string, BigNumber], URIEventObject>; + +export type URIEventFilter = TypedEventFilter; + +export interface WithdrawEventObject { + caller: string; + receiver: string; + owner: string; + id: BigNumber; + assets: BigNumber; + shares: BigNumber; +} +export type WithdrawEvent = TypedEvent<[string, string, string, BigNumber, BigNumber, BigNumber], WithdrawEventObject>; + +export type WithdrawEventFilter = TypedEventFilter; + +export interface Y2KFinanceVaultV1 extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: Y2KFinanceVaultV1Interface; + + 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: { + asset(overrides?: CallOverrides): Promise<[string]>; + + balanceOf( + account: PromiseOrValue, + id: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[BigNumber]>; + + balanceOfBatch( + accounts: PromiseOrValue[], + ids: PromiseOrValue[], + overrides?: CallOverrides, + ): Promise<[BigNumber[]]>; + + calculateWithdrawalFeeValue( + amount: PromiseOrValue, + _epoch: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[BigNumber] & { feeValue: BigNumber }>; + + changeController( + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeTreasury( + _treasury: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + controller(overrides?: CallOverrides): Promise<[string]>; + + createAssets( + epochBegin: PromiseOrValue, + epochEnd: PromiseOrValue, + _withdrawalFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + deposit( + id: PromiseOrValue, + assets: PromiseOrValue, + receiver: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + depositETH( + id: PromiseOrValue, + receiver: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue }, + ): Promise; + + endEpoch( + id: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + epochFee(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; + + epochNull(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[boolean]>; + + epochs(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; + + epochsLength(overrides?: CallOverrides): Promise<[BigNumber]>; + + exists(id: PromiseOrValue, overrides?: CallOverrides): Promise<[boolean]>; + + factory(overrides?: CallOverrides): Promise<[string]>; + + idClaimTVL(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; + + idEpochBegin(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; + + idEpochEnded(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[boolean]>; + + idExists(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[boolean]>; + + idFinalTVL(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; + + isApprovedForAll( + account: PromiseOrValue, + operator: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[boolean]>; + + name(overrides?: CallOverrides): Promise<[string]>; + + previewWithdraw( + id: PromiseOrValue, + assets: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[BigNumber] & { entitledAmount: BigNumber }>; + + safeBatchTransferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + ids: PromiseOrValue[], + amounts: PromiseOrValue[], + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + safeTransferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + sendTokens( + id: PromiseOrValue, + _counterparty: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setApprovalForAll( + operator: PromiseOrValue, + approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setClaimTVL( + id: PromiseOrValue, + claimTVL: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setEpochNull( + id: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + strikePrice(overrides?: CallOverrides): Promise<[BigNumber]>; + + supportsInterface(interfaceId: PromiseOrValue, overrides?: CallOverrides): Promise<[boolean]>; + + symbol(overrides?: CallOverrides): Promise<[string]>; + + tokenInsured(overrides?: CallOverrides): Promise<[string]>; + + totalAssets(_id: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; + + totalSupply(id: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; + + treasury(overrides?: CallOverrides): Promise<[string]>; + + uri(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[string]>; + + withdraw( + id: PromiseOrValue, + assets: PromiseOrValue, + receiver: PromiseOrValue, + owner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + }; + + asset(overrides?: CallOverrides): Promise; + + balanceOf( + account: PromiseOrValue, + id: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + balanceOfBatch( + accounts: PromiseOrValue[], + ids: PromiseOrValue[], + overrides?: CallOverrides, + ): Promise; + + calculateWithdrawalFeeValue( + amount: PromiseOrValue, + _epoch: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + changeController( + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeTreasury( + _treasury: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + controller(overrides?: CallOverrides): Promise; + + createAssets( + epochBegin: PromiseOrValue, + epochEnd: PromiseOrValue, + _withdrawalFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + deposit( + id: PromiseOrValue, + assets: PromiseOrValue, + receiver: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + depositETH( + id: PromiseOrValue, + receiver: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue }, + ): Promise; + + endEpoch( + id: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + epochFee(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochNull(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochs(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochsLength(overrides?: CallOverrides): Promise; + + exists(id: PromiseOrValue, overrides?: CallOverrides): Promise; + + factory(overrides?: CallOverrides): Promise; + + idClaimTVL(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + idEpochBegin(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + idEpochEnded(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + idExists(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + idFinalTVL(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + isApprovedForAll( + account: PromiseOrValue, + operator: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + name(overrides?: CallOverrides): Promise; + + previewWithdraw( + id: PromiseOrValue, + assets: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + safeBatchTransferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + ids: PromiseOrValue[], + amounts: PromiseOrValue[], + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + safeTransferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + sendTokens( + id: PromiseOrValue, + _counterparty: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setApprovalForAll( + operator: PromiseOrValue, + approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setClaimTVL( + id: PromiseOrValue, + claimTVL: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setEpochNull( + id: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + strikePrice(overrides?: CallOverrides): Promise; + + supportsInterface(interfaceId: PromiseOrValue, overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + tokenInsured(overrides?: CallOverrides): Promise; + + totalAssets(_id: PromiseOrValue, overrides?: CallOverrides): Promise; + + totalSupply(id: PromiseOrValue, overrides?: CallOverrides): Promise; + + treasury(overrides?: CallOverrides): Promise; + + uri(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + withdraw( + id: PromiseOrValue, + assets: PromiseOrValue, + receiver: PromiseOrValue, + owner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + callStatic: { + asset(overrides?: CallOverrides): Promise; + + balanceOf( + account: PromiseOrValue, + id: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + balanceOfBatch( + accounts: PromiseOrValue[], + ids: PromiseOrValue[], + overrides?: CallOverrides, + ): Promise; + + calculateWithdrawalFeeValue( + amount: PromiseOrValue, + _epoch: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + changeController(_controller: PromiseOrValue, overrides?: CallOverrides): Promise; + + changeTreasury(_treasury: PromiseOrValue, overrides?: CallOverrides): Promise; + + controller(overrides?: CallOverrides): Promise; + + createAssets( + epochBegin: PromiseOrValue, + epochEnd: PromiseOrValue, + _withdrawalFee: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + deposit( + id: PromiseOrValue, + assets: PromiseOrValue, + receiver: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + depositETH( + id: PromiseOrValue, + receiver: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + endEpoch(id: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochFee(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochNull(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochs(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochsLength(overrides?: CallOverrides): Promise; + + exists(id: PromiseOrValue, overrides?: CallOverrides): Promise; + + factory(overrides?: CallOverrides): Promise; + + idClaimTVL(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + idEpochBegin(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + idEpochEnded(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + idExists(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + idFinalTVL(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + isApprovedForAll( + account: PromiseOrValue, + operator: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + name(overrides?: CallOverrides): Promise; + + previewWithdraw( + id: PromiseOrValue, + assets: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + safeBatchTransferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + ids: PromiseOrValue[], + amounts: PromiseOrValue[], + data: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + safeTransferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + sendTokens( + id: PromiseOrValue, + _counterparty: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + setApprovalForAll( + operator: PromiseOrValue, + approved: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + setClaimTVL( + id: PromiseOrValue, + claimTVL: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + setEpochNull(id: PromiseOrValue, overrides?: CallOverrides): Promise; + + strikePrice(overrides?: CallOverrides): Promise; + + supportsInterface(interfaceId: PromiseOrValue, overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + tokenInsured(overrides?: CallOverrides): Promise; + + totalAssets(_id: PromiseOrValue, overrides?: CallOverrides): Promise; + + totalSupply(id: PromiseOrValue, overrides?: CallOverrides): Promise; + + treasury(overrides?: CallOverrides): Promise; + + uri(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + withdraw( + id: PromiseOrValue, + assets: PromiseOrValue, + receiver: PromiseOrValue, + owner: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + }; + + filters: { + 'ApprovalForAll(address,address,bool)'( + account?: PromiseOrValue | null, + operator?: PromiseOrValue | null, + approved?: null, + ): ApprovalForAllEventFilter; + ApprovalForAll( + account?: PromiseOrValue | null, + operator?: PromiseOrValue | null, + approved?: null, + ): ApprovalForAllEventFilter; + + 'Deposit(address,address,uint256,uint256)'( + caller?: null, + owner?: PromiseOrValue | null, + id?: PromiseOrValue | null, + assets?: null, + ): DepositEventFilter; + Deposit( + caller?: null, + owner?: PromiseOrValue | null, + id?: PromiseOrValue | null, + assets?: null, + ): DepositEventFilter; + + 'TransferBatch(address,address,address,uint256[],uint256[])'( + operator?: PromiseOrValue | null, + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + ids?: null, + values?: null, + ): TransferBatchEventFilter; + TransferBatch( + operator?: PromiseOrValue | null, + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + ids?: null, + values?: null, + ): TransferBatchEventFilter; + + 'TransferSingle(address,address,address,uint256,uint256)'( + operator?: PromiseOrValue | null, + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + id?: null, + value?: null, + ): TransferSingleEventFilter; + TransferSingle( + operator?: PromiseOrValue | null, + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + id?: null, + value?: null, + ): TransferSingleEventFilter; + + 'URI(string,uint256)'(value?: null, id?: PromiseOrValue | null): URIEventFilter; + URI(value?: null, id?: PromiseOrValue | null): URIEventFilter; + + 'Withdraw(address,address,address,uint256,uint256,uint256)'( + caller?: null, + receiver?: null, + owner?: PromiseOrValue | null, + id?: PromiseOrValue | null, + assets?: null, + shares?: null, + ): WithdrawEventFilter; + Withdraw( + caller?: null, + receiver?: null, + owner?: PromiseOrValue | null, + id?: PromiseOrValue | null, + assets?: null, + shares?: null, + ): WithdrawEventFilter; + }; + + estimateGas: { + asset(overrides?: CallOverrides): Promise; + + balanceOf( + account: PromiseOrValue, + id: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + balanceOfBatch( + accounts: PromiseOrValue[], + ids: PromiseOrValue[], + overrides?: CallOverrides, + ): Promise; + + calculateWithdrawalFeeValue( + amount: PromiseOrValue, + _epoch: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + changeController( + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeTreasury( + _treasury: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + controller(overrides?: CallOverrides): Promise; + + createAssets( + epochBegin: PromiseOrValue, + epochEnd: PromiseOrValue, + _withdrawalFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + deposit( + id: PromiseOrValue, + assets: PromiseOrValue, + receiver: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + depositETH( + id: PromiseOrValue, + receiver: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue }, + ): Promise; + + endEpoch( + id: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + epochFee(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochNull(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochs(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochsLength(overrides?: CallOverrides): Promise; + + exists(id: PromiseOrValue, overrides?: CallOverrides): Promise; + + factory(overrides?: CallOverrides): Promise; + + idClaimTVL(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + idEpochBegin(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + idEpochEnded(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + idExists(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + idFinalTVL(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + isApprovedForAll( + account: PromiseOrValue, + operator: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + name(overrides?: CallOverrides): Promise; + + previewWithdraw( + id: PromiseOrValue, + assets: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + safeBatchTransferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + ids: PromiseOrValue[], + amounts: PromiseOrValue[], + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + safeTransferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + sendTokens( + id: PromiseOrValue, + _counterparty: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setApprovalForAll( + operator: PromiseOrValue, + approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setClaimTVL( + id: PromiseOrValue, + claimTVL: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setEpochNull( + id: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + strikePrice(overrides?: CallOverrides): Promise; + + supportsInterface(interfaceId: PromiseOrValue, overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + tokenInsured(overrides?: CallOverrides): Promise; + + totalAssets(_id: PromiseOrValue, overrides?: CallOverrides): Promise; + + totalSupply(id: PromiseOrValue, overrides?: CallOverrides): Promise; + + treasury(overrides?: CallOverrides): Promise; + + uri(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + withdraw( + id: PromiseOrValue, + assets: PromiseOrValue, + receiver: PromiseOrValue, + owner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + }; + + populateTransaction: { + asset(overrides?: CallOverrides): Promise; + + balanceOf( + account: PromiseOrValue, + id: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + balanceOfBatch( + accounts: PromiseOrValue[], + ids: PromiseOrValue[], + overrides?: CallOverrides, + ): Promise; + + calculateWithdrawalFeeValue( + amount: PromiseOrValue, + _epoch: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + changeController( + _controller: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeTreasury( + _treasury: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + controller(overrides?: CallOverrides): Promise; + + createAssets( + epochBegin: PromiseOrValue, + epochEnd: PromiseOrValue, + _withdrawalFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + deposit( + id: PromiseOrValue, + assets: PromiseOrValue, + receiver: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + depositETH( + id: PromiseOrValue, + receiver: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue }, + ): Promise; + + endEpoch( + id: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + epochFee(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochNull(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochs(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + epochsLength(overrides?: CallOverrides): Promise; + + exists(id: PromiseOrValue, overrides?: CallOverrides): Promise; + + factory(overrides?: CallOverrides): Promise; + + idClaimTVL(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + idEpochBegin(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + idEpochEnded(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + idExists(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + idFinalTVL(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + isApprovedForAll( + account: PromiseOrValue, + operator: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + name(overrides?: CallOverrides): Promise; + + previewWithdraw( + id: PromiseOrValue, + assets: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + safeBatchTransferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + ids: PromiseOrValue[], + amounts: PromiseOrValue[], + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + safeTransferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + sendTokens( + id: PromiseOrValue, + _counterparty: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setApprovalForAll( + operator: PromiseOrValue, + approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setClaimTVL( + id: PromiseOrValue, + claimTVL: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setEpochNull( + id: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + strikePrice(overrides?: CallOverrides): Promise; + + supportsInterface(interfaceId: PromiseOrValue, overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + tokenInsured(overrides?: CallOverrides): Promise; + + totalAssets(_id: PromiseOrValue, overrides?: CallOverrides): Promise; + + totalSupply(id: PromiseOrValue, overrides?: CallOverrides): Promise; + + treasury(overrides?: CallOverrides): Promise; + + uri(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + withdraw( + id: PromiseOrValue, + assets: PromiseOrValue, + receiver: PromiseOrValue, + owner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + }; +} diff --git a/src/apps/y2k-finance/contracts/ethers/Y2KFinanceVotingLocked.ts b/src/apps/y2k-finance/contracts/ethers/Y2KFinanceVotingLocked.ts new file mode 100644 index 000000000..85915192f --- /dev/null +++ b/src/apps/y2k-finance/contracts/ethers/Y2KFinanceVotingLocked.ts @@ -0,0 +1,1337 @@ +/* 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, PromiseOrValue } from './common'; + +export interface Y2KFinanceVotingLockedInterface extends utils.Interface { + functions: { + 'accounts(address)': FunctionFragment; + 'balanceOf(address)': FunctionFragment; + 'balanceOfInEpoch(address,uint256)': FunctionFragment; + 'changeEnforceTime(bool)': FunctionFragment; + 'changeMaxEpochs(uint256)': FunctionFragment; + 'changeRecoverWhitelist(address,bool)': FunctionFragment; + 'claimReward()': FunctionFragment; + 'currentEpoch()': FunctionFragment; + 'deposit(uint256,uint256)': FunctionFragment; + 'enforceTime()': FunctionFragment; + 'epochs(uint256)': FunctionFragment; + 'exit()': FunctionFragment; + 'getAccount(address)': FunctionFragment; + 'getCurrentEpoch()': FunctionFragment; + 'getEpoch(uint256)': FunctionFragment; + 'getEpochAccountInfo(address,uint256)': FunctionFragment; + 'getNextEpoch()': FunctionFragment; + 'lockToken()': FunctionFragment; + 'maxEpochs()': FunctionFragment; + 'minEpochs()': FunctionFragment; + 'nextUnsetEpoch()': FunctionFragment; + 'owner()': FunctionFragment; + 'pause()': FunctionFragment; + 'paused()': FunctionFragment; + 'recoverERC20(address,uint256)': FunctionFragment; + 'recoverERC721(address,uint256)': FunctionFragment; + 'renounceOwnership()': FunctionFragment; + 'rewardToken(uint256)': FunctionFragment; + 'setNextEpoch(uint256,uint256,uint256)': FunctionFragment; + 'setNextEpoch_start(uint256,uint256,uint256,uint256)': FunctionFragment; + 'totalAssets()': FunctionFragment; + 'totalLocked()': FunctionFragment; + 'transferOwnership(address)': FunctionFragment; + 'unpause()': FunctionFragment; + 'updateAccount()': FunctionFragment; + 'updateEpochs()': FunctionFragment; + 'whitelistRecoverERC20(address)': FunctionFragment; + 'withdraw(uint256)': FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | 'accounts' + | 'balanceOf' + | 'balanceOfInEpoch' + | 'changeEnforceTime' + | 'changeMaxEpochs' + | 'changeRecoverWhitelist' + | 'claimReward' + | 'currentEpoch' + | 'deposit' + | 'enforceTime' + | 'epochs' + | 'exit' + | 'getAccount' + | 'getCurrentEpoch' + | 'getEpoch' + | 'getEpochAccountInfo' + | 'getNextEpoch' + | 'lockToken' + | 'maxEpochs' + | 'minEpochs' + | 'nextUnsetEpoch' + | 'owner' + | 'pause' + | 'paused' + | 'recoverERC20' + | 'recoverERC721' + | 'renounceOwnership' + | 'rewardToken' + | 'setNextEpoch' + | 'setNextEpoch_start' + | 'totalAssets' + | 'totalLocked' + | 'transferOwnership' + | 'unpause' + | 'updateAccount' + | 'updateEpochs' + | 'whitelistRecoverERC20' + | 'withdraw', + ): FunctionFragment; + + encodeFunctionData(functionFragment: 'accounts', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'balanceOf', values: [PromiseOrValue]): string; + encodeFunctionData( + functionFragment: 'balanceOfInEpoch', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'changeEnforceTime', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'changeMaxEpochs', values: [PromiseOrValue]): string; + encodeFunctionData( + functionFragment: 'changeRecoverWhitelist', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'claimReward', values?: undefined): string; + encodeFunctionData(functionFragment: 'currentEpoch', values?: undefined): string; + encodeFunctionData( + functionFragment: 'deposit', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'enforceTime', values?: undefined): string; + encodeFunctionData(functionFragment: 'epochs', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'exit', values?: undefined): string; + encodeFunctionData(functionFragment: 'getAccount', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'getCurrentEpoch', values?: undefined): string; + encodeFunctionData(functionFragment: 'getEpoch', values: [PromiseOrValue]): string; + encodeFunctionData( + functionFragment: 'getEpochAccountInfo', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'getNextEpoch', values?: undefined): string; + encodeFunctionData(functionFragment: 'lockToken', values?: undefined): string; + encodeFunctionData(functionFragment: 'maxEpochs', values?: undefined): string; + encodeFunctionData(functionFragment: 'minEpochs', values?: undefined): string; + encodeFunctionData(functionFragment: 'nextUnsetEpoch', values?: undefined): string; + encodeFunctionData(functionFragment: 'owner', values?: undefined): string; + encodeFunctionData(functionFragment: 'pause', values?: undefined): string; + encodeFunctionData(functionFragment: 'paused', values?: undefined): string; + encodeFunctionData( + functionFragment: 'recoverERC20', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData( + functionFragment: 'recoverERC721', + values: [PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData(functionFragment: 'renounceOwnership', values?: undefined): string; + encodeFunctionData(functionFragment: 'rewardToken', values: [PromiseOrValue]): string; + encodeFunctionData( + functionFragment: 'setNextEpoch', + values: [PromiseOrValue, PromiseOrValue, PromiseOrValue], + ): string; + encodeFunctionData( + functionFragment: 'setNextEpoch_start', + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + ], + ): string; + encodeFunctionData(functionFragment: 'totalAssets', values?: undefined): string; + encodeFunctionData(functionFragment: 'totalLocked', values?: undefined): string; + encodeFunctionData(functionFragment: 'transferOwnership', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'unpause', values?: undefined): string; + encodeFunctionData(functionFragment: 'updateAccount', values?: undefined): string; + encodeFunctionData(functionFragment: 'updateEpochs', values?: undefined): string; + encodeFunctionData(functionFragment: 'whitelistRecoverERC20', values: [PromiseOrValue]): string; + encodeFunctionData(functionFragment: 'withdraw', values: [PromiseOrValue]): string; + + decodeFunctionResult(functionFragment: 'accounts', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'balanceOf', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'balanceOfInEpoch', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'changeEnforceTime', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'changeMaxEpochs', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'changeRecoverWhitelist', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'claimReward', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'currentEpoch', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'deposit', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'enforceTime', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'epochs', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'exit', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getAccount', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getCurrentEpoch', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getEpoch', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getEpochAccountInfo', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'getNextEpoch', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'lockToken', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'maxEpochs', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'minEpochs', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'nextUnsetEpoch', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'owner', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'pause', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'paused', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'recoverERC20', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'recoverERC721', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'renounceOwnership', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'rewardToken', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'setNextEpoch', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'setNextEpoch_start', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'totalAssets', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'totalLocked', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'transferOwnership', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'unpause', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'updateAccount', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'updateEpochs', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'whitelistRecoverERC20', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'withdraw', data: BytesLike): Result; + + events: { + 'ChangeERC20Whiltelist(address,bool)': EventFragment; + 'ChangeEnforceTime(uint256,bool)': EventFragment; + 'ChangeMaxLockEpochs(uint256,uint256,uint256)': EventFragment; + 'Deposit(address,uint256,uint256)': EventFragment; + 'OwnershipTransferred(address,address)': EventFragment; + 'Paused(address)': EventFragment; + 'RecoveredERC20(address,uint256)': EventFragment; + 'RecoveredERC721(address,uint256)': EventFragment; + 'Relock(address,uint256,uint256)': EventFragment; + 'RewardPaid(address,address,uint256)': EventFragment; + 'SetNextReward(uint256,uint256,uint256,uint256,uint256)': EventFragment; + 'Unpaused(address)': EventFragment; + 'UpdatedEpoch(uint256)': EventFragment; + 'Withdrawn(address,uint256)': EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: 'ChangeERC20Whiltelist'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'ChangeEnforceTime'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'ChangeMaxLockEpochs'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Deposit'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'OwnershipTransferred'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Paused'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'RecoveredERC20'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'RecoveredERC721'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Relock'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'RewardPaid'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'SetNextReward'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Unpaused'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'UpdatedEpoch'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Withdrawn'): EventFragment; +} + +export interface ChangeERC20WhiltelistEventObject { + token: string; + tokenState: boolean; +} +export type ChangeERC20WhiltelistEvent = TypedEvent<[string, boolean], ChangeERC20WhiltelistEventObject>; + +export type ChangeERC20WhiltelistEventFilter = TypedEventFilter; + +export interface ChangeEnforceTimeEventObject { + currentTime: BigNumber; + flag: boolean; +} +export type ChangeEnforceTimeEvent = TypedEvent<[BigNumber, boolean], ChangeEnforceTimeEventObject>; + +export type ChangeEnforceTimeEventFilter = TypedEventFilter; + +export interface ChangeMaxLockEpochsEventObject { + currentTime: BigNumber; + oldEpochs: BigNumber; + newEpochs: BigNumber; +} +export type ChangeMaxLockEpochsEvent = TypedEvent<[BigNumber, BigNumber, BigNumber], ChangeMaxLockEpochsEventObject>; + +export type ChangeMaxLockEpochsEventFilter = TypedEventFilter; + +export interface DepositEventObject { + user: string; + amount: BigNumber; + lockedEpochs: BigNumber; +} +export type DepositEvent = TypedEvent<[string, BigNumber, BigNumber], DepositEventObject>; + +export type DepositEventFilter = TypedEventFilter; + +export interface OwnershipTransferredEventObject { + previousOwner: string; + newOwner: string; +} +export type OwnershipTransferredEvent = TypedEvent<[string, string], OwnershipTransferredEventObject>; + +export type OwnershipTransferredEventFilter = TypedEventFilter; + +export interface PausedEventObject { + account: string; +} +export type PausedEvent = TypedEvent<[string], PausedEventObject>; + +export type PausedEventFilter = TypedEventFilter; + +export interface RecoveredERC20EventObject { + token: string; + amount: BigNumber; +} +export type RecoveredERC20Event = TypedEvent<[string, BigNumber], RecoveredERC20EventObject>; + +export type RecoveredERC20EventFilter = TypedEventFilter; + +export interface RecoveredERC721EventObject { + token: string; + tokenId: BigNumber; +} +export type RecoveredERC721Event = TypedEvent<[string, BigNumber], RecoveredERC721EventObject>; + +export type RecoveredERC721EventFilter = TypedEventFilter; + +export interface RelockEventObject { + user: string; + totalBalance: BigNumber; + lockedEpochs: BigNumber; +} +export type RelockEvent = TypedEvent<[string, BigNumber, BigNumber], RelockEventObject>; + +export type RelockEventFilter = TypedEventFilter; + +export interface RewardPaidEventObject { + user: string; + token: string; + reward: BigNumber; +} +export type RewardPaidEvent = TypedEvent<[string, string, BigNumber], RewardPaidEventObject>; + +export type RewardPaidEventFilter = TypedEventFilter; + +export interface SetNextRewardEventObject { + epochId: BigNumber; + reward1: BigNumber; + reward2: BigNumber; + start: BigNumber; + finish: BigNumber; +} +export type SetNextRewardEvent = TypedEvent< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber], + SetNextRewardEventObject +>; + +export type SetNextRewardEventFilter = TypedEventFilter; + +export interface UnpausedEventObject { + account: string; +} +export type UnpausedEvent = TypedEvent<[string], UnpausedEventObject>; + +export type UnpausedEventFilter = TypedEventFilter; + +export interface UpdatedEpochEventObject { + currentId: BigNumber; +} +export type UpdatedEpochEvent = TypedEvent<[BigNumber], UpdatedEpochEventObject>; + +export type UpdatedEpochEventFilter = TypedEventFilter; + +export interface WithdrawnEventObject { + user: string; + amount: BigNumber; +} +export type WithdrawnEvent = TypedEvent<[string, BigNumber], WithdrawnEventObject>; + +export type WithdrawnEventFilter = TypedEventFilter; + +export interface Y2KFinanceVotingLocked extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: Y2KFinanceVotingLockedInterface; + + 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: { + accounts( + arg0: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & { + balance: BigNumber; + lockEpochs: BigNumber; + lastEpochPaid: BigNumber; + rewards1: BigNumber; + rewards2: BigNumber; + } + >; + + balanceOf(owner: PromiseOrValue, overrides?: CallOverrides): Promise<[BigNumber]>; + + balanceOfInEpoch( + owner: PromiseOrValue, + epochId: PromiseOrValue, + overrides?: CallOverrides, + ): Promise<[BigNumber]>; + + changeEnforceTime( + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeMaxEpochs( + _maxEpochs: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeRecoverWhitelist( + tokenAddress: PromiseOrValue, + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + claimReward(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + currentEpoch(overrides?: CallOverrides): Promise<[BigNumber]>; + + deposit( + amount: PromiseOrValue, + lockEpochs: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + enforceTime(overrides?: CallOverrides): Promise<[boolean]>; + + epochs( + arg0: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, boolean] & { + start: BigNumber; + finish: BigNumber; + totalLocked: BigNumber; + rewards1: BigNumber; + rewards2: BigNumber; + isSet: boolean; + } + >; + + exit(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + getAccount( + owner: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & { + balance: BigNumber; + lockEpochs: BigNumber; + lastEpochPaid: BigNumber; + rewards1: BigNumber; + rewards2: BigNumber; + } + >; + + getCurrentEpoch(overrides?: CallOverrides): Promise< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, boolean] & { + start: BigNumber; + finish: BigNumber; + locked: BigNumber; + rewards1: BigNumber; + rewards2: BigNumber; + isSet: boolean; + } + >; + + getEpoch( + epochId: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, boolean] & { + start: BigNumber; + finish: BigNumber; + locked: BigNumber; + rewards1: BigNumber; + rewards2: BigNumber; + isSet: boolean; + } + >; + + getEpochAccountInfo( + owner: PromiseOrValue, + epochId: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, boolean] & { + balance: BigNumber; + start: BigNumber; + finish: BigNumber; + locked: BigNumber; + userRewards1: BigNumber; + userRewards2: BigNumber; + isSet: boolean; + } + >; + + getNextEpoch(overrides?: CallOverrides): Promise< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, boolean] & { + start: BigNumber; + finish: BigNumber; + locked: BigNumber; + rewards1: BigNumber; + rewards2: BigNumber; + isSet: boolean; + } + >; + + lockToken(overrides?: CallOverrides): Promise<[string]>; + + maxEpochs(overrides?: CallOverrides): Promise<[BigNumber]>; + + minEpochs(overrides?: CallOverrides): Promise<[BigNumber]>; + + nextUnsetEpoch(overrides?: CallOverrides): Promise<[BigNumber]>; + + owner(overrides?: CallOverrides): Promise<[string]>; + + pause(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + paused(overrides?: CallOverrides): Promise<[boolean]>; + + recoverERC20( + tokenAddress: PromiseOrValue, + tokenAmount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + recoverERC721( + tokenAddress: PromiseOrValue, + tokenId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + renounceOwnership(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + rewardToken( + arg0: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [string, BigNumber, BigNumber] & { + addr: string; + rewards: BigNumber; + rewardsPaid: BigNumber; + } + >; + + setNextEpoch( + reward1: PromiseOrValue, + reward2: PromiseOrValue, + epochDurationInDays: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setNextEpoch_start( + reward1: PromiseOrValue, + reward2: PromiseOrValue, + epochDurationInDays: PromiseOrValue, + epochStart: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + totalAssets(overrides?: CallOverrides): Promise<[BigNumber]>; + + totalLocked(overrides?: CallOverrides): Promise<[BigNumber]>; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + unpause(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + updateAccount(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + updateEpochs(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + whitelistRecoverERC20(arg0: PromiseOrValue, overrides?: CallOverrides): Promise<[boolean]>; + + withdraw( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + }; + + accounts( + arg0: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & { + balance: BigNumber; + lockEpochs: BigNumber; + lastEpochPaid: BigNumber; + rewards1: BigNumber; + rewards2: BigNumber; + } + >; + + balanceOf(owner: PromiseOrValue, overrides?: CallOverrides): Promise; + + balanceOfInEpoch( + owner: PromiseOrValue, + epochId: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + changeEnforceTime( + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeMaxEpochs( + _maxEpochs: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeRecoverWhitelist( + tokenAddress: PromiseOrValue, + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + claimReward(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + currentEpoch(overrides?: CallOverrides): Promise; + + deposit( + amount: PromiseOrValue, + lockEpochs: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + enforceTime(overrides?: CallOverrides): Promise; + + epochs( + arg0: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, boolean] & { + start: BigNumber; + finish: BigNumber; + totalLocked: BigNumber; + rewards1: BigNumber; + rewards2: BigNumber; + isSet: boolean; + } + >; + + exit(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + getAccount( + owner: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & { + balance: BigNumber; + lockEpochs: BigNumber; + lastEpochPaid: BigNumber; + rewards1: BigNumber; + rewards2: BigNumber; + } + >; + + getCurrentEpoch(overrides?: CallOverrides): Promise< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, boolean] & { + start: BigNumber; + finish: BigNumber; + locked: BigNumber; + rewards1: BigNumber; + rewards2: BigNumber; + isSet: boolean; + } + >; + + getEpoch( + epochId: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, boolean] & { + start: BigNumber; + finish: BigNumber; + locked: BigNumber; + rewards1: BigNumber; + rewards2: BigNumber; + isSet: boolean; + } + >; + + getEpochAccountInfo( + owner: PromiseOrValue, + epochId: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, boolean] & { + balance: BigNumber; + start: BigNumber; + finish: BigNumber; + locked: BigNumber; + userRewards1: BigNumber; + userRewards2: BigNumber; + isSet: boolean; + } + >; + + getNextEpoch(overrides?: CallOverrides): Promise< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, boolean] & { + start: BigNumber; + finish: BigNumber; + locked: BigNumber; + rewards1: BigNumber; + rewards2: BigNumber; + isSet: boolean; + } + >; + + lockToken(overrides?: CallOverrides): Promise; + + maxEpochs(overrides?: CallOverrides): Promise; + + minEpochs(overrides?: CallOverrides): Promise; + + nextUnsetEpoch(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + pause(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + paused(overrides?: CallOverrides): Promise; + + recoverERC20( + tokenAddress: PromiseOrValue, + tokenAmount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + recoverERC721( + tokenAddress: PromiseOrValue, + tokenId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + renounceOwnership(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + rewardToken( + arg0: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [string, BigNumber, BigNumber] & { + addr: string; + rewards: BigNumber; + rewardsPaid: BigNumber; + } + >; + + setNextEpoch( + reward1: PromiseOrValue, + reward2: PromiseOrValue, + epochDurationInDays: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setNextEpoch_start( + reward1: PromiseOrValue, + reward2: PromiseOrValue, + epochDurationInDays: PromiseOrValue, + epochStart: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + totalAssets(overrides?: CallOverrides): Promise; + + totalLocked(overrides?: CallOverrides): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + unpause(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + updateAccount(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + updateEpochs(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + whitelistRecoverERC20(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + withdraw( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + callStatic: { + accounts( + arg0: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & { + balance: BigNumber; + lockEpochs: BigNumber; + lastEpochPaid: BigNumber; + rewards1: BigNumber; + rewards2: BigNumber; + } + >; + + balanceOf(owner: PromiseOrValue, overrides?: CallOverrides): Promise; + + balanceOfInEpoch( + owner: PromiseOrValue, + epochId: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + changeEnforceTime(flag: PromiseOrValue, overrides?: CallOverrides): Promise; + + changeMaxEpochs(_maxEpochs: PromiseOrValue, overrides?: CallOverrides): Promise; + + changeRecoverWhitelist( + tokenAddress: PromiseOrValue, + flag: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + claimReward(overrides?: CallOverrides): Promise<[BigNumber, BigNumber]>; + + currentEpoch(overrides?: CallOverrides): Promise; + + deposit( + amount: PromiseOrValue, + lockEpochs: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + enforceTime(overrides?: CallOverrides): Promise; + + epochs( + arg0: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, boolean] & { + start: BigNumber; + finish: BigNumber; + totalLocked: BigNumber; + rewards1: BigNumber; + rewards2: BigNumber; + isSet: boolean; + } + >; + + exit(overrides?: CallOverrides): Promise<[BigNumber, BigNumber]>; + + getAccount( + owner: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & { + balance: BigNumber; + lockEpochs: BigNumber; + lastEpochPaid: BigNumber; + rewards1: BigNumber; + rewards2: BigNumber; + } + >; + + getCurrentEpoch(overrides?: CallOverrides): Promise< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, boolean] & { + start: BigNumber; + finish: BigNumber; + locked: BigNumber; + rewards1: BigNumber; + rewards2: BigNumber; + isSet: boolean; + } + >; + + getEpoch( + epochId: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, boolean] & { + start: BigNumber; + finish: BigNumber; + locked: BigNumber; + rewards1: BigNumber; + rewards2: BigNumber; + isSet: boolean; + } + >; + + getEpochAccountInfo( + owner: PromiseOrValue, + epochId: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, boolean] & { + balance: BigNumber; + start: BigNumber; + finish: BigNumber; + locked: BigNumber; + userRewards1: BigNumber; + userRewards2: BigNumber; + isSet: boolean; + } + >; + + getNextEpoch(overrides?: CallOverrides): Promise< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber, boolean] & { + start: BigNumber; + finish: BigNumber; + locked: BigNumber; + rewards1: BigNumber; + rewards2: BigNumber; + isSet: boolean; + } + >; + + lockToken(overrides?: CallOverrides): Promise; + + maxEpochs(overrides?: CallOverrides): Promise; + + minEpochs(overrides?: CallOverrides): Promise; + + nextUnsetEpoch(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + pause(overrides?: CallOverrides): Promise; + + paused(overrides?: CallOverrides): Promise; + + recoverERC20( + tokenAddress: PromiseOrValue, + tokenAmount: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + recoverERC721( + tokenAddress: PromiseOrValue, + tokenId: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + renounceOwnership(overrides?: CallOverrides): Promise; + + rewardToken( + arg0: PromiseOrValue, + overrides?: CallOverrides, + ): Promise< + [string, BigNumber, BigNumber] & { + addr: string; + rewards: BigNumber; + rewardsPaid: BigNumber; + } + >; + + setNextEpoch( + reward1: PromiseOrValue, + reward2: PromiseOrValue, + epochDurationInDays: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + setNextEpoch_start( + reward1: PromiseOrValue, + reward2: PromiseOrValue, + epochDurationInDays: PromiseOrValue, + epochStart: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + totalAssets(overrides?: CallOverrides): Promise; + + totalLocked(overrides?: CallOverrides): Promise; + + transferOwnership(newOwner: PromiseOrValue, overrides?: CallOverrides): Promise; + + unpause(overrides?: CallOverrides): Promise; + + updateAccount(overrides?: CallOverrides): Promise< + [BigNumber, BigNumber, BigNumber, BigNumber, BigNumber] & { + balance: BigNumber; + lockEpochs: BigNumber; + lastEpochPaid: BigNumber; + rewards1: BigNumber; + rewards2: BigNumber; + } + >; + + updateEpochs(overrides?: CallOverrides): Promise; + + whitelistRecoverERC20(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + withdraw(amount: PromiseOrValue, overrides?: CallOverrides): Promise; + }; + + filters: { + 'ChangeERC20Whiltelist(address,bool)'(token?: null, tokenState?: null): ChangeERC20WhiltelistEventFilter; + ChangeERC20Whiltelist(token?: null, tokenState?: null): ChangeERC20WhiltelistEventFilter; + + 'ChangeEnforceTime(uint256,bool)'( + currentTime?: PromiseOrValue | null, + flag?: null, + ): ChangeEnforceTimeEventFilter; + ChangeEnforceTime(currentTime?: PromiseOrValue | null, flag?: null): ChangeEnforceTimeEventFilter; + + 'ChangeMaxLockEpochs(uint256,uint256,uint256)'( + currentTime?: PromiseOrValue | null, + oldEpochs?: null, + newEpochs?: null, + ): ChangeMaxLockEpochsEventFilter; + ChangeMaxLockEpochs( + currentTime?: PromiseOrValue | null, + oldEpochs?: null, + newEpochs?: null, + ): ChangeMaxLockEpochsEventFilter; + + 'Deposit(address,uint256,uint256)'( + user?: PromiseOrValue | null, + amount?: null, + lockedEpochs?: null, + ): DepositEventFilter; + Deposit(user?: PromiseOrValue | null, amount?: null, lockedEpochs?: null): DepositEventFilter; + + 'OwnershipTransferred(address,address)'( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null, + ): OwnershipTransferredEventFilter; + OwnershipTransferred( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null, + ): OwnershipTransferredEventFilter; + + 'Paused(address)'(account?: null): PausedEventFilter; + Paused(account?: null): PausedEventFilter; + + 'RecoveredERC20(address,uint256)'(token?: null, amount?: null): RecoveredERC20EventFilter; + RecoveredERC20(token?: null, amount?: null): RecoveredERC20EventFilter; + + 'RecoveredERC721(address,uint256)'(token?: null, tokenId?: null): RecoveredERC721EventFilter; + RecoveredERC721(token?: null, tokenId?: null): RecoveredERC721EventFilter; + + 'Relock(address,uint256,uint256)'( + user?: PromiseOrValue | null, + totalBalance?: null, + lockedEpochs?: null, + ): RelockEventFilter; + Relock(user?: PromiseOrValue | null, totalBalance?: null, lockedEpochs?: null): RelockEventFilter; + + 'RewardPaid(address,address,uint256)'( + user?: PromiseOrValue | null, + token?: null, + reward?: null, + ): RewardPaidEventFilter; + RewardPaid(user?: PromiseOrValue | null, token?: null, reward?: null): RewardPaidEventFilter; + + 'SetNextReward(uint256,uint256,uint256,uint256,uint256)'( + epochId?: PromiseOrValue | null, + reward1?: null, + reward2?: null, + start?: null, + finish?: null, + ): SetNextRewardEventFilter; + SetNextReward( + epochId?: PromiseOrValue | null, + reward1?: null, + reward2?: null, + start?: null, + finish?: null, + ): SetNextRewardEventFilter; + + 'Unpaused(address)'(account?: null): UnpausedEventFilter; + Unpaused(account?: null): UnpausedEventFilter; + + 'UpdatedEpoch(uint256)'(currentId?: null): UpdatedEpochEventFilter; + UpdatedEpoch(currentId?: null): UpdatedEpochEventFilter; + + 'Withdrawn(address,uint256)'(user?: PromiseOrValue | null, amount?: null): WithdrawnEventFilter; + Withdrawn(user?: PromiseOrValue | null, amount?: null): WithdrawnEventFilter; + }; + + estimateGas: { + accounts(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + balanceOf(owner: PromiseOrValue, overrides?: CallOverrides): Promise; + + balanceOfInEpoch( + owner: PromiseOrValue, + epochId: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + changeEnforceTime( + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeMaxEpochs( + _maxEpochs: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeRecoverWhitelist( + tokenAddress: PromiseOrValue, + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + claimReward(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + currentEpoch(overrides?: CallOverrides): Promise; + + deposit( + amount: PromiseOrValue, + lockEpochs: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + enforceTime(overrides?: CallOverrides): Promise; + + epochs(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + exit(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + getAccount(owner: PromiseOrValue, overrides?: CallOverrides): Promise; + + getCurrentEpoch(overrides?: CallOverrides): Promise; + + getEpoch(epochId: PromiseOrValue, overrides?: CallOverrides): Promise; + + getEpochAccountInfo( + owner: PromiseOrValue, + epochId: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + getNextEpoch(overrides?: CallOverrides): Promise; + + lockToken(overrides?: CallOverrides): Promise; + + maxEpochs(overrides?: CallOverrides): Promise; + + minEpochs(overrides?: CallOverrides): Promise; + + nextUnsetEpoch(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + pause(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + paused(overrides?: CallOverrides): Promise; + + recoverERC20( + tokenAddress: PromiseOrValue, + tokenAmount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + recoverERC721( + tokenAddress: PromiseOrValue, + tokenId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + renounceOwnership(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + rewardToken(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + setNextEpoch( + reward1: PromiseOrValue, + reward2: PromiseOrValue, + epochDurationInDays: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setNextEpoch_start( + reward1: PromiseOrValue, + reward2: PromiseOrValue, + epochDurationInDays: PromiseOrValue, + epochStart: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + totalAssets(overrides?: CallOverrides): Promise; + + totalLocked(overrides?: CallOverrides): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + unpause(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + updateAccount(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + updateEpochs(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + whitelistRecoverERC20(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + withdraw( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + }; + + populateTransaction: { + accounts(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + balanceOf(owner: PromiseOrValue, overrides?: CallOverrides): Promise; + + balanceOfInEpoch( + owner: PromiseOrValue, + epochId: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + changeEnforceTime( + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeMaxEpochs( + _maxEpochs: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + changeRecoverWhitelist( + tokenAddress: PromiseOrValue, + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + claimReward(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + currentEpoch(overrides?: CallOverrides): Promise; + + deposit( + amount: PromiseOrValue, + lockEpochs: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + enforceTime(overrides?: CallOverrides): Promise; + + epochs(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + exit(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + getAccount(owner: PromiseOrValue, overrides?: CallOverrides): Promise; + + getCurrentEpoch(overrides?: CallOverrides): Promise; + + getEpoch(epochId: PromiseOrValue, overrides?: CallOverrides): Promise; + + getEpochAccountInfo( + owner: PromiseOrValue, + epochId: PromiseOrValue, + overrides?: CallOverrides, + ): Promise; + + getNextEpoch(overrides?: CallOverrides): Promise; + + lockToken(overrides?: CallOverrides): Promise; + + maxEpochs(overrides?: CallOverrides): Promise; + + minEpochs(overrides?: CallOverrides): Promise; + + nextUnsetEpoch(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + pause(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + paused(overrides?: CallOverrides): Promise; + + recoverERC20( + tokenAddress: PromiseOrValue, + tokenAmount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + recoverERC721( + tokenAddress: PromiseOrValue, + tokenId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + renounceOwnership(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + rewardToken(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + setNextEpoch( + reward1: PromiseOrValue, + reward2: PromiseOrValue, + epochDurationInDays: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + setNextEpoch_start( + reward1: PromiseOrValue, + reward2: PromiseOrValue, + epochDurationInDays: PromiseOrValue, + epochStart: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + totalAssets(overrides?: CallOverrides): Promise; + + totalLocked(overrides?: CallOverrides): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + + unpause(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + updateAccount(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + updateEpochs(overrides?: Overrides & { from?: PromiseOrValue }): Promise; + + whitelistRecoverERC20(arg0: PromiseOrValue, overrides?: CallOverrides): Promise; + + withdraw( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue }, + ): Promise; + }; +} diff --git a/src/apps/y2k-finance/contracts/ethers/common.ts b/src/apps/y2k-finance/contracts/ethers/common.ts new file mode 100644 index 000000000..35f31be99 --- /dev/null +++ b/src/apps/y2k-finance/contracts/ethers/common.ts @@ -0,0 +1,32 @@ +/* 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; + +export type PromiseOrValue = T | Promise; diff --git a/src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceCarouselFactory__factory.ts b/src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceCarouselFactory__factory.ts new file mode 100644 index 000000000..447153e7d --- /dev/null +++ b/src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceCarouselFactory__factory.ts @@ -0,0 +1,847 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from 'ethers'; +import type { Provider } from '@ethersproject/providers'; +import type { Y2KFinanceCarouselFactory, Y2KFinanceCarouselFactoryInterface } from '../Y2KFinanceCarouselFactory'; + +const _abi = [ + { + inputs: [ + { + internalType: 'address', + name: '_weth', + type: 'address', + }, + { + internalType: 'address', + name: '_treasury', + type: 'address', + }, + { + internalType: 'address', + name: '_timelocker', + type: 'address', + }, + ], + stateMutability: 'nonpayable', + type: 'constructor', + }, + { + inputs: [], + name: 'AddressZero', + type: 'error', + }, + { + inputs: [], + name: 'ControllerNotSet', + type: 'error', + }, + { + inputs: [], + name: 'FeeCannotBe0', + type: 'error', + }, + { + inputs: [], + name: 'MarketAlreadyExists', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'marketId', + type: 'uint256', + }, + ], + name: 'MarketDoesNotExist', + type: 'error', + }, + { + inputs: [], + name: 'NotAuthorized', + type: 'error', + }, + { + inputs: [], + name: 'NotTimeLocker', + type: 'error', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: '_wAddress', + type: 'address', + }, + { + indexed: true, + internalType: 'uint256', + name: '_marketId', + type: 'uint256', + }, + ], + name: 'AddressWhitelisted', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'uint256', + name: 'marketId', + type: 'uint256', + }, + { + indexed: true, + internalType: 'address', + name: 'controller', + type: 'address', + }, + { + indexed: false, + internalType: 'address', + name: 'premium', + type: 'address', + }, + { + indexed: false, + internalType: 'address', + name: 'collateral', + type: 'address', + }, + ], + name: 'ControllerChanged', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: '_controller', + type: 'address', + }, + ], + name: 'ControllerWhitelisted', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'uint256', + name: 'epochId', + type: 'uint256', + }, + { + indexed: true, + internalType: 'uint256', + name: 'marketId', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint40', + name: 'startEpoch', + type: 'uint40', + }, + { + indexed: false, + internalType: 'uint40', + name: 'endEpoch', + type: 'uint40', + }, + { + indexed: false, + internalType: 'address', + name: 'premium', + type: 'address', + }, + { + indexed: false, + internalType: 'address', + name: 'collateral', + type: 'address', + }, + { + indexed: false, + internalType: 'address', + name: 'token', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: 'strike', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint16', + name: 'withdrawalFee', + type: 'uint16', + }, + ], + name: 'EpochCreated', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'uint256', + name: 'marketId', + type: 'uint256', + }, + { + indexed: false, + internalType: 'address', + name: 'premium', + type: 'address', + }, + { + indexed: false, + internalType: 'address', + name: 'collateral', + type: 'address', + }, + { + indexed: false, + internalType: 'address', + name: 'underlyingAsset', + type: 'address', + }, + { + indexed: false, + internalType: 'address', + name: 'token', + type: 'address', + }, + { + indexed: false, + internalType: 'string', + name: 'name', + type: 'string', + }, + { + indexed: false, + internalType: 'uint256', + name: 'strike', + type: 'uint256', + }, + { + indexed: false, + internalType: 'address', + name: 'controller', + type: 'address', + }, + ], + name: 'MarketCreated', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'uint256', + name: '_marketId', + type: 'uint256', + }, + { + indexed: false, + internalType: 'address', + name: '_oracle', + type: 'address', + }, + ], + name: 'OracleChanged', + 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: false, + internalType: 'address', + name: '_treasury', + type: 'address', + }, + ], + name: 'TreasurySet', + type: 'event', + }, + { + inputs: [], + name: 'WETH', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_marketId', + type: 'uint256', + }, + { + internalType: 'address', + name: '_controller', + type: 'address', + }, + ], + name: 'changeController', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_marketId', + type: 'uint256', + }, + { + internalType: 'address', + name: '_oracle', + type: 'address', + }, + ], + name: 'changeOracle', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + name: 'controllers', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_marketId', + type: 'uint256', + }, + { + internalType: 'uint40', + name: '_epochBegin', + type: 'uint40', + }, + { + internalType: 'uint40', + name: '_epochEnd', + type: 'uint40', + }, + { + internalType: 'uint16', + name: '_withdrawalFee', + type: 'uint16', + }, + ], + name: 'createEpoch', + outputs: [ + { + internalType: 'uint256', + name: 'epochId', + type: 'uint256', + }, + { + internalType: 'address[2]', + name: 'vaults', + type: 'address[2]', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + components: [ + { + internalType: 'address', + name: 'token', + type: 'address', + }, + { + internalType: 'uint256', + name: 'strike', + type: 'uint256', + }, + { + internalType: 'address', + name: 'oracle', + type: 'address', + }, + { + internalType: 'address', + name: 'underlyingAsset', + type: 'address', + }, + { + internalType: 'string', + name: 'name', + type: 'string', + }, + { + internalType: 'string', + name: 'tokenURI', + type: 'string', + }, + { + internalType: 'address', + name: 'controller', + type: 'address', + }, + ], + internalType: 'struct VaultFactoryV2.MarketConfigurationCalldata', + name: '_marketCalldata', + type: 'tuple', + }, + ], + name: 'createNewMarket', + outputs: [ + { + internalType: 'address', + name: 'premium', + type: 'address', + }, + { + internalType: 'address', + name: 'collateral', + type: 'address', + }, + { + internalType: 'uint256', + name: 'marketId', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'epochFee', + outputs: [ + { + internalType: 'uint16', + name: '', + type: 'uint16', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'epochId', + type: 'uint256', + }, + ], + name: 'getEpochFee', + outputs: [ + { + internalType: 'uint16', + name: 'fee', + type: 'uint16', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'marketId', + type: 'uint256', + }, + { + internalType: 'uint40', + name: 'epochBegin', + type: 'uint40', + }, + { + internalType: 'uint40', + name: 'epochEnd', + type: 'uint40', + }, + ], + name: 'getEpochId', + outputs: [ + { + internalType: 'uint256', + name: 'epochId', + type: 'uint256', + }, + ], + stateMutability: 'pure', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'marketId', + type: 'uint256', + }, + ], + name: 'getEpochsByMarketId', + outputs: [ + { + internalType: 'uint256[]', + name: '', + type: 'uint256[]', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_token', + type: 'address', + }, + { + internalType: 'uint256', + name: '_strikePrice', + type: 'uint256', + }, + { + internalType: 'address', + name: '_underlying', + type: 'address', + }, + ], + name: 'getMarketId', + outputs: [ + { + internalType: 'uint256', + name: 'marketId', + type: 'uint256', + }, + ], + stateMutability: 'pure', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_marketId', + type: 'uint256', + }, + ], + name: 'getMarketInfo', + outputs: [ + { + internalType: 'address', + name: 'token', + type: 'address', + }, + { + internalType: 'uint256', + name: 'strike', + type: 'uint256', + }, + { + internalType: 'address', + name: 'underlyingAsset', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'index', + type: 'uint256', + }, + ], + name: 'getVaults', + outputs: [ + { + internalType: 'address[2]', + name: 'vaults', + type: 'address[2]', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'marketIdInfo', + outputs: [ + { + internalType: 'address', + name: 'token', + type: 'address', + }, + { + internalType: 'uint256', + name: 'strike', + type: 'uint256', + }, + { + internalType: 'address', + name: 'underlyingAsset', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'marketIdToEpochs', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'marketIdToVaults', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'marketToOracle', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'owner', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'renounceOwnership', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_treasury', + type: 'address', + }, + ], + name: 'setTreasury', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'timelocker', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_owner', + type: 'address', + }, + ], + name: 'transferOwnership', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'treasury', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_marketId', + type: 'uint256', + }, + { + internalType: 'address', + name: '_wAddress', + type: 'address', + }, + ], + name: 'whitelistAddressOnMarket', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_controller', + type: 'address', + }, + ], + name: 'whitelistController', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, +]; + +export class Y2KFinanceCarouselFactory__factory { + static readonly abi = _abi; + static createInterface(): Y2KFinanceCarouselFactoryInterface { + return new utils.Interface(_abi) as Y2KFinanceCarouselFactoryInterface; + } + static connect(address: string, signerOrProvider: Signer | Provider): Y2KFinanceCarouselFactory { + return new Contract(address, _abi, signerOrProvider) as Y2KFinanceCarouselFactory; + } +} diff --git a/src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceCarousel__factory.ts b/src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceCarousel__factory.ts new file mode 100644 index 000000000..b231dd2b5 --- /dev/null +++ b/src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceCarousel__factory.ts @@ -0,0 +1,1967 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from 'ethers'; +import type { Provider } from '@ethersproject/providers'; +import type { Y2KFinanceCarousel, Y2KFinanceCarouselInterface, Carousel } from '../Y2KFinanceCarousel'; + +const _abi = [ + { + inputs: [ + { + components: [ + { + internalType: 'bool', + name: 'isWETH', + type: 'bool', + }, + { + internalType: 'address', + name: 'assetAddress', + type: 'address', + }, + { + internalType: 'string', + name: 'name', + type: 'string', + }, + { + internalType: 'string', + name: 'symbol', + type: 'string', + }, + { + internalType: 'string', + name: 'tokenURI', + type: 'string', + }, + { + internalType: 'address', + name: 'token', + type: 'address', + }, + { + internalType: 'uint256', + name: 'strike', + type: 'uint256', + }, + { + internalType: 'address', + name: 'controller', + type: 'address', + }, + { + internalType: 'address', + name: 'emissionsToken', + type: 'address', + }, + { + internalType: 'uint256', + name: 'relayerFee', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'depositFee', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'minQueueDeposit', + type: 'uint256', + }, + ], + internalType: 'struct Carousel.ConstructorArgs', + name: '_data', + type: 'tuple', + }, + ], + stateMutability: 'nonpayable', + type: 'constructor', + }, + { + inputs: [ + { + internalType: 'address', + name: '_contract', + type: 'address', + }, + ], + name: 'AddressNotController', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: '_contract', + type: 'address', + }, + ], + name: 'AddressNotFactory', + type: 'error', + }, + { + inputs: [], + name: 'AddressZero', + type: 'error', + }, + { + inputs: [], + name: 'AlreadyInitialized', + type: 'error', + }, + { + inputs: [], + name: 'AlreadyRollingOver', + type: 'error', + }, + { + inputs: [], + name: 'AmountExceedsTVL', + type: 'error', + }, + { + inputs: [], + name: 'BPSToHigh', + type: 'error', + }, + { + inputs: [], + name: 'CanNotDepositETH', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: '_counterparty', + type: 'address', + }, + ], + name: 'DestinationNotAuthorized', + type: 'error', + }, + { + inputs: [], + name: 'EpochAlreadyEnded', + type: 'error', + }, + { + inputs: [], + name: 'EpochAlreadyExists', + type: 'error', + }, + { + inputs: [], + name: 'EpochAlreadyStarted', + type: 'error', + }, + { + inputs: [], + name: 'EpochDoesNotExist', + type: 'error', + }, + { + inputs: [], + name: 'EpochEndMustBeAfterBegin', + type: 'error', + }, + { + inputs: [], + name: 'EpochNotResolved', + type: 'error', + }, + { + inputs: [], + name: 'EpochNotStarted', + type: 'error', + }, + { + inputs: [], + name: 'InsufficientBalance', + type: 'error', + }, + { + inputs: [], + name: 'InvalidEpoch', + type: 'error', + }, + { + inputs: [], + name: 'InvalidEpochId', + type: 'error', + }, + { + inputs: [], + name: 'MinDeposit', + type: 'error', + }, + { + inputs: [], + name: 'NoRolloverQueued', + type: 'error', + }, + { + inputs: [], + name: 'OverflowQueue', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: '_sender', + type: 'address', + }, + { + internalType: 'address', + name: '_owner', + type: 'address', + }, + ], + name: 'OwnerDidNotAuthorize', + type: 'error', + }, + { + inputs: [], + name: 'RelayerFeeToLow', + type: 'error', + }, + { + inputs: [], + name: 'ZeroValue', + type: 'error', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'account', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'operator', + type: 'address', + }, + { + indexed: false, + internalType: 'bool', + name: 'approved', + type: 'bool', + }, + ], + name: 'ApprovalForAll', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: 'caller', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'owner', + type: 'address', + }, + { + indexed: true, + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'assets', + type: 'uint256', + }, + ], + name: 'Deposit', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'sender', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'receiver', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: 'epochId', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'assets', + type: 'uint256', + }, + ], + name: 'DepositInQueue', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint256', + name: 'epochId', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'operations', + type: 'uint256', + }, + ], + name: 'RelayerMinted', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'sender', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: 'assets', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'epochId', + type: 'uint256', + }, + ], + name: 'RolloverQueued', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'operator', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'from', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'to', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256[]', + name: 'ids', + type: 'uint256[]', + }, + { + indexed: false, + internalType: 'uint256[]', + name: 'values', + type: 'uint256[]', + }, + ], + name: 'TransferBatch', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'operator', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'from', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'to', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'value', + type: 'uint256', + }, + ], + name: 'TransferSingle', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'string', + name: 'value', + type: 'string', + }, + { + indexed: true, + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + ], + name: 'URI', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: 'caller', + type: 'address', + }, + { + indexed: false, + internalType: 'address', + name: 'receiver', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'owner', + type: 'address', + }, + { + indexed: true, + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'assets', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'shares', + type: 'uint256', + }, + ], + name: 'Withdraw', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: 'caller', + type: 'address', + }, + { + indexed: false, + internalType: 'address', + name: 'receiver', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'owner', + type: 'address', + }, + { + indexed: true, + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'assets', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'shares', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'emissions', + type: 'uint256', + }, + ], + name: 'WithdrawWithEmissions', + type: 'event', + }, + { + inputs: [], + name: 'asset', + outputs: [ + { + internalType: 'contract IERC20', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'account', + type: 'address', + }, + { + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + ], + name: 'balanceOf', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address[]', + name: 'accounts', + type: 'address[]', + }, + { + internalType: 'uint256[]', + name: 'ids', + type: 'uint256[]', + }, + ], + name: 'balanceOfBatch', + outputs: [ + { + internalType: 'uint256[]', + name: '', + type: 'uint256[]', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'int256', + name: 'minX', + type: 'int256', + }, + { + internalType: 'int256', + name: 'maxX', + type: 'int256', + }, + ], + name: 'calculateFeePercent', + outputs: [ + { + internalType: 'uint256', + name: '_y', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_controller', + type: 'address', + }, + ], + name: 'changeController', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_depositFee', + type: 'uint256', + }, + ], + name: 'changeDepositFee', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_relayerFee', + type: 'uint256', + }, + ], + name: 'changeRelayerFee', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'claimTVL', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address[]', + name: '_addressesToDelist', + type: 'address[]', + }, + ], + name: 'cleanUpRolloverQueue', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'controller', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'counterPartyVault', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_owner', + type: 'address', + }, + ], + name: 'delistInRollover', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_id', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_assets', + type: 'uint256', + }, + { + internalType: 'address', + name: '_receiver', + type: 'address', + }, + ], + name: 'deposit', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_id', + type: 'uint256', + }, + { + internalType: 'address', + name: '_receiver', + type: 'address', + }, + ], + name: 'depositETH', + outputs: [], + stateMutability: 'payable', + type: 'function', + }, + { + inputs: [], + name: 'depositFee', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'depositQueue', + outputs: [ + { + internalType: 'uint256', + name: 'shares', + type: 'uint256', + }, + { + internalType: 'address', + name: 'receiver', + type: 'address', + }, + { + internalType: 'uint256', + name: 'epochId', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'emissions', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'emissionsToken', + outputs: [ + { + internalType: 'contract IERC20', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_epochId', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_shares', + type: 'uint256', + }, + { + internalType: 'address', + name: '_receiver', + type: 'address', + }, + ], + name: 'enlistInRollover', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'epochAccounting', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'epochConfig', + outputs: [ + { + internalType: 'uint40', + name: 'epochBegin', + type: 'uint40', + }, + { + internalType: 'uint40', + name: 'epochEnd', + type: 'uint40', + }, + { + internalType: 'uint40', + name: 'epochCreation', + type: 'uint40', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'epochExists', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'epochNull', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'epochResolved', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'epochs', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + ], + name: 'exists', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'factory', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'finalTVL', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getAllEpochs', + outputs: [ + { + internalType: 'uint256[]', + name: '', + type: 'uint256[]', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getDepositQueueLength', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getDepositQueueTVL', + outputs: [ + { + internalType: 'uint256', + name: 'tvl', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_id', + type: 'uint256', + }, + ], + name: 'getEpochConfig', + outputs: [ + { + internalType: 'uint40', + name: 'epochBegin', + type: 'uint40', + }, + { + internalType: 'uint40', + name: 'epochEnd', + type: 'uint40', + }, + { + internalType: 'uint40', + name: 'epochCreation', + type: 'uint40', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_id', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_assets', + type: 'uint256', + }, + ], + name: 'getEpochDepositFee', + outputs: [ + { + internalType: 'uint256', + name: 'feeAmount', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'assetsAfterFee', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getEpochsLength', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_owner', + type: 'address', + }, + ], + name: 'getRolloverIndex', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_owner', + type: 'address', + }, + ], + name: 'getRolloverPosition', + outputs: [ + { + internalType: 'uint256', + name: 'shares', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'epochId', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_index', + type: 'uint256', + }, + ], + name: 'getRolloverQueueItem', + outputs: [ + { + internalType: 'address', + name: 'receiver', + type: 'address', + }, + { + internalType: 'uint256', + name: 'shares', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'epochId', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getRolloverQueueLength', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getRolloverTVL', + outputs: [ + { + internalType: 'uint256', + name: 'tvl', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_epochId', + type: 'uint256', + }, + ], + name: 'getRolloverTVLByEpochId', + outputs: [ + { + internalType: 'uint256', + name: 'tvl', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'account', + type: 'address', + }, + { + internalType: 'address', + name: 'operator', + type: 'address', + }, + ], + name: 'isApprovedForAll', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_owner', + type: 'address', + }, + ], + name: 'isEnlistedInRolloverQueue', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'isWETH', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'minQueueDeposit', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_epochId', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_operations', + type: 'uint256', + }, + ], + name: 'mintDepositInQueue', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_epochId', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_operations', + type: 'uint256', + }, + ], + name: 'mintRollovers', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'name', + outputs: [ + { + internalType: 'string', + name: '', + type: 'string', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + name: 'ownerToRollOverQueueIndex', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_id', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_assets', + type: 'uint256', + }, + ], + name: 'previewAmountInShares', + outputs: [ + { + internalType: 'uint256', + name: 'entitledShareAmount', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_id', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_assets', + type: 'uint256', + }, + ], + name: 'previewEmissionsWithdraw', + outputs: [ + { + internalType: 'uint256', + name: 'entitledAmount', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_id', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_shares', + type: 'uint256', + }, + ], + name: 'previewWithdraw', + outputs: [ + { + internalType: 'uint256', + name: 'entitledAssets', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'relayerFee', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_id', + type: 'uint256', + }, + ], + name: 'resolveEpoch', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'rolloverAccounting', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'rolloverQueue', + outputs: [ + { + internalType: 'uint256', + name: 'shares', + type: 'uint256', + }, + { + internalType: 'address', + name: 'receiver', + type: 'address', + }, + { + internalType: 'uint256', + name: 'epochId', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + { + internalType: 'address', + name: '', + type: 'address', + }, + { + internalType: 'uint256[]', + name: '', + type: 'uint256[]', + }, + { + internalType: 'uint256[]', + name: '', + type: 'uint256[]', + }, + { + internalType: 'bytes', + name: '', + type: 'bytes', + }, + ], + name: 'safeBatchTransferFrom', + outputs: [], + stateMutability: 'pure', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'from', + type: 'address', + }, + { + internalType: 'address', + name: 'to', + type: 'address', + }, + { + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + { + internalType: 'bytes', + name: 'data', + type: 'bytes', + }, + ], + name: 'safeTransferFrom', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_id', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_amount', + type: 'uint256', + }, + { + internalType: 'address', + name: '_receiver', + type: 'address', + }, + ], + name: 'sendTokens', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'operator', + type: 'address', + }, + { + internalType: 'bool', + name: 'approved', + type: 'bool', + }, + ], + name: 'setApprovalForAll', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_id', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_claimTVL', + type: 'uint256', + }, + ], + name: 'setClaimTVL', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_counterPartyVault', + type: 'address', + }, + ], + name: 'setCounterPartyVault', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_epochId', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_emissionAmount', + type: 'uint256', + }, + ], + name: 'setEmissions', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint40', + name: '_epochBegin', + type: 'uint40', + }, + { + internalType: 'uint40', + name: '_epochEnd', + type: 'uint40', + }, + { + internalType: 'uint256', + name: '_epochId', + type: 'uint256', + }, + ], + name: 'setEpoch', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_id', + type: 'uint256', + }, + ], + name: 'setEpochNull', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'strike', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bytes4', + name: 'interfaceId', + type: 'bytes4', + }, + ], + name: 'supportsInterface', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'symbol', + outputs: [ + { + internalType: 'string', + name: '', + type: 'string', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'token', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_id', + type: 'uint256', + }, + ], + name: 'totalAssets', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + ], + name: 'totalSupply', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'treasury', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'uri', + outputs: [ + { + internalType: 'string', + name: '', + type: 'string', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_wAddress', + type: 'address', + }, + ], + name: 'whiteListAddress', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + name: 'whitelistedAddresses', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_id', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_shares', + type: 'uint256', + }, + { + internalType: 'address', + name: '_receiver', + type: 'address', + }, + { + internalType: 'address', + name: '_owner', + type: 'address', + }, + ], + name: 'withdraw', + outputs: [ + { + internalType: 'uint256', + name: 'assets', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, +]; + +export class Y2KFinanceCarousel__factory { + static readonly abi = _abi; + static createInterface(): Y2KFinanceCarouselInterface { + return new utils.Interface(_abi) as Y2KFinanceCarouselInterface; + } + static connect(address: string, signerOrProvider: Signer | Provider): Y2KFinanceCarousel { + return new Contract(address, _abi, signerOrProvider) as Y2KFinanceCarousel; + } +} diff --git a/src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceRewardsFactory__factory.ts b/src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceRewardsFactory__factory.ts new file mode 100644 index 000000000..e4dbb807b --- /dev/null +++ b/src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceRewardsFactory__factory.ts @@ -0,0 +1,190 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from 'ethers'; +import type { Provider } from '@ethersproject/providers'; +import type { Y2KFinanceRewardsFactory, Y2KFinanceRewardsFactoryInterface } from '../Y2KFinanceRewardsFactory'; + +const _abi = [ + { + inputs: [ + { + internalType: 'address', + name: '_govToken', + type: 'address', + }, + { + internalType: 'address', + name: '_factory', + type: 'address', + }, + ], + stateMutability: 'nonpayable', + type: 'constructor', + }, + { + inputs: [], + name: 'EpochDoesNotExist', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'marketId', + type: 'uint256', + }, + ], + name: 'MarketDoesNotExist', + type: 'error', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'bytes32', + name: 'marketEpochId', + type: 'bytes32', + }, + { + indexed: true, + internalType: 'uint256', + name: 'mIndex', + type: 'uint256', + }, + { + indexed: false, + internalType: 'address', + name: 'hedgeFarm', + type: 'address', + }, + { + indexed: false, + internalType: 'address', + name: 'riskFarm', + type: 'address', + }, + ], + name: 'CreatedStakingReward', + 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', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_marketIndex', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_epochEnd', + type: 'uint256', + }, + ], + name: 'createStakingRewards', + outputs: [ + { + internalType: 'address', + name: 'insr', + type: 'address', + }, + { + internalType: 'address', + name: 'risk', + type: 'address', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'factory', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'govToken', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'owner', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'renounceOwnership', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'newOwner', + type: 'address', + }, + ], + name: 'transferOwnership', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, +]; + +export class Y2KFinanceRewardsFactory__factory { + static readonly abi = _abi; + static createInterface(): Y2KFinanceRewardsFactoryInterface { + return new utils.Interface(_abi) as Y2KFinanceRewardsFactoryInterface; + } + static connect(address: string, signerOrProvider: Signer | Provider): Y2KFinanceRewardsFactory { + return new Contract(address, _abi, signerOrProvider) as Y2KFinanceRewardsFactory; + } +} diff --git a/src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceStakingRewards__factory.ts b/src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceStakingRewards__factory.ts new file mode 100644 index 000000000..54b84ca4d --- /dev/null +++ b/src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceStakingRewards__factory.ts @@ -0,0 +1,735 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from 'ethers'; +import type { Provider } from '@ethersproject/providers'; +import type { Y2KFinanceStakingRewards, Y2KFinanceStakingRewardsInterface } from '../Y2KFinanceStakingRewards'; + +const _abi = [ + { + inputs: [ + { + internalType: 'address', + name: '_owner', + type: 'address', + }, + { + internalType: 'address', + name: '_rewardsDistribution', + type: 'address', + }, + { + internalType: 'address', + name: '_rewardsToken', + type: 'address', + }, + { + internalType: 'address', + name: '_stakingToken', + type: 'address', + }, + { + internalType: 'uint256', + name: '_epochEnd', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'constructor', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: 'oldOwner', + type: 'address', + }, + { + indexed: false, + internalType: 'address', + name: 'newOwner', + type: 'address', + }, + ], + name: 'OwnerChanged', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: 'newOwner', + type: 'address', + }, + ], + name: 'OwnerNominated', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: 'account', + type: 'address', + }, + ], + name: 'Paused', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: 'token', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + ], + name: 'Recovered', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint256', + name: 'reward', + type: 'uint256', + }, + ], + name: 'RewardAdded', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'user', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: 'reward', + type: 'uint256', + }, + ], + name: 'RewardPaid', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint256', + name: 'newDuration', + type: 'uint256', + }, + ], + name: 'RewardsDurationUpdated', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'user', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + ], + name: 'Staked', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: 'account', + type: 'address', + }, + ], + name: 'Unpaused', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'user', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + ], + name: 'Withdrawn', + type: 'event', + }, + { + inputs: [], + name: 'acceptOwnership', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'account', + type: 'address', + }, + ], + name: 'balanceOf', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'account', + type: 'address', + }, + ], + name: 'earned', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'exit', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'getReward', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'getRewardForDuration', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'id', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'lastTimeRewardApplicable', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'lastUpdateTime', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_owner', + type: 'address', + }, + ], + name: 'nominateNewOwner', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'nominatedOwner', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'reward', + type: 'uint256', + }, + ], + name: 'notifyRewardAmount', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + { + internalType: 'address', + name: '', + type: 'address', + }, + { + internalType: 'uint256[]', + name: '', + type: 'uint256[]', + }, + { + internalType: 'uint256[]', + name: '', + type: 'uint256[]', + }, + { + internalType: 'bytes', + name: '', + type: 'bytes', + }, + ], + name: 'onERC1155BatchReceived', + outputs: [ + { + internalType: 'bytes4', + name: '', + type: 'bytes4', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + { + internalType: 'address', + name: '', + type: 'address', + }, + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + { + internalType: 'bytes', + name: '', + type: 'bytes', + }, + ], + name: 'onERC1155Received', + outputs: [ + { + internalType: 'bytes4', + name: '', + type: 'bytes4', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'owner', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'pause', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'paused', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'periodFinish', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'tokenAddress', + type: 'address', + }, + { + internalType: 'uint256', + name: 'tokenAmount', + type: 'uint256', + }, + ], + name: 'recoverERC20', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'rewardPerToken', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'rewardPerTokenStored', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'rewardRate', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + name: 'rewards', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'rewardsDistribution', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'rewardsDuration', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'rewardsToken', + outputs: [ + { + internalType: 'contract ERC20', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_rewardsDistribution', + type: 'address', + }, + ], + name: 'setRewardsDistribution', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_rewardsDuration', + type: 'uint256', + }, + ], + name: 'setRewardsDuration', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + ], + name: 'stake', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'stakingToken', + outputs: [ + { + internalType: 'contract IERC1155', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bytes4', + name: 'interfaceId', + type: 'bytes4', + }, + ], + name: 'supportsInterface', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'totalSupply', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'unpause', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + name: 'userRewardPerTokenPaid', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + ], + name: 'withdraw', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, +]; + +export class Y2KFinanceStakingRewards__factory { + static readonly abi = _abi; + static createInterface(): Y2KFinanceStakingRewardsInterface { + return new utils.Interface(_abi) as Y2KFinanceStakingRewardsInterface; + } + static connect(address: string, signerOrProvider: Signer | Provider): Y2KFinanceStakingRewards { + return new Contract(address, _abi, signerOrProvider) as Y2KFinanceStakingRewards; + } +} diff --git a/src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceVaultFactoryV1__factory.ts b/src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceVaultFactoryV1__factory.ts new file mode 100644 index 000000000..b00387133 --- /dev/null +++ b/src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceVaultFactoryV1__factory.ts @@ -0,0 +1,633 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from 'ethers'; +import type { Provider } from '@ethersproject/providers'; +import type { Y2KFinanceVaultFactoryV1, Y2KFinanceVaultFactoryV1Interface } from '../Y2KFinanceVaultFactoryV1'; + +const _abi = [ + { + inputs: [ + { + internalType: 'address', + name: '_treasury', + type: 'address', + }, + { + internalType: 'address', + name: '_weth', + type: 'address', + }, + { + internalType: 'address', + name: '_policy', + type: 'address', + }, + ], + stateMutability: 'nonpayable', + type: 'constructor', + }, + { + inputs: [], + name: 'AddressFactoryNotInController', + type: 'error', + }, + { + inputs: [], + name: 'AddressNotController', + type: 'error', + }, + { + inputs: [], + name: 'AddressZero', + type: 'error', + }, + { + inputs: [], + name: 'ControllerAlreadySet', + type: 'error', + }, + { + inputs: [], + name: 'ControllerNotSet', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'marketIndex', + type: 'uint256', + }, + ], + name: 'MarketDoesNotExist', + type: 'error', + }, + { + inputs: [], + name: 'NotTimeLocker', + type: 'error', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'bytes32', + name: 'marketEpochId', + type: 'bytes32', + }, + { + indexed: true, + internalType: 'uint256', + name: 'mIndex', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'startEpoch', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'endEpoch', + type: 'uint256', + }, + { + indexed: false, + internalType: 'address', + name: 'hedge', + type: 'address', + }, + { + indexed: false, + internalType: 'address', + name: 'risk', + type: 'address', + }, + { + indexed: false, + internalType: 'address', + name: 'token', + type: 'address', + }, + { + indexed: false, + internalType: 'string', + name: 'name', + type: 'string', + }, + { + indexed: false, + internalType: 'int256', + name: 'strikePrice', + type: 'int256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'withdrawalFee', + type: 'uint256', + }, + ], + name: 'EpochCreated', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'uint256', + name: 'mIndex', + type: 'uint256', + }, + { + indexed: false, + internalType: 'address', + name: 'hedge', + type: 'address', + }, + { + indexed: false, + internalType: 'address', + name: 'risk', + type: 'address', + }, + { + indexed: false, + internalType: 'address', + name: 'token', + type: 'address', + }, + { + indexed: false, + internalType: 'string', + name: 'name', + type: 'string', + }, + { + indexed: false, + internalType: 'int256', + name: 'strikePrice', + type: 'int256', + }, + ], + name: 'MarketCreated', + 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: 'uint256', + name: '_marketIndex', + type: 'uint256', + }, + { + indexed: true, + internalType: 'address', + name: 'controller', + type: 'address', + }, + ], + name: 'changedController', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: '_token', + type: 'address', + }, + { + indexed: false, + internalType: 'address', + name: '_oracle', + type: 'address', + }, + ], + name: 'changedOracle', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: '_treasury', + type: 'address', + }, + { + indexed: true, + internalType: 'uint256', + name: '_marketIndex', + type: 'uint256', + }, + ], + name: 'changedTreasury', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'uint256', + name: '_marketIndex', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: '_feeRate', + type: 'uint256', + }, + ], + name: 'changedVaultFee', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'newController', + type: 'address', + }, + ], + name: 'controllerSet', + type: 'event', + }, + { + inputs: [], + name: 'WETH', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_marketIndex', + type: 'uint256', + }, + { + internalType: 'address', + name: '_controller', + type: 'address', + }, + ], + name: 'changeController', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_token', + type: 'address', + }, + { + internalType: 'address', + name: '_oracle', + type: 'address', + }, + ], + name: 'changeOracle', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_treasury', + type: 'address', + }, + { + internalType: 'uint256', + name: '_marketIndex', + type: 'uint256', + }, + ], + name: 'changeTreasury', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'controller', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_withdrawalFee', + type: 'uint256', + }, + { + internalType: 'address', + name: '_token', + type: 'address', + }, + { + internalType: 'int256', + name: '_strikePrice', + type: 'int256', + }, + { + internalType: 'uint256', + name: 'epochBegin', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'epochEnd', + type: 'uint256', + }, + { + internalType: 'address', + name: '_oracle', + type: 'address', + }, + { + internalType: 'string', + name: '_name', + type: 'string', + }, + ], + name: 'createNewMarket', + outputs: [ + { + internalType: 'address', + name: 'insr', + type: 'address', + }, + { + internalType: 'address', + name: 'rsk', + type: 'address', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'index', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'epochBegin', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'epochEnd', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_withdrawalFee', + type: 'uint256', + }, + ], + name: 'deployMoreAssets', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'index', + type: 'uint256', + }, + ], + name: 'getVaults', + outputs: [ + { + internalType: 'address[]', + name: 'vaults', + type: 'address[]', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'indexEpochs', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'indexVaults', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'marketIndex', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'owner', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'renounceOwnership', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_controller', + type: 'address', + }, + ], + name: 'setController', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'timelocker', + outputs: [ + { + internalType: 'contract TimeLock', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + name: 'tokenToOracle', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'newOwner', + type: 'address', + }, + ], + name: 'transferOwnership', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'treasury', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, +]; + +export class Y2KFinanceVaultFactoryV1__factory { + static readonly abi = _abi; + static createInterface(): Y2KFinanceVaultFactoryV1Interface { + return new utils.Interface(_abi) as Y2KFinanceVaultFactoryV1Interface; + } + static connect(address: string, signerOrProvider: Signer | Provider): Y2KFinanceVaultFactoryV1 { + return new Contract(address, _abi, signerOrProvider) as Y2KFinanceVaultFactoryV1; + } +} diff --git a/src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceVaultV1__factory.ts b/src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceVaultV1__factory.ts new file mode 100644 index 000000000..60de2b60e --- /dev/null +++ b/src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceVaultV1__factory.ts @@ -0,0 +1,1096 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from 'ethers'; +import type { Provider } from '@ethersproject/providers'; +import type { Y2KFinanceVaultV1, Y2KFinanceVaultV1Interface } from '../Y2KFinanceVaultV1'; + +const _abi = [ + { + inputs: [ + { + internalType: 'address', + name: '_assetAddress', + type: 'address', + }, + { + internalType: 'string', + name: '_name', + type: 'string', + }, + { + internalType: 'string', + name: '_symbol', + type: 'string', + }, + { + internalType: 'address', + name: '_treasury', + type: 'address', + }, + { + internalType: 'address', + name: '_token', + type: 'address', + }, + { + internalType: 'int256', + name: '_strikePrice', + type: 'int256', + }, + { + internalType: 'address', + name: '_controller', + type: 'address', + }, + ], + stateMutability: 'nonpayable', + type: 'constructor', + }, + { + inputs: [ + { + internalType: 'address', + name: '_contract', + type: 'address', + }, + ], + name: 'AddressNotController', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: '_contract', + type: 'address', + }, + ], + name: 'AddressNotFactory', + type: 'error', + }, + { + inputs: [], + name: 'AddressZero', + type: 'error', + }, + { + inputs: [], + name: 'EpochAlreadyStarted', + type: 'error', + }, + { + inputs: [], + name: 'EpochEndMustBeAfterBegin', + type: 'error', + }, + { + inputs: [], + name: 'EpochNotFinished', + type: 'error', + }, + { + inputs: [], + name: 'FeeCannotBe0', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_fee', + type: 'uint256', + }, + ], + name: 'FeeMoreThan150', + type: 'error', + }, + { + inputs: [], + name: 'MarketEpochDoesNotExist', + type: 'error', + }, + { + inputs: [], + name: 'MarketEpochExists', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: '_sender', + type: 'address', + }, + { + internalType: 'address', + name: '_owner', + type: 'address', + }, + ], + name: 'OwnerDidNotAuthorize', + type: 'error', + }, + { + inputs: [], + name: 'ZeroValue', + type: 'error', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'account', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'operator', + type: 'address', + }, + { + indexed: false, + internalType: 'bool', + name: 'approved', + type: 'bool', + }, + ], + name: 'ApprovalForAll', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: 'caller', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'owner', + type: 'address', + }, + { + indexed: true, + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'assets', + type: 'uint256', + }, + ], + name: 'Deposit', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'operator', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'from', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'to', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256[]', + name: 'ids', + type: 'uint256[]', + }, + { + indexed: false, + internalType: 'uint256[]', + name: 'values', + type: 'uint256[]', + }, + ], + name: 'TransferBatch', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'operator', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'from', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'to', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'value', + type: 'uint256', + }, + ], + name: 'TransferSingle', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'string', + name: 'value', + type: 'string', + }, + { + indexed: true, + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + ], + name: 'URI', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: 'caller', + type: 'address', + }, + { + indexed: false, + internalType: 'address', + name: 'receiver', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'owner', + type: 'address', + }, + { + indexed: true, + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'assets', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'shares', + type: 'uint256', + }, + ], + name: 'Withdraw', + type: 'event', + }, + { + inputs: [], + name: 'asset', + outputs: [ + { + internalType: 'contract ERC20', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'account', + type: 'address', + }, + { + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + ], + name: 'balanceOf', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address[]', + name: 'accounts', + type: 'address[]', + }, + { + internalType: 'uint256[]', + name: 'ids', + type: 'uint256[]', + }, + ], + name: 'balanceOfBatch', + outputs: [ + { + internalType: 'uint256[]', + name: '', + type: 'uint256[]', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_epoch', + type: 'uint256', + }, + ], + name: 'calculateWithdrawalFeeValue', + outputs: [ + { + internalType: 'uint256', + name: 'feeValue', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_controller', + type: 'address', + }, + ], + name: 'changeController', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_treasury', + type: 'address', + }, + ], + name: 'changeTreasury', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'controller', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'epochBegin', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'epochEnd', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_withdrawalFee', + type: 'uint256', + }, + ], + name: 'createAssets', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'assets', + type: 'uint256', + }, + { + internalType: 'address', + name: 'receiver', + type: 'address', + }, + ], + name: 'deposit', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + { + internalType: 'address', + name: 'receiver', + type: 'address', + }, + ], + name: 'depositETH', + outputs: [], + stateMutability: 'payable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + ], + name: 'endEpoch', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'epochFee', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'epochNull', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'epochs', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'epochsLength', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + ], + name: 'exists', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'factory', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'idClaimTVL', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'idEpochBegin', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'idEpochEnded', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'idExists', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'idFinalTVL', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'account', + type: 'address', + }, + { + internalType: 'address', + name: 'operator', + type: 'address', + }, + ], + name: 'isApprovedForAll', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'name', + outputs: [ + { + internalType: 'string', + name: '', + type: 'string', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'assets', + type: 'uint256', + }, + ], + name: 'previewWithdraw', + outputs: [ + { + internalType: 'uint256', + name: 'entitledAmount', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'from', + type: 'address', + }, + { + internalType: 'address', + name: 'to', + type: 'address', + }, + { + internalType: 'uint256[]', + name: 'ids', + type: 'uint256[]', + }, + { + internalType: 'uint256[]', + name: 'amounts', + type: 'uint256[]', + }, + { + internalType: 'bytes', + name: 'data', + type: 'bytes', + }, + ], + name: 'safeBatchTransferFrom', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'from', + type: 'address', + }, + { + internalType: 'address', + name: 'to', + type: 'address', + }, + { + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + { + internalType: 'bytes', + name: 'data', + type: 'bytes', + }, + ], + name: 'safeTransferFrom', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + { + internalType: 'address', + name: '_counterparty', + type: 'address', + }, + ], + name: 'sendTokens', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'operator', + type: 'address', + }, + { + internalType: 'bool', + name: 'approved', + type: 'bool', + }, + ], + name: 'setApprovalForAll', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'claimTVL', + type: 'uint256', + }, + ], + name: 'setClaimTVL', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + ], + name: 'setEpochNull', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'strikePrice', + outputs: [ + { + internalType: 'int256', + name: '', + type: 'int256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bytes4', + name: 'interfaceId', + type: 'bytes4', + }, + ], + name: 'supportsInterface', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'symbol', + outputs: [ + { + internalType: 'string', + name: '', + type: 'string', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'tokenInsured', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_id', + type: 'uint256', + }, + ], + name: 'totalAssets', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + ], + name: 'totalSupply', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'treasury', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'uri', + outputs: [ + { + internalType: 'string', + name: '', + type: 'string', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'id', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'assets', + type: 'uint256', + }, + { + internalType: 'address', + name: 'receiver', + type: 'address', + }, + { + internalType: 'address', + name: 'owner', + type: 'address', + }, + ], + name: 'withdraw', + outputs: [ + { + internalType: 'uint256', + name: 'shares', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, +]; + +export class Y2KFinanceVaultV1__factory { + static readonly abi = _abi; + static createInterface(): Y2KFinanceVaultV1Interface { + return new utils.Interface(_abi) as Y2KFinanceVaultV1Interface; + } + static connect(address: string, signerOrProvider: Signer | Provider): Y2KFinanceVaultV1 { + return new Contract(address, _abi, signerOrProvider) as Y2KFinanceVaultV1; + } +} diff --git a/src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceVotingLocked__factory.ts b/src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceVotingLocked__factory.ts new file mode 100644 index 000000000..cd5ea4a4f --- /dev/null +++ b/src/apps/y2k-finance/contracts/ethers/factories/Y2KFinanceVotingLocked__factory.ts @@ -0,0 +1,1242 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from 'ethers'; +import type { Provider } from '@ethersproject/providers'; +import type { Y2KFinanceVotingLocked, Y2KFinanceVotingLockedInterface } from '../Y2KFinanceVotingLocked'; + +const _abi = [ + { + inputs: [ + { + internalType: 'address', + name: '_lockToken', + type: 'address', + }, + { + internalType: 'address', + name: '_rewardAddr1', + type: 'address', + }, + { + internalType: 'address', + name: '_rewardAddr2', + type: 'address', + }, + { + internalType: 'uint256', + name: '_maxEpochs', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_minEpochs', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'constructor', + }, + { + inputs: [ + { + internalType: 'address', + name: 'governanceToken', + type: 'address', + }, + ], + name: 'CannotWhitelistGovernanceToken', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'maxEpochs', + type: 'uint256', + }, + ], + name: 'EpochMaxReached', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'epochStart', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'now', + type: 'uint256', + }, + ], + name: 'EpochStartInvalid', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'balance', + type: 'uint256', + }, + ], + name: 'FundsInLockPeriod', + type: 'error', + }, + { + inputs: [], + name: 'IncreaseLockEpochsNotGTZero', + type: 'error', + }, + { + inputs: [], + name: 'InsufficientAmount', + type: 'error', + }, + { + inputs: [], + name: 'InsufficientBalance', + type: 'error', + }, + { + inputs: [ + { + internalType: 'address', + name: 'token', + type: 'address', + }, + { + internalType: 'uint256', + name: 'available', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'rewardAmount', + type: 'uint256', + }, + ], + name: 'InsufficientFundsForRewards', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'maxEpochs', + type: 'uint256', + }, + ], + name: 'LockEpochsMax', + type: 'error', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'minEpochs', + type: 'uint256', + }, + ], + name: 'LockEpochsMin', + type: 'error', + }, + { + inputs: [], + name: 'NotWhitelisted', + type: 'error', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: 'token', + type: 'address', + }, + { + indexed: false, + internalType: 'bool', + name: 'tokenState', + type: 'bool', + }, + ], + name: 'ChangeERC20Whiltelist', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'uint256', + name: 'currentTime', + type: 'uint256', + }, + { + indexed: false, + internalType: 'bool', + name: 'flag', + type: 'bool', + }, + ], + name: 'ChangeEnforceTime', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'uint256', + name: 'currentTime', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'oldEpochs', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'newEpochs', + type: 'uint256', + }, + ], + name: 'ChangeMaxLockEpochs', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'user', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'lockedEpochs', + type: 'uint256', + }, + ], + name: 'Deposit', + 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: false, + internalType: 'address', + name: 'account', + type: 'address', + }, + ], + name: 'Paused', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: 'token', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + ], + name: 'RecoveredERC20', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: 'token', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: 'tokenId', + type: 'uint256', + }, + ], + name: 'RecoveredERC721', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'user', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: 'totalBalance', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'lockedEpochs', + type: 'uint256', + }, + ], + name: 'Relock', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'user', + type: 'address', + }, + { + indexed: false, + internalType: 'address', + name: 'token', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: 'reward', + type: 'uint256', + }, + ], + name: 'RewardPaid', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'uint256', + name: 'epochId', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'reward1', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'reward2', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'start', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: 'finish', + type: 'uint256', + }, + ], + name: 'SetNextReward', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'address', + name: 'account', + type: 'address', + }, + ], + name: 'Unpaused', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint256', + name: 'currentId', + type: 'uint256', + }, + ], + name: 'UpdatedEpoch', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'user', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + ], + name: 'Withdrawn', + type: 'event', + }, + { + inputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + name: 'accounts', + outputs: [ + { + internalType: 'uint256', + name: 'balance', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'lockEpochs', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'lastEpochPaid', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'rewards1', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'rewards2', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'owner', + type: 'address', + }, + ], + name: 'balanceOf', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'owner', + type: 'address', + }, + { + internalType: 'uint256', + name: 'epochId', + type: 'uint256', + }, + ], + name: 'balanceOfInEpoch', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'bool', + name: 'flag', + type: 'bool', + }, + ], + name: 'changeEnforceTime', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_maxEpochs', + type: 'uint256', + }, + ], + name: 'changeMaxEpochs', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'tokenAddress', + type: 'address', + }, + { + internalType: 'bool', + name: 'flag', + type: 'bool', + }, + ], + name: 'changeRecoverWhitelist', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'claimReward', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'currentEpoch', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'lockEpochs', + type: 'uint256', + }, + ], + name: 'deposit', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'enforceTime', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'epochs', + outputs: [ + { + internalType: 'uint256', + name: 'start', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'finish', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'totalLocked', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'rewards1', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'rewards2', + type: 'uint256', + }, + { + internalType: 'bool', + name: 'isSet', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'exit', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'owner', + type: 'address', + }, + ], + name: 'getAccount', + outputs: [ + { + internalType: 'uint256', + name: 'balance', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'lockEpochs', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'lastEpochPaid', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'rewards1', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'rewards2', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getCurrentEpoch', + outputs: [ + { + internalType: 'uint256', + name: 'start', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'finish', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'locked', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'rewards1', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'rewards2', + type: 'uint256', + }, + { + internalType: 'bool', + name: 'isSet', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'epochId', + type: 'uint256', + }, + ], + name: 'getEpoch', + outputs: [ + { + internalType: 'uint256', + name: 'start', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'finish', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'locked', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'rewards1', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'rewards2', + type: 'uint256', + }, + { + internalType: 'bool', + name: 'isSet', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'owner', + type: 'address', + }, + { + internalType: 'uint256', + name: 'epochId', + type: 'uint256', + }, + ], + name: 'getEpochAccountInfo', + outputs: [ + { + internalType: 'uint256', + name: 'balance', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'start', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'finish', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'locked', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'userRewards1', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'userRewards2', + type: 'uint256', + }, + { + internalType: 'bool', + name: 'isSet', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'getNextEpoch', + outputs: [ + { + internalType: 'uint256', + name: 'start', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'finish', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'locked', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'rewards1', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'rewards2', + type: 'uint256', + }, + { + internalType: 'bool', + name: 'isSet', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'lockToken', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'maxEpochs', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'minEpochs', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'nextUnsetEpoch', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'owner', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'pause', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'paused', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'tokenAddress', + type: 'address', + }, + { + internalType: 'uint256', + name: 'tokenAmount', + type: 'uint256', + }, + ], + name: 'recoverERC20', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'tokenAddress', + type: 'address', + }, + { + internalType: 'uint256', + name: 'tokenId', + type: 'uint256', + }, + ], + name: 'recoverERC721', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'renounceOwnership', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'rewardToken', + outputs: [ + { + internalType: 'address', + name: 'addr', + type: 'address', + }, + { + internalType: 'uint256', + name: 'rewards', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'rewardsPaid', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'reward1', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'reward2', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'epochDurationInDays', + type: 'uint256', + }, + ], + name: 'setNextEpoch', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'reward1', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'reward2', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'epochDurationInDays', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'epochStart', + type: 'uint256', + }, + ], + name: 'setNextEpoch_start', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'totalAssets', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'totalLocked', + 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: [], + name: 'unpause', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'updateAccount', + outputs: [ + { + internalType: 'uint256', + name: 'balance', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'lockEpochs', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'lastEpochPaid', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'rewards1', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'rewards2', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'updateEpochs', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + name: 'whitelistRecoverERC20', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + ], + name: 'withdraw', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, +]; + +export class Y2KFinanceVotingLocked__factory { + static readonly abi = _abi; + static createInterface(): Y2KFinanceVotingLockedInterface { + return new utils.Interface(_abi) as Y2KFinanceVotingLockedInterface; + } + static connect(address: string, signerOrProvider: Signer | Provider): Y2KFinanceVotingLocked { + return new Contract(address, _abi, signerOrProvider) as Y2KFinanceVotingLocked; + } +} diff --git a/src/apps/y2k-finance/contracts/ethers/factories/index.ts b/src/apps/y2k-finance/contracts/ethers/factories/index.ts new file mode 100644 index 000000000..bb90e8d05 --- /dev/null +++ b/src/apps/y2k-finance/contracts/ethers/factories/index.ts @@ -0,0 +1,10 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { Y2KFinanceCarousel__factory } from './Y2KFinanceCarousel__factory'; +export { Y2KFinanceCarouselFactory__factory } from './Y2KFinanceCarouselFactory__factory'; +export { Y2KFinanceRewardsFactory__factory } from './Y2KFinanceRewardsFactory__factory'; +export { Y2KFinanceStakingRewards__factory } from './Y2KFinanceStakingRewards__factory'; +export { Y2KFinanceVaultFactoryV1__factory } from './Y2KFinanceVaultFactoryV1__factory'; +export { Y2KFinanceVaultV1__factory } from './Y2KFinanceVaultV1__factory'; +export { Y2KFinanceVotingLocked__factory } from './Y2KFinanceVotingLocked__factory'; diff --git a/src/apps/y2k-finance/contracts/ethers/index.ts b/src/apps/y2k-finance/contracts/ethers/index.ts new file mode 100644 index 000000000..33ed30aed --- /dev/null +++ b/src/apps/y2k-finance/contracts/ethers/index.ts @@ -0,0 +1,18 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { Y2KFinanceCarousel } from './Y2KFinanceCarousel'; +export type { Y2KFinanceCarouselFactory } from './Y2KFinanceCarouselFactory'; +export type { Y2KFinanceRewardsFactory } from './Y2KFinanceRewardsFactory'; +export type { Y2KFinanceStakingRewards } from './Y2KFinanceStakingRewards'; +export type { Y2KFinanceVaultFactoryV1 } from './Y2KFinanceVaultFactoryV1'; +export type { Y2KFinanceVaultV1 } from './Y2KFinanceVaultV1'; +export type { Y2KFinanceVotingLocked } from './Y2KFinanceVotingLocked'; +export * as factories from './factories'; +export { Y2KFinanceCarouselFactory__factory } from './factories/Y2KFinanceCarouselFactory__factory'; +export { Y2KFinanceCarousel__factory } from './factories/Y2KFinanceCarousel__factory'; +export { Y2KFinanceRewardsFactory__factory } from './factories/Y2KFinanceRewardsFactory__factory'; +export { Y2KFinanceStakingRewards__factory } from './factories/Y2KFinanceStakingRewards__factory'; +export { Y2KFinanceVaultFactoryV1__factory } from './factories/Y2KFinanceVaultFactoryV1__factory'; +export { Y2KFinanceVaultV1__factory } from './factories/Y2KFinanceVaultV1__factory'; +export { Y2KFinanceVotingLocked__factory } from './factories/Y2KFinanceVotingLocked__factory'; diff --git a/src/apps/y2k-finance/contracts/index.ts b/src/apps/y2k-finance/contracts/index.ts new file mode 100644 index 000000000..47489a6c4 --- /dev/null +++ b/src/apps/y2k-finance/contracts/index.ts @@ -0,0 +1,55 @@ +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 { + Y2KFinanceCarousel__factory, + Y2KFinanceCarouselFactory__factory, + Y2KFinanceRewardsFactory__factory, + Y2KFinanceStakingRewards__factory, + Y2KFinanceVaultFactoryV1__factory, + Y2KFinanceVaultV1__factory, + Y2KFinanceVotingLocked__factory, +} from './ethers'; + +// eslint-disable-next-line +type ContractOpts = { address: string; network: Network }; + +@Injectable() +export class Y2KFinanceContractFactory extends ContractFactory { + constructor(@Inject(APP_TOOLKIT) protected readonly appToolkit: IAppToolkit) { + super((network: Network) => appToolkit.getNetworkProvider(network)); + } + + y2KFinanceCarousel({ address, network }: ContractOpts) { + return Y2KFinanceCarousel__factory.connect(address, this.appToolkit.getNetworkProvider(network)); + } + y2KFinanceCarouselFactory({ address, network }: ContractOpts) { + return Y2KFinanceCarouselFactory__factory.connect(address, this.appToolkit.getNetworkProvider(network)); + } + y2KFinanceRewardsFactory({ address, network }: ContractOpts) { + return Y2KFinanceRewardsFactory__factory.connect(address, this.appToolkit.getNetworkProvider(network)); + } + y2KFinanceStakingRewards({ address, network }: ContractOpts) { + return Y2KFinanceStakingRewards__factory.connect(address, this.appToolkit.getNetworkProvider(network)); + } + y2KFinanceVaultFactoryV1({ address, network }: ContractOpts) { + return Y2KFinanceVaultFactoryV1__factory.connect(address, this.appToolkit.getNetworkProvider(network)); + } + y2KFinanceVaultV1({ address, network }: ContractOpts) { + return Y2KFinanceVaultV1__factory.connect(address, this.appToolkit.getNetworkProvider(network)); + } + y2KFinanceVotingLocked({ address, network }: ContractOpts) { + return Y2KFinanceVotingLocked__factory.connect(address, this.appToolkit.getNetworkProvider(network)); + } +} + +export type { Y2KFinanceCarousel } from './ethers'; +export type { Y2KFinanceCarouselFactory } from './ethers'; +export type { Y2KFinanceRewardsFactory } from './ethers'; +export type { Y2KFinanceStakingRewards } from './ethers'; +export type { Y2KFinanceVaultFactoryV1 } from './ethers'; +export type { Y2KFinanceVaultV1 } from './ethers'; +export type { Y2KFinanceVotingLocked } from './ethers'; diff --git a/src/apps/y2k-finance/y2k-finance.module.ts b/src/apps/y2k-finance/y2k-finance.module.ts new file mode 100644 index 000000000..b8f117b05 --- /dev/null +++ b/src/apps/y2k-finance/y2k-finance.module.ts @@ -0,0 +1,21 @@ +import { Module } from '@nestjs/common'; + +import { AbstractApp } from '~app/app.dynamic-module'; + +import { ArbitrumY2KFinanceFarmV1ContractPositionFetcher } from './arbitrum/y2k-finance.farm-v1.contract-position-fetcher'; +import { ArbitrumY2KFinanceMintV1ContractPositionFetcher } from './arbitrum/y2k-finance.mint-v1.contract-position-fetcher'; +import { ArbitrumY2KFinanceMintV2ContractPositionFetcher } from './arbitrum/y2k-finance.mint-v2.contract-position-fetcher'; +import { ArbitrumY2KFinanceVotingLockedContractPositionFetcher } from './arbitrum/y2k-finance.voting-locked.contract-position-fetcher'; +import { Y2KFinanceContractFactory } from './contracts'; + +@Module({ + providers: [ + Y2KFinanceContractFactory, + // Arbitrum + ArbitrumY2KFinanceFarmV1ContractPositionFetcher, + ArbitrumY2KFinanceMintV1ContractPositionFetcher, + ArbitrumY2KFinanceMintV2ContractPositionFetcher, + ArbitrumY2KFinanceVotingLockedContractPositionFetcher, + ], +}) +export class Y2KFinanceAppModule extends AbstractApp() {}