diff --git a/packages/contract-helpers/src/commons/types.ts b/packages/contract-helpers/src/commons/types.ts index 303d72f6..fac9cf4e 100644 --- a/packages/contract-helpers/src/commons/types.ts +++ b/packages/contract-helpers/src/commons/types.ts @@ -1,4 +1,5 @@ -import { BigNumber, BytesLike, PopulatedTransaction } from 'ethers'; +import { BigNumber } from '@ethersproject/bignumber'; +import { BytesLike, PopulatedTransaction } from 'ethers'; import { LPBorrowParamsType, LPRepayParamsType, @@ -158,6 +159,26 @@ export enum ProtocolAction { batchMetaDelegate = 'batchMetaDelegate', updateRepresentatives = 'updateRepresentatives', migrateABPT = 'migrateABPT', + umbrellaStake = 'umbrellaStake', + umbrellaStakeWithPermit = 'umbrellaStakeWithPermit', + umbrellaStakeWithATokens = 'umbrellaStakeWithATokens', + umbrellaStakeWithATokensWithPermit = 'umbrellaStakeWithATokensWithPermit', + umbrellaRedeem = 'umbrellaRedeem', + umbrellaRedeemATokens = 'umbrellaRedeemATokens', + umbrellaStakeTokenCooldown = 'umbrellaStakeTokenCooldown', + umbrellaStakeTokenDeposit = 'umbrellaStakeTokenDeposit', + umbrellaStakeTokenDepositWithPermit = 'umbrellaStakeTokenDepositWithPermit', + umbrellaStakeTokenRedeem = 'umbrellaStakeTokenRedeem', + umbrellaClaimAllRewards = 'umbrellaClaimAllRewards', + umbrellaClaimSelectedRewards = 'umbrellaClaimSelectedRewards', + umbrellaStakeGatewayStake = 'umbrellaStakeGatewayStake', + umbrellaStakeGatewayStakeWithPermit = 'umbrellaStakeGatewayStakeWithPermit', + umbrellaStakeGatewayStakeATokens = 'umbrellaStakeGatewayStakeATokens', + umbrellaStakeGatewayStakeATokensWithPermit = 'umbrellaStakeGatewayStakeATokensWithPermit', + umbrellaStakeGatewayStakeNativeTokens = 'umbrellaStakeGatewayStakeNativeTokens', + umbrellaStakeGatewayRedeem = 'umbrellaStakeGatewayRedeem', + umbrellaStakeGatewayRedeemATokens = 'umbrellaStakeGatewayRedeemATokens', + umbrellaStakeGatewayRedeemNativeTokens = 'umbrellaStakeGatewayRedeemNativeTokens', } export enum GovernanceVote { @@ -406,3 +427,10 @@ export type RepayWithATokensTxBuilder = { rateMode, }: Omit) => Promise; }; + +export type DefinedPopulatedTransaction = PopulatedTransaction & { + data: string; + from: string; + to: string; + gasLimit: BigNumber; +}; diff --git a/packages/contract-helpers/src/commons/utils.test.ts b/packages/contract-helpers/src/commons/utils.test.ts index 57cddfec..acf2004b 100644 --- a/packages/contract-helpers/src/commons/utils.test.ts +++ b/packages/contract-helpers/src/commons/utils.test.ts @@ -1,4 +1,5 @@ -import { BigNumber } from 'ethers'; +import { BigNumber, Wallet } from 'ethers'; +import { isAddress } from 'ethers/lib/utils'; import { transactionType } from './types'; import { API_ETH_MOCK_ADDRESS, @@ -9,6 +10,8 @@ import { getTxValue, augustusToAmountOffsetFromCalldata, convertPopulatedTx, + makePair, + generateEIP712PermitMock, } from './utils'; describe('Utils', () => { @@ -130,4 +133,35 @@ describe('Utils', () => { expect(convertedTx.value).toEqual(BigNumber.from('0')); }); }); + + describe('makePair', () => { + it('Generates a valid pair', () => { + const { address, privateKey } = makePair('test_id'); + expect(isAddress(address)).toBeTruthy(); + expect(privateKey).toHaveLength(66); + const wallet = new Wallet(privateKey); + expect(wallet.address).toEqual(address); + }); + it('Generate always the same pair with same id', () => { + const { address: address1, privateKey: privateKey1 } = + makePair('test_id'); + const { address: address2, privateKey: privateKey2 } = + makePair('test_id'); + expect(address1).toEqual(address2); + expect(privateKey1).toEqual(privateKey2); + }); + }); + + describe('generateEIP712PermitMock', () => { + it('Generates valid EIP712 Permit values', () => { + const { value } = generateEIP712PermitMock('0x0', '0x1', '100', '1'); + expect(value).toEqual({ + owner: '0x0', + spender: '0x1', + value: '100', + nonce: '0', + deadline: '1', + }); + }); + }); }); diff --git a/packages/contract-helpers/src/commons/utils.ts b/packages/contract-helpers/src/commons/utils.ts index 7355195d..b03c1479 100644 --- a/packages/contract-helpers/src/commons/utils.ts +++ b/packages/contract-helpers/src/commons/utils.ts @@ -1,5 +1,5 @@ import { BigNumber as BigNumberJs } from 'bignumber.js'; -import { BigNumber, constants, PopulatedTransaction } from 'ethers'; +import { BigNumber, constants, PopulatedTransaction, utils } from 'ethers'; import { GasRecommendationType, ProtocolAction, @@ -150,6 +150,86 @@ export const gasLimitRecommendations: GasRecommendationType = { limit: '750000', recommended: '750000', }, + [ProtocolAction.umbrellaStake]: { + limit: '400000', + recommended: '400000', + }, + [ProtocolAction.umbrellaStakeWithPermit]: { + limit: '310000', + recommended: '310000', + }, + [ProtocolAction.umbrellaStakeWithATokens]: { + limit: '310000', + recommended: '310000', + }, + [ProtocolAction.umbrellaStakeWithATokensWithPermit]: { + limit: '310000', + recommended: '310000', + }, + [ProtocolAction.umbrellaRedeem]: { + limit: '310000', + recommended: '310000', + }, + [ProtocolAction.umbrellaRedeemATokens]: { + limit: '310000', + recommended: '310000', + }, + [ProtocolAction.umbrellaStakeTokenCooldown]: { + limit: '60000', + recommended: '60000', + }, + [ProtocolAction.umbrellaStakeTokenDeposit]: { + limit: '200000', + recommended: '200000', + }, + [ProtocolAction.umbrellaStakeTokenDepositWithPermit]: { + limit: '300000', + recommended: '300000', + }, + [ProtocolAction.umbrellaStakeTokenRedeem]: { + limit: '200000', + recommended: '200000', + }, + [ProtocolAction.umbrellaClaimAllRewards]: { + limit: '310000', + recommended: '310000', + }, + [ProtocolAction.umbrellaClaimSelectedRewards]: { + limit: '310000', + recommended: '310000', + }, + [ProtocolAction.umbrellaStakeGatewayStake]: { + limit: '310000', + recommended: '310000', + }, + [ProtocolAction.umbrellaStakeGatewayStakeWithPermit]: { + limit: '310000', + recommended: '310000', + }, + [ProtocolAction.umbrellaStakeGatewayStakeATokens]: { + limit: '310000', + recommended: '310000', + }, + [ProtocolAction.umbrellaStakeGatewayStakeATokensWithPermit]: { + limit: '310000', + recommended: '310000', + }, + [ProtocolAction.umbrellaStakeGatewayStakeNativeTokens]: { + limit: '310000', + recommended: '310000', + }, + [ProtocolAction.umbrellaStakeGatewayRedeem]: { + limit: '310000', + recommended: '310000', + }, + [ProtocolAction.umbrellaStakeGatewayRedeemATokens]: { + limit: '310000', + recommended: '310000', + }, + [ProtocolAction.umbrellaStakeGatewayRedeemNativeTokens]: { + limit: '310000', + recommended: '310000', + }, }; export const mintAmountsPerToken: Record = { @@ -232,3 +312,48 @@ export const convertPopulatedTx = ( value: tx.value ? BigNumber.from(tx.value) : BigNumber.from('0'), }; }; + +export const makePair = (id: string) => { + const privateKey = utils.id(id); + const address = utils.computeAddress(privateKey); + return { privateKey, address }; +}; + +export const DEFAULT_MOCK_VERIFYING_CONTRACT = + '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC'; + +export const generateEIP712PermitMock = ( + owner: string, + spender: string, + amount: string, + deadline: string, +) => { + const domain = { + name: 'Mocked token', + version: '1', + chainId: 1, + verifyingContract: DEFAULT_MOCK_VERIFYING_CONTRACT, + }; + const types = { + Permit: [ + { name: 'owner', type: 'address' }, + { name: 'spender', type: 'address' }, + { name: 'value', type: 'uint256' }, + { name: 'nonce', type: 'uint256' }, + { name: 'deadline', type: 'uint256' }, + ], + }; + const value = { + owner, + spender, + value: amount, + nonce: '0', + deadline, + }; + + return { domain, types, value }; +}; + +export function expectToBeDefined(value: T | undefined): asserts value is T { + expect(value).toBeDefined(); +} diff --git a/packages/contract-helpers/src/index.ts b/packages/contract-helpers/src/index.ts index da1c0e46..5f2bb6cf 100644 --- a/packages/contract-helpers/src/index.ts +++ b/packages/contract-helpers/src/index.ts @@ -41,6 +41,7 @@ export * from './governance-v3/aave-token-v3'; export * from './governance-v3/payloads-data-helper'; export * from './governance-v3/delegate-helper'; export * from './abpt-migration'; +export * from './umbrella'; // commons export * from './commons/types'; diff --git a/packages/contract-helpers/src/umbrella/RewardsDistributor.test.ts b/packages/contract-helpers/src/umbrella/RewardsDistributor.test.ts new file mode 100644 index 00000000..11e5408b --- /dev/null +++ b/packages/contract-helpers/src/umbrella/RewardsDistributor.test.ts @@ -0,0 +1,92 @@ +import { ProtocolAction } from '../commons/types'; +import { + expectToBeDefined, + gasLimitRecommendations, + makePair, +} from '../commons/utils'; +import { IRewardsDistributor__factory } from './typechain/IRewardsDistributor__factory'; +import { RewardsDistributorService } from './'; + +describe('Umbrella Rewards distributor', () => { + const { address: STAKE_TOKEN } = makePair('STAKE_TOKEN'); + const { address: STAKE_TOKEN_2 } = makePair('STAKE_TOKEN_2'); + const { address: ALICE } = makePair('ALICE'); + + const REWARD_1 = makePair('REWARD_1').address; + const REWARD_2 = makePair('REWARD_2').address; + + const stakeTokenService = new RewardsDistributorService(STAKE_TOKEN); + const stakeTokenInterface = IRewardsDistributor__factory.createInterface(); + describe('claimAllAvailableRewards', () => { + it('should properly create the transaction', () => { + const tx = stakeTokenService.claimAllAvailableRewards({ + stakeTokens: [STAKE_TOKEN, STAKE_TOKEN_2], + sender: ALICE, + }); + expect(tx.from).toEqual(ALICE); + expect(tx.to).toEqual(STAKE_TOKEN); + expectToBeDefined(tx.gasLimit); + expectToBeDefined(tx.data); + expect(tx.gasLimit.toString()).toEqual( + gasLimitRecommendations[ProtocolAction.umbrellaClaimAllRewards] + .recommended, + ); + const decoded = stakeTokenInterface.decodeFunctionData( + 'claimAllRewards(address[],address)', + tx.data, + ); + expect(decoded).toHaveLength(2); + expect(decoded[0]).toEqual([STAKE_TOKEN, STAKE_TOKEN_2]); + expect(decoded[1]).toEqual(ALICE); + }); + }); + describe('claimAllRewards', () => { + it('should properly create the transaction', () => { + const tx = stakeTokenService.claimAllRewards({ + stakeToken: STAKE_TOKEN, + sender: ALICE, + }); + expect(tx.from).toEqual(ALICE); + expect(tx.to).toEqual(STAKE_TOKEN); + expectToBeDefined(tx.gasLimit); + expectToBeDefined(tx.data); + expect(tx.gasLimit.toString()).toEqual( + gasLimitRecommendations[ProtocolAction.umbrellaClaimAllRewards] + .recommended, + ); + const decoded = stakeTokenInterface.decodeFunctionData( + 'claimAllRewards(address,address)', + tx.data, + ); + expect(decoded).toHaveLength(2); + expect(decoded[0]).toEqual(STAKE_TOKEN); + expect(decoded[1]).toEqual(ALICE); + }); + }); + describe('claimSelectedRewards', () => { + it('should properly create the transaction', () => { + const rewards = [REWARD_1, REWARD_2]; + const tx = stakeTokenService.claimSelectedRewards({ + stakeToken: STAKE_TOKEN, + rewards, + sender: ALICE, + }); + expect(tx.from).toEqual(ALICE); + expect(tx.to).toEqual(STAKE_TOKEN); + expectToBeDefined(tx.gasLimit); + expectToBeDefined(tx.data); + expect(tx.gasLimit.toString()).toEqual( + gasLimitRecommendations[ProtocolAction.umbrellaClaimSelectedRewards] + .recommended, + ); + const decoded = stakeTokenInterface.decodeFunctionData( + 'claimSelectedRewards(address,address[],address)', + tx.data, + ); + expect(decoded).toHaveLength(3); + expect(decoded[0]).toEqual(STAKE_TOKEN); + expect(decoded[1]).toEqual(rewards); + expect(decoded[2]).toEqual(ALICE); + }); + }); +}); diff --git a/packages/contract-helpers/src/umbrella/RewardsDistributor.ts b/packages/contract-helpers/src/umbrella/RewardsDistributor.ts new file mode 100644 index 00000000..0e63a705 --- /dev/null +++ b/packages/contract-helpers/src/umbrella/RewardsDistributor.ts @@ -0,0 +1,91 @@ +import { BigNumber, PopulatedTransaction } from 'ethers'; +import { ProtocolAction } from '../commons/types'; +import { gasLimitRecommendations } from '../commons/utils'; +import { IRewardsDistributorInterface } from './typechain/IRewardsDistributor'; +import { IRewardsDistributor__factory } from './typechain/IRewardsDistributor__factory'; + +interface RewardsDistributorClaimAllAvailableRewardsParams { + stakeTokens: string[]; + sender: string; +} + +interface RewardsDistributorClaimAllRewardsParams { + stakeToken: string; + sender: string; +} + +interface RewardsDistributorClaimSelectedRewardsParams { + stakeToken: string; + rewards: string[]; + sender: string; +} + +export class RewardsDistributorService { + private readonly interface: IRewardsDistributorInterface; + + constructor(private readonly rewardsDistributorAddress: string) { + this.interface = IRewardsDistributor__factory.createInterface(); + } + + // Claim all rewards across all stake tokens + claimAllAvailableRewards({ + stakeTokens, + sender, + }: RewardsDistributorClaimAllAvailableRewardsParams) { + const tx: PopulatedTransaction = {}; + const receiver = sender; + tx.data = this.interface.encodeFunctionData( + 'claimAllRewards(address[],address)', + [stakeTokens, receiver], + ); + tx.from = sender; + tx.to = this.rewardsDistributorAddress; + tx.gasLimit = BigNumber.from( + gasLimitRecommendations[ProtocolAction.umbrellaClaimAllRewards] + .recommended, + ); + return tx; + } + + // Claim all rewards for a specific stake token + claimAllRewards({ + stakeToken, + sender, + }: RewardsDistributorClaimAllRewardsParams) { + const tx: PopulatedTransaction = {}; + const receiver = sender; + const txData = this.interface.encodeFunctionData( + 'claimAllRewards(address,address)', + [stakeToken, receiver], + ); + tx.data = txData; + tx.from = sender; + tx.to = this.rewardsDistributorAddress; + tx.gasLimit = BigNumber.from( + gasLimitRecommendations[ProtocolAction.umbrellaClaimAllRewards] + .recommended, + ); + return tx; + } + + claimSelectedRewards({ + stakeToken, + rewards, + sender, + }: RewardsDistributorClaimSelectedRewardsParams) { + const tx: PopulatedTransaction = {}; + const receiver = sender; + const txData = this.interface.encodeFunctionData( + 'claimSelectedRewards(address,address[],address)', + [stakeToken, rewards, receiver], + ); + tx.data = txData; + tx.from = sender; + tx.to = this.rewardsDistributorAddress; + tx.gasLimit = BigNumber.from( + gasLimitRecommendations[ProtocolAction.umbrellaClaimSelectedRewards] + .recommended, + ); + return tx; + } +} diff --git a/packages/contract-helpers/src/umbrella/StakeDataProvider.test.ts b/packages/contract-helpers/src/umbrella/StakeDataProvider.test.ts new file mode 100644 index 00000000..81bab357 --- /dev/null +++ b/packages/contract-helpers/src/umbrella/StakeDataProvider.test.ts @@ -0,0 +1,168 @@ +import { BigNumber, providers } from 'ethers'; +import { + RewardStruct, + StakeDataStruct, + StakeUserDataStruct, + StataTokenDataStruct, +} from './typechain/StakeDataProvider'; +import { StakeDataProviderService } from './index'; + +const mockStataTokenData: StataTokenDataStruct = { + asset: '0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef', + assetName: 'Mock Stata Token Asset', + assetSymbol: 'MSTAT', + aToken: '0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef', + aTokenName: 'Mock Stata Token AToken', + aTokenSymbol: 'MSTATA', +}; + +const mockRewardData: RewardStruct = { + rewardAddress: '0xfeabcdefabcdefabcdefabcdefabcdefabcdef', + rewardName: 'Mock Reward Token', + rewardSymbol: 'MRT', + price: BigNumber.from('1000000'), + decimals: 18, + index: BigNumber.from('1000000000000000000'), + maxEmissionPerSecond: BigNumber.from('500000000000000'), + distributionEnd: BigNumber.from('1800000000'), + currentEmissionPerSecond: BigNumber.from('250000000000000'), + apy: BigNumber.from('500000000000000000'), +}; + +const mockStakeData: StakeDataStruct = { + tokenAddress: '0x1234567890abcdef1234567890abcdef12345678', + name: 'Mock Staking Token', + symbol: 'MST', + price: BigNumber.from('1000000000000000000'), + totalAssets: BigNumber.from('1000000000000000000000000'), + underlyingTokenAddress: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd', + underlyingTokenName: 'Mock Underlying Token', + underlyingTokenSymbol: 'MUT', + underlyingTokenDecimals: 18, + cooldownSeconds: BigNumber.from('86400'), + unstakeWindowSeconds: BigNumber.from('43200'), + underlyingIsStataToken: false, + stataTokenData: mockStataTokenData, + rewards: [mockRewardData], +}; + +export const mockStakeUserData: StakeUserDataStruct = { + stakeToken: '0x1234567890abcdef1234567890abcdef12345678', + stakeTokenName: 'Mock Staking Token', + balances: { + stakeTokenBalance: BigNumber.from('500000000000000000000'), + stakeTokenRedeemableAmount: BigNumber.from('200000000000000000000'), + underlyingTokenBalance: BigNumber.from('100000000000000000000'), + stataTokenAssetBalance: BigNumber.from('150000000000000000000'), + stataTokenATokenBalance: BigNumber.from('50000000000000000000'), + }, + cooldown: { + cooldownAmount: BigNumber.from('250000000000000000000'), + endOfCooldown: 1739822860, + withdrawalWindow: 7200, + }, + rewards: [ + '0xfeabcdefabcdefabcdefabcdefabcdefabcdef', + '0xcaabcdefabcdefabcdefabcdefabcdefabcdef', + ], + rewardsAccrued: [ + BigNumber.from('3000000000000000000'), + BigNumber.from('5000000000000000000'), + ], +}; + +describe('Umbrella StakeDataProvider', () => { + const mockAddress = '0x88757f2f99175387ab4c6a4b3067c77a695b0349'; + + const createService = () => { + const service = new StakeDataProviderService( + mockAddress, + new providers.JsonRpcProvider(), + ); + + const mockGetStakeData = jest.fn(); + const mockGetUserStakeData = jest.fn(); + + mockGetStakeData.mockResolvedValue([mockStakeData]); + mockGetUserStakeData.mockResolvedValue([mockStakeUserData]); + + // @ts-expect-error readonly + service._contract = { + getStakeData: mockGetStakeData, + getUserStakeData: mockGetUserStakeData, + }; + + return service; + }; + + it('should be defined', () => { + const service = createService(); + expect(service).toBeDefined(); + }); + + it('should fetch stake data', async () => { + const service = createService(); + const result = await service.getStakeData(); + expect(result).toEqual([mockStakeData]); + }); + + it('should fetch user stake data', async () => { + const service = createService(); + const result = await service.getUserStakeData(mockAddress); + expect(result).toEqual([mockStakeUserData]); + }); + + it('should fetch stake data humanized', async () => { + const service = createService(); + const result = await service.getStakeDataHumanized(); + expect(result[0]).toEqual({ + ...mockStakeData, + totalAssets: '1000000000000000000000000', + price: '1000000000000000000', + cooldownSeconds: 86400, + unstakeWindowSeconds: 43200, + rewards: [ + { + ...mockRewardData, + price: '1000000', + currentEmissionPerSecond: '250000000000000', + apy: '500000000000000000', + distributionEnd: '1800000000', + index: '1000000000000000000', + maxEmissionPerSecond: '500000000000000', + }, + ], + }); + }); + + it('should fetch user stake data humanized', async () => { + const service = createService(); + const result = await service.getUserStakeDataHumanized(mockAddress); + expect(result[0]).toEqual({ + stakeToken: mockStakeUserData.stakeToken, + stakeTokenName: mockStakeUserData.stakeTokenName, + balances: { + stakeTokenBalance: '500000000000000000000', + stakeTokenRedeemableAmount: '200000000000000000000', + underlyingTokenBalance: '100000000000000000000', + stataTokenAssetBalance: '150000000000000000000', + stataTokenATokenBalance: '50000000000000000000', + }, + cooldown: { + cooldownAmount: '250000000000000000000', + endOfCooldown: 1739822860, + withdrawalWindow: 7200, + }, + rewards: [ + { + accrued: '3000000000000000000', + rewardAddress: '0xfeabcdefabcdefabcdefabcdefabcdefabcdef', + }, + { + accrued: '5000000000000000000', + rewardAddress: '0xcaabcdefabcdefabcdefabcdefabcdefabcdef', + }, + ], + }); + }); +}); diff --git a/packages/contract-helpers/src/umbrella/StakeDataProvider.ts b/packages/contract-helpers/src/umbrella/StakeDataProvider.ts new file mode 100644 index 00000000..b71d2955 --- /dev/null +++ b/packages/contract-helpers/src/umbrella/StakeDataProvider.ts @@ -0,0 +1,153 @@ +import { providers } from 'ethers'; +import { StakeDataProvider } from './typechain/StakeDataProvider'; +import { StakeDataProvider__factory } from './typechain/StakeDataProvider__factory'; + +export interface StakeData { + tokenAddress: string; + name: string; + symbol: string; + price: string; + totalAssets: string; + underlyingTokenAddress: string; + underlyingTokenName: string; + underlyingTokenSymbol: string; + underlyingTokenDecimals: number; + cooldownSeconds: number; + unstakeWindowSeconds: number; + underlyingIsStataToken: boolean; + stataTokenData: StataTokenData; + rewards: Reward[]; +} + +export interface StataTokenData { + asset: string; + assetName: string; + assetSymbol: string; + aToken: string; + aTokenName: string; + aTokenSymbol: string; +} + +export interface Reward { + rewardAddress: string; + rewardName: string; + rewardSymbol: string; + price: string; + decimals: number; + index: string; + maxEmissionPerSecond: string; + distributionEnd: string; + currentEmissionPerSecond: string; + apy: string; +} + +export interface StakeUserData { + stakeToken: string; + stakeTokenName: string; + balances: StakeUserBalances; + cooldown: StakeUserCooldown; + rewards: UserRewards[]; +} + +export interface StakeUserBalances { + stakeTokenBalance: string; + stakeTokenRedeemableAmount: string; + underlyingTokenBalance: string; + stataTokenAssetBalance: string; + stataTokenATokenBalance: string; +} + +export interface StakeUserCooldown { + cooldownAmount: string; + endOfCooldown: number; + withdrawalWindow: number; +} + +export interface UserRewards { + rewardAddress: string; + accrued: string; +} + +export class StakeDataProviderService { + private readonly _contract: StakeDataProvider; + + constructor(stakeDataProviderAddress: string, provider: providers.Provider) { + this._contract = StakeDataProvider__factory.connect( + stakeDataProviderAddress, + provider, + ); + } + + public async getStakeData() { + const result = await this._contract.getStakeData(); + return result; + } + + public async getUserStakeData(user: string) { + const result = await this._contract.getUserStakeData(user); + return result; + } + + public async getStakeDataHumanized() { + const result = await this.getStakeData(); + return result.map(r => ({ + tokenAddress: r.tokenAddress, + name: r.name, + symbol: r.symbol, + price: r.price.toString(), + totalAssets: r.totalAssets.toString(), + underlyingTokenAddress: r.underlyingTokenAddress, + underlyingTokenName: r.underlyingTokenName, + underlyingTokenSymbol: r.underlyingTokenSymbol, + underlyingTokenDecimals: r.underlyingTokenDecimals, + cooldownSeconds: r.cooldownSeconds.toNumber(), + unstakeWindowSeconds: r.unstakeWindowSeconds.toNumber(), + underlyingIsStataToken: r.underlyingIsStataToken, + stataTokenData: { + asset: r.stataTokenData.asset, + assetName: r.stataTokenData.assetName, + assetSymbol: r.stataTokenData.assetSymbol, + aToken: r.stataTokenData.aToken, + aTokenName: r.stataTokenData.aTokenName, + aTokenSymbol: r.stataTokenData.aTokenSymbol, + }, + rewards: r.rewards.map(reward => ({ + rewardAddress: reward.rewardAddress, + rewardName: reward.rewardName, + rewardSymbol: reward.rewardSymbol, + price: reward.price.toString(), + decimals: reward.decimals, + index: reward.index.toString(), + maxEmissionPerSecond: reward.maxEmissionPerSecond.toString(), + distributionEnd: reward.distributionEnd.toString(), + currentEmissionPerSecond: reward.currentEmissionPerSecond.toString(), + apy: reward.apy.toString(), + })), + })); + } + + public async getUserStakeDataHumanized(user: string) { + const result = await this.getUserStakeData(user); + return result.map(r => ({ + stakeToken: r.stakeToken, + stakeTokenName: r.stakeTokenName, + balances: { + stakeTokenBalance: r.balances.stakeTokenBalance.toString(), + stakeTokenRedeemableAmount: + r.balances.stakeTokenRedeemableAmount.toString(), + underlyingTokenBalance: r.balances.underlyingTokenBalance.toString(), + stataTokenAssetBalance: r.balances.stataTokenAssetBalance.toString(), + stataTokenATokenBalance: r.balances.stataTokenATokenBalance.toString(), + }, + cooldown: { + cooldownAmount: r.cooldown.cooldownAmount.toString(), + endOfCooldown: r.cooldown.endOfCooldown, + withdrawalWindow: r.cooldown.withdrawalWindow, + }, + rewards: r.rewards.map((reward, index) => ({ + rewardAddress: reward, + accrued: r.rewardsAccrued[index].toString(), + })), + })); + } +} diff --git a/packages/contract-helpers/src/umbrella/StakeToken.test.ts b/packages/contract-helpers/src/umbrella/StakeToken.test.ts new file mode 100644 index 00000000..7894a8a8 --- /dev/null +++ b/packages/contract-helpers/src/umbrella/StakeToken.test.ts @@ -0,0 +1,135 @@ +import { BigNumber, Wallet } from 'ethers'; +import { splitSignature } from 'ethers/lib/utils'; +import { ProtocolAction } from '../commons/types'; +import { + expectToBeDefined, + gasLimitRecommendations, + generateEIP712PermitMock, + makePair, +} from '../commons/utils'; +import { IERC4626StakeToken } from './typechain/StakeToken'; +import { IERC4626StakeToken__factory } from './typechain/StakeToken__factory'; +import { StakeTokenService } from './'; + +describe('Umbrella Stake Token', () => { + const { address: STAKE_TOKEN } = makePair('STAKE_TOKEN'); + const { address: ALICE, privateKey: ALICE_PRIVATE_KEY } = makePair('ALICE'); + const aliceWallet = new Wallet(ALICE_PRIVATE_KEY); + const stakeTokenService = new StakeTokenService(STAKE_TOKEN); + const stakeTokenInterface = IERC4626StakeToken__factory.createInterface(); + + describe('cooldown', () => { + it('should properly create the transaction', () => { + const tx = stakeTokenService.cooldown({ sender: ALICE }); + expect(tx.from).toEqual(ALICE); + expect(tx.to).toEqual(STAKE_TOKEN); + expectToBeDefined(tx.gasLimit); + expect(tx.gasLimit.toString()).toEqual( + gasLimitRecommendations[ProtocolAction.umbrellaStakeTokenCooldown] + .recommended, + ); + expectToBeDefined(tx.data); + const decoded = stakeTokenInterface.decodeFunctionData( + 'cooldown', + tx.data, + ); + expect(decoded).toHaveLength(0); + }); + }); + describe('deposit', () => { + it('should properly create the transaction', () => { + const amount = '1337'; + const tx = stakeTokenService.deposit({ + amount, + sender: ALICE, + }); + expect(tx.from).toEqual(ALICE); + expect(tx.to).toEqual(STAKE_TOKEN); + expectToBeDefined(tx.gasLimit); + expect(tx.gasLimit.toString()).toEqual( + gasLimitRecommendations[ProtocolAction.umbrellaStakeTokenDeposit] + .recommended, + ); + expectToBeDefined(tx.data); + const decoded = stakeTokenInterface.decodeFunctionData( + 'deposit', + tx.data, + ) as [BigNumber, string]; + expect(decoded).toHaveLength(2); + expect(decoded[0].toString()).toEqual(amount); + expect(decoded[1]).toEqual(ALICE); + }); + }); + describe('depositWithPermit', () => { + it('should properly create the transaction', async () => { + const amount = '1337'; + const deadline = '1'; + const { domain, types, value } = generateEIP712PermitMock( + ALICE, + STAKE_TOKEN, + amount, + deadline, + ); + const signature = await aliceWallet._signTypedData(domain, types, value); + const tx = stakeTokenService.depositWithPermit({ + amount, + deadline, + permit: signature, + sender: ALICE, + }); + expect(tx.from).toEqual(ALICE); + expect(tx.to).toEqual(STAKE_TOKEN); + expectToBeDefined(tx.gasLimit); + expect(tx.gasLimit.toString()).toEqual( + gasLimitRecommendations[ + ProtocolAction.umbrellaStakeTokenDepositWithPermit + ].recommended, + ); + expectToBeDefined(tx.data); + const decoded = stakeTokenInterface.decodeFunctionData( + 'depositWithPermit', + tx.data, + ) as [ + BigNumber, + string, + BigNumber, + IERC4626StakeToken.SignatureParamsStruct, + ]; + expect(decoded).toHaveLength(4); + expect(decoded[0].toString()).toEqual(amount); + expect(decoded[1]).toEqual(ALICE); + expect(decoded[2].toString()).toEqual(deadline); + const splittedSignature = splitSignature(signature); + expect(decoded[3]).toMatchObject({ + v: splittedSignature.v, + r: splittedSignature.r, + s: splittedSignature.s, + }); + }); + }); + describe('redeem', () => { + it('should properly create the transaction', () => { + const amount = '1337'; + const tx = stakeTokenService.redeem({ + amount, + sender: ALICE, + }); + expect(tx.from).toEqual(ALICE); + expect(tx.to).toEqual(STAKE_TOKEN); + expectToBeDefined(tx.gasLimit); + expect(tx.gasLimit.toString()).toEqual( + gasLimitRecommendations[ProtocolAction.umbrellaStakeTokenRedeem] + .recommended, + ); + expectToBeDefined(tx.data); + const decoded = stakeTokenInterface.decodeFunctionData( + 'redeem', + tx.data, + ) as [BigNumber, string, string]; + expect(decoded).toHaveLength(3); + expect(decoded[0].toString()).toEqual(amount); + expect(decoded[1]).toEqual(ALICE); + expect(decoded[2]).toEqual(ALICE); + }); + }); +}); diff --git a/packages/contract-helpers/src/umbrella/StakeToken.ts b/packages/contract-helpers/src/umbrella/StakeToken.ts new file mode 100644 index 00000000..79adcad7 --- /dev/null +++ b/packages/contract-helpers/src/umbrella/StakeToken.ts @@ -0,0 +1,111 @@ +import { SignatureLike, splitSignature } from '@ethersproject/bytes'; +import { BigNumber, PopulatedTransaction } from 'ethers'; + +import { ProtocolAction } from '../commons/types'; +import { gasLimitRecommendations } from '../commons/utils'; +import { IERC4626StakeTokenInterface } from './typechain/StakeToken'; +import { IERC4626StakeToken__factory } from './typechain/StakeToken__factory'; + +interface StakeTokenCooldownParams { + sender: string; +} + +interface StakeTokenDepositParams { + amount: string; + sender: string; +} + +interface StakeTokenDepositWithPermitParams { + amount: string; + deadline: string; + permit: SignatureLike; + sender: string; +} + +interface StakeTokenRedeemParams { + amount: string; + sender: string; +} + +export class StakeTokenService { + private readonly interface: IERC4626StakeTokenInterface; + + constructor(private readonly stakeTokenAddress: string) { + this.interface = IERC4626StakeToken__factory.createInterface(); + } + + cooldown({ sender }: StakeTokenCooldownParams) { + const tx: PopulatedTransaction = {}; + const txData = this.interface.encodeFunctionData('cooldown'); + tx.data = txData; + tx.from = sender; + tx.to = this.stakeTokenAddress; + tx.gasLimit = BigNumber.from( + gasLimitRecommendations[ProtocolAction.umbrellaStakeTokenCooldown] + .recommended, + ); + return tx; + } + + deposit({ amount, sender }: StakeTokenDepositParams) { + const tx: PopulatedTransaction = {}; + const receiver = sender; + const txData = this.interface.encodeFunctionData('deposit', [ + amount, + receiver, + ]); + tx.data = txData; + tx.from = sender; + tx.to = this.stakeTokenAddress; + tx.gasLimit = BigNumber.from( + gasLimitRecommendations[ProtocolAction.umbrellaStakeTokenDeposit] + .recommended, + ); + return tx; + } + + depositWithPermit({ + amount, + deadline, + permit, + sender, + }: StakeTokenDepositWithPermitParams) { + const tx: PopulatedTransaction = {}; + const signature = splitSignature(permit); + const receiver = sender; + const txData = this.interface.encodeFunctionData('depositWithPermit', [ + amount, + receiver, + deadline, + { v: signature.v, r: signature.r, s: signature.s }, + ]); + tx.data = txData; + tx.from = sender; + tx.to = this.stakeTokenAddress; + tx.gasLimit = BigNumber.from( + gasLimitRecommendations[ + ProtocolAction.umbrellaStakeTokenDepositWithPermit + ].recommended, + ); + return tx; + } + + redeem({ amount, sender }: StakeTokenRedeemParams) { + const tx: PopulatedTransaction = {}; + const receiver = sender; + const owner = sender; + const txData = this.interface.encodeFunctionData('redeem', [ + amount, + receiver, + owner, + ]); + tx.data = txData; + tx.from = sender; + tx.to = this.stakeTokenAddress; + tx.gasLimit = BigNumber.from( + gasLimitRecommendations[ProtocolAction.umbrellaStakeTokenRedeem] + .recommended, + ); + return tx; + } +} diff --git a/packages/contract-helpers/src/umbrella/UmbrellaBatchHelper.test.ts b/packages/contract-helpers/src/umbrella/UmbrellaBatchHelper.test.ts new file mode 100644 index 00000000..1c4baefb --- /dev/null +++ b/packages/contract-helpers/src/umbrella/UmbrellaBatchHelper.test.ts @@ -0,0 +1,192 @@ +import { BigNumber, Wallet } from 'ethers'; +import { splitSignature } from 'ethers/lib/utils'; +import { ProtocolAction } from '../commons/types'; +import { + DEFAULT_MOCK_VERIFYING_CONTRACT, + expectToBeDefined, + gasLimitRecommendations, + generateEIP712PermitMock, + makePair, +} from '../commons/utils'; +import { IUmbrellaBatchHelper } from './typechain/UmbrellaBatchHelper'; +import { UmbrellaBatchHelper__factory } from './typechain/UmbrellaBatchHelper__factory'; +import { UmbrellaBatchHelperService } from './'; + +describe('UmbrellaBatchHelper', () => { + const { address: STAKE_TOKEN } = makePair('STAKE_TOKEN'); + const { address: ALICE, privateKey: ALICE_PRIVATE_KEY } = makePair('ALICE'); + const aliceWallet = new Wallet(ALICE_PRIVATE_KEY); + const batchHelperService = new UmbrellaBatchHelperService(STAKE_TOKEN); + const batchHelperInterface = UmbrellaBatchHelper__factory.createInterface(); + describe('deposit', () => { + it('should properly create the transaction', () => { + const amount = '1337'; + const tx = batchHelperService.deposit({ + sender: ALICE, + stakeToken: STAKE_TOKEN, + amount, + edgeToken: DEFAULT_MOCK_VERIFYING_CONTRACT, + }); + expect(tx.from).toEqual(ALICE); + expect(tx.to).toEqual(STAKE_TOKEN); + expectToBeDefined(tx.gasLimit); + expect(tx.gasLimit.toString()).toEqual( + gasLimitRecommendations[ProtocolAction.umbrellaStakeGatewayStake] + .recommended, + ); + const decoded = batchHelperInterface.decodeFunctionData( + 'deposit', + tx.data, + ) as [IUmbrellaBatchHelper.IODataStruct]; + expect(decoded).toHaveLength(1); + const struct = decoded[0]; + expect(struct.edgeToken).toEqual(DEFAULT_MOCK_VERIFYING_CONTRACT); + expect(struct.stakeToken).toEqual(STAKE_TOKEN); + expect(BigNumber.from(struct.value).toString()).toEqual(amount); + }); + }); + describe('depositWithPermit', () => { + it('should properly create the transaction', async () => { + const amount = '1337'; + const deadline = '1'; + const { domain, types, value } = generateEIP712PermitMock( + ALICE, + STAKE_TOKEN, + amount, + deadline, + ); + const signature = await aliceWallet._signTypedData(domain, types, value); + const tx = batchHelperService.depositWithPermit({ + sender: ALICE, + stakeToken: STAKE_TOKEN, + edgeToken: DEFAULT_MOCK_VERIFYING_CONTRACT, + amount, + deadline, + permit: signature, + }); + expect(tx.from).toEqual(ALICE); + expect(tx.to).toEqual(STAKE_TOKEN); + expect(tx.gasLimit.toString()).toEqual( + gasLimitRecommendations[ + ProtocolAction.umbrellaStakeGatewayStakeWithPermit + ].recommended, + ); + const decoded = batchHelperInterface.decodeFunctionData( + 'multicall', + tx.data, + ) as [string, string]; + expect(decoded).toHaveLength(1); + const tx1 = decoded[0][0]; + const tx1Decoded = batchHelperInterface.decodeFunctionData( + 'permit', + tx1, + ) as [IUmbrellaBatchHelper.PermitStruct]; + expect(tx1Decoded).toHaveLength(1); + const permitStruct = tx1Decoded[0]; + expect(permitStruct.token).toEqual(DEFAULT_MOCK_VERIFYING_CONTRACT); + expect(BigNumber.from(permitStruct.value).toString()).toEqual(amount); + expect(BigNumber.from(permitStruct.deadline).toString()).toEqual( + deadline, + ); + const splittedSignature = splitSignature(signature); + expect(permitStruct.v).toEqual(splittedSignature.v); + expect(permitStruct.r).toEqual(splittedSignature.r); + expect(permitStruct.s).toEqual(splittedSignature.s); + const tx2 = decoded[0][1]; + const tx2Decoded = batchHelperInterface.decodeFunctionData( + 'deposit', + tx2, + ) as [IUmbrellaBatchHelper.IODataStruct]; + expect(tx2Decoded).toHaveLength(1); + const struct = tx2Decoded[0]; + expect(struct.edgeToken).toEqual(DEFAULT_MOCK_VERIFYING_CONTRACT); + expect(struct.stakeToken).toEqual(STAKE_TOKEN); + expect(BigNumber.from(struct.value).toString()).toEqual(amount); + }); + }); + describe('redeem', () => { + it('should properly create the transaction', () => { + const amount = '1337'; + const tx = batchHelperService.redeem({ + sender: ALICE, + stakeToken: STAKE_TOKEN, + edgeToken: DEFAULT_MOCK_VERIFYING_CONTRACT, + amount, + }); + expect(tx.from).toEqual(ALICE); + expect(tx.to).toEqual(STAKE_TOKEN); + expect(tx.gasLimit.toString()).toEqual( + gasLimitRecommendations[ProtocolAction.umbrellaStakeGatewayRedeem] + .recommended, + ); + const decoded = batchHelperInterface.decodeFunctionData( + 'redeem', + tx.data, + ) as [IUmbrellaBatchHelper.IODataStruct]; + expect(decoded).toHaveLength(1); + const struct = decoded[0]; + expect(struct.edgeToken).toEqual(DEFAULT_MOCK_VERIFYING_CONTRACT); + expect(struct.stakeToken).toEqual(STAKE_TOKEN); + expect(BigNumber.from(struct.value).toString()).toEqual(amount); + }); + }); + describe('redeemWithPermit', () => { + it('should properly create the transaction', async () => { + const amount = '1337'; + const deadline = '1'; + const { domain, types, value } = generateEIP712PermitMock( + ALICE, + STAKE_TOKEN, + amount, + deadline, + ); + const signature = await aliceWallet._signTypedData(domain, types, value); + const tx = batchHelperService.redeemWithPermit({ + sender: ALICE, + stakeToken: STAKE_TOKEN, + edgeToken: DEFAULT_MOCK_VERIFYING_CONTRACT, + amount, + deadline, + permit: signature, + }); + expect(tx.from).toEqual(ALICE); + expect(tx.to).toEqual(STAKE_TOKEN); + expect(tx.gasLimit.toString()).toEqual( + gasLimitRecommendations[ + ProtocolAction.umbrellaStakeGatewayStakeWithPermit + ].recommended, + ); + const decoded = batchHelperInterface.decodeFunctionData( + 'multicall', + tx.data, + ) as [string, string]; + expect(decoded).toHaveLength(1); + const tx1 = decoded[0][0]; + const tx1Decoded = batchHelperInterface.decodeFunctionData( + 'permit', + tx1, + ) as [IUmbrellaBatchHelper.PermitStruct]; + expect(tx1Decoded).toHaveLength(1); + const permitStruct = tx1Decoded[0]; + expect(permitStruct.token).toEqual(DEFAULT_MOCK_VERIFYING_CONTRACT); + expect(BigNumber.from(permitStruct.value).toString()).toEqual(amount); + expect(BigNumber.from(permitStruct.deadline).toString()).toEqual( + deadline, + ); + const splittedSignature = splitSignature(signature); + expect(permitStruct.v).toEqual(splittedSignature.v); + expect(permitStruct.r).toEqual(splittedSignature.r); + expect(permitStruct.s).toEqual(splittedSignature.s); + const tx2 = decoded[0][1]; + const tx2Decoded = batchHelperInterface.decodeFunctionData( + 'redeem', + tx2, + ) as [IUmbrellaBatchHelper.IODataStruct]; + expect(tx2Decoded).toHaveLength(1); + const struct = tx2Decoded[0]; + expect(struct.edgeToken).toEqual(DEFAULT_MOCK_VERIFYING_CONTRACT); + expect(struct.stakeToken).toEqual(STAKE_TOKEN); + expect(BigNumber.from(struct.value).toString()).toEqual(amount); + }); + }); +}); diff --git a/packages/contract-helpers/src/umbrella/UmbrellaBatchHelper.ts b/packages/contract-helpers/src/umbrella/UmbrellaBatchHelper.ts new file mode 100644 index 00000000..7cdab48c --- /dev/null +++ b/packages/contract-helpers/src/umbrella/UmbrellaBatchHelper.ts @@ -0,0 +1,183 @@ +import { SignatureLike, splitSignature } from '@ethersproject/bytes'; +import { BigNumber } from 'ethers'; + +import { DefinedPopulatedTransaction, ProtocolAction } from '../commons/types'; +import { gasLimitRecommendations } from '../commons/utils'; +import { UmbrellaBatchHelperInterface } from './typechain/UmbrellaBatchHelper'; +import { UmbrellaBatchHelper__factory } from './typechain/UmbrellaBatchHelper__factory'; + +interface BatchHelperBaseParams { + sender: string; + stakeToken: string; + amount: string; + edgeToken: string; +} + +interface BatchHelperPermitParams { + deadline: string; + permit: SignatureLike; +} + +type UmbrellaBatchHelperDepositParams = BatchHelperBaseParams; + +type UmbrellaBatchHelperDepositWithPermitParams = BatchHelperBaseParams & + BatchHelperPermitParams; + +type UmbrellaBatchHelperRedeemParams = BatchHelperBaseParams; + +type UmbrellaBatchHelperRedeemWithPermitParams = BatchHelperBaseParams & + BatchHelperPermitParams; + +export class UmbrellaBatchHelperService { + private readonly interface: UmbrellaBatchHelperInterface; + + constructor(private readonly umbrellaBatchHelperAddress: string) { + this.interface = UmbrellaBatchHelper__factory.createInterface(); + } + + deposit({ + sender, + stakeToken, + amount, + edgeToken, + }: UmbrellaBatchHelperDepositParams) { + const txData = this.interface.encodeFunctionData('deposit', [ + { + edgeToken, + stakeToken, + value: amount, + }, + ]); + const data = txData; + const from = sender; + const to = this.umbrellaBatchHelperAddress; + const gasLimit = BigNumber.from( + gasLimitRecommendations[ProtocolAction.umbrellaStakeGatewayStake] + .recommended, + ); + const tx: DefinedPopulatedTransaction = { + data, + from, + to, + gasLimit, + }; + return tx; + } + + depositWithPermit({ + sender, + edgeToken, + stakeToken, + amount, + deadline, + permit, + }: UmbrellaBatchHelperDepositWithPermitParams) { + const signature = splitSignature(permit); + const permitTxData = this.interface.encodeFunctionData('permit', [ + { + token: edgeToken, + value: amount, + deadline, + v: signature.v, + r: signature.r, + s: signature.s, + }, + ]); + const { data: depositTxData } = this.deposit({ + sender, + stakeToken, + amount, + edgeToken, + }); + const txData = this.interface.encodeFunctionData('multicall', [ + [permitTxData, depositTxData], + ]); + const data = txData; + const from = sender; + const to = this.umbrellaBatchHelperAddress; + const gasLimit = BigNumber.from( + gasLimitRecommendations[ProtocolAction.umbrellaStakeGatewayStake] + .recommended, + ); + const tx: DefinedPopulatedTransaction = { + data, + from, + to, + gasLimit, + }; + return tx; + } + + redeem({ + sender, + stakeToken, + amount, + edgeToken, + }: UmbrellaBatchHelperRedeemParams) { + const txData = this.interface.encodeFunctionData('redeem', [ + { + edgeToken, + stakeToken, + value: amount, + }, + ]); + const data = txData; + const from = sender; + const to = this.umbrellaBatchHelperAddress; + const gasLimit = BigNumber.from( + gasLimitRecommendations[ProtocolAction.umbrellaStakeGatewayRedeem] + .recommended, + ); + const tx: DefinedPopulatedTransaction = { + data, + from, + to, + gasLimit, + }; + return tx; + } + + redeemWithPermit({ + sender, + edgeToken, + stakeToken, + amount, + deadline, + permit, + }: UmbrellaBatchHelperRedeemWithPermitParams) { + const signature = splitSignature(permit); + const permitTxData = this.interface.encodeFunctionData('permit', [ + { + token: edgeToken, + value: amount, + deadline, + v: signature.v, + r: signature.r, + s: signature.s, + }, + ]); + const { data: redeemTxData } = this.redeem({ + sender, + stakeToken, + amount, + edgeToken, + }); + const txData = this.interface.encodeFunctionData('multicall', [ + [permitTxData, redeemTxData], + ]); + const data = txData; + const from = sender; + const to = this.umbrellaBatchHelperAddress; + const gasLimit = BigNumber.from( + gasLimitRecommendations[ProtocolAction.umbrellaStakeGatewayStake] + .recommended, + ); + const tx: DefinedPopulatedTransaction = { + data, + from, + to, + gasLimit, + }; + return tx; + } +} diff --git a/packages/contract-helpers/src/umbrella/index.ts b/packages/contract-helpers/src/umbrella/index.ts new file mode 100644 index 00000000..4de339e5 --- /dev/null +++ b/packages/contract-helpers/src/umbrella/index.ts @@ -0,0 +1,4 @@ +export { StakeTokenService } from './StakeToken'; +export { RewardsDistributorService } from './RewardsDistributor'; +export { UmbrellaBatchHelperService } from './UmbrellaBatchHelper'; +export * from './StakeDataProvider'; diff --git a/packages/contract-helpers/src/umbrella/typechain/IRewardsDistributor.ts b/packages/contract-helpers/src/umbrella/typechain/IRewardsDistributor.ts new file mode 100644 index 00000000..2c52358b --- /dev/null +++ b/packages/contract-helpers/src/umbrella/typechain/IRewardsDistributor.ts @@ -0,0 +1,709 @@ +/* Autogenerated file. Do not edit manually. */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from 'ethers'; +import type { + FunctionFragment, + Result, + EventFragment, +} from '@ethersproject/abi'; +import type { Listener, Provider } from '@ethersproject/providers'; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, +} from './common'; + +export declare namespace IRewardsStructs { + export type SignatureParamsStruct = { + v: BigNumberish; + r: BytesLike; + s: BytesLike; + }; + + export type SignatureParamsStructOutput = [number, string, string] & { + v: number; + r: string; + s: string; + }; +} + +export interface IRewardsDistributorInterface extends utils.Interface { + functions: { + 'claimAllRewards(address,address)': FunctionFragment; + 'claimAllRewards(address[],address)': FunctionFragment; + 'claimAllRewardsOnBehalf(address[],address,address)': FunctionFragment; + 'claimAllRewardsOnBehalf(address,address,address)': FunctionFragment; + 'claimAllRewardsPermit(address,address,address,uint256,(uint8,bytes32,bytes32))': FunctionFragment; + 'claimSelectedRewards(address[],address[][],address)': FunctionFragment; + 'claimSelectedRewards(address,address[],address)': FunctionFragment; + 'claimSelectedRewardsOnBehalf(address,address[],address,address)': FunctionFragment; + 'claimSelectedRewardsOnBehalf(address[],address[][],address,address)': FunctionFragment; + 'claimSelectedRewardsPermit(address,address[],address,address,uint256,(uint8,bytes32,bytes32))': FunctionFragment; + 'setClaimer(address,bool)': FunctionFragment; + 'setClaimer(address,address,bool)': FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | 'claimAllRewards(address,address)' + | 'claimAllRewards(address[],address)' + | 'claimAllRewardsOnBehalf(address[],address,address)' + | 'claimAllRewardsOnBehalf(address,address,address)' + | 'claimAllRewardsPermit' + | 'claimSelectedRewards(address[],address[][],address)' + | 'claimSelectedRewards(address,address[],address)' + | 'claimSelectedRewardsOnBehalf(address,address[],address,address)' + | 'claimSelectedRewardsOnBehalf(address[],address[][],address,address)' + | 'claimSelectedRewardsPermit' + | 'setClaimer(address,bool)' + | 'setClaimer(address,address,bool)', + ): FunctionFragment; + + encodeFunctionData( + functionFragment: 'claimAllRewards(address,address)', + values: [string, string], + ): string; + encodeFunctionData( + functionFragment: 'claimAllRewards(address[],address)', + values: [string[], string], + ): string; + encodeFunctionData( + functionFragment: 'claimAllRewardsOnBehalf(address[],address,address)', + values: [string[], string, string], + ): string; + encodeFunctionData( + functionFragment: 'claimAllRewardsOnBehalf(address,address,address)', + values: [string, string, string], + ): string; + encodeFunctionData( + functionFragment: 'claimAllRewardsPermit', + values: [ + string, + string, + string, + BigNumberish, + IRewardsStructs.SignatureParamsStruct, + ], + ): string; + encodeFunctionData( + functionFragment: 'claimSelectedRewards(address[],address[][],address)', + values: [string[], string[][], string], + ): string; + encodeFunctionData( + functionFragment: 'claimSelectedRewards(address,address[],address)', + values: [string, string[], string], + ): string; + encodeFunctionData( + functionFragment: 'claimSelectedRewardsOnBehalf(address,address[],address,address)', + values: [string, string[], string, string], + ): string; + encodeFunctionData( + functionFragment: 'claimSelectedRewardsOnBehalf(address[],address[][],address,address)', + values: [string[], string[][], string, string], + ): string; + encodeFunctionData( + functionFragment: 'claimSelectedRewardsPermit', + values: [ + string, + string[], + string, + string, + BigNumberish, + IRewardsStructs.SignatureParamsStruct, + ], + ): string; + encodeFunctionData( + functionFragment: 'setClaimer(address,bool)', + values: [string, boolean], + ): string; + encodeFunctionData( + functionFragment: 'setClaimer(address,address,bool)', + values: [string, string, boolean], + ): string; + + decodeFunctionResult( + functionFragment: 'claimAllRewards(address,address)', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'claimAllRewards(address[],address)', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'claimAllRewardsOnBehalf(address[],address,address)', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'claimAllRewardsOnBehalf(address,address,address)', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'claimAllRewardsPermit', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'claimSelectedRewards(address[],address[][],address)', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'claimSelectedRewards(address,address[],address)', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'claimSelectedRewardsOnBehalf(address,address[],address,address)', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'claimSelectedRewardsOnBehalf(address[],address[][],address,address)', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'claimSelectedRewardsPermit', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'setClaimer(address,bool)', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'setClaimer(address,address,bool)', + data: BytesLike, + ): Result; + + events: { + 'ClaimerSet(address,address,address,bool)': EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: 'ClaimerSet'): EventFragment; +} + +export interface ClaimerSetEventObject { + user: string; + claimer: string; + caller: string; + flag: boolean; +} +export type ClaimerSetEvent = TypedEvent< + [string, string, string, boolean], + ClaimerSetEventObject +>; + +export type ClaimerSetEventFilter = TypedEventFilter; + +export interface IRewardsDistributor extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IRewardsDistributorInterface; + + 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: { + 'claimAllRewards(address,address)'( + asset: string, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimAllRewards(address[],address)'( + assets: string[], + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimAllRewardsOnBehalf(address[],address,address)'( + assets: string[], + user: string, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimAllRewardsOnBehalf(address,address,address)'( + asset: string, + user: string, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + claimAllRewardsPermit( + asset: string, + user: string, + receiver: string, + deadline: BigNumberish, + sig: IRewardsStructs.SignatureParamsStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimSelectedRewards(address[],address[][],address)'( + assets: string[], + rewards: string[][], + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimSelectedRewards(address,address[],address)'( + asset: string, + rewards: string[], + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimSelectedRewardsOnBehalf(address,address[],address,address)'( + asset: string, + rewards: string[], + user: string, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimSelectedRewardsOnBehalf(address[],address[][],address,address)'( + assets: string[], + rewards: string[][], + user: string, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + claimSelectedRewardsPermit( + asset: string, + rewards: string[], + user: string, + receiver: string, + deadline: BigNumberish, + sig: IRewardsStructs.SignatureParamsStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'setClaimer(address,bool)'( + claimer: string, + flag: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'setClaimer(address,address,bool)'( + user: string, + claimer: string, + flag: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + }; + + 'claimAllRewards(address,address)'( + asset: string, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimAllRewards(address[],address)'( + assets: string[], + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimAllRewardsOnBehalf(address[],address,address)'( + assets: string[], + user: string, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimAllRewardsOnBehalf(address,address,address)'( + asset: string, + user: string, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + claimAllRewardsPermit( + asset: string, + user: string, + receiver: string, + deadline: BigNumberish, + sig: IRewardsStructs.SignatureParamsStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimSelectedRewards(address[],address[][],address)'( + assets: string[], + rewards: string[][], + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimSelectedRewards(address,address[],address)'( + asset: string, + rewards: string[], + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimSelectedRewardsOnBehalf(address,address[],address,address)'( + asset: string, + rewards: string[], + user: string, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimSelectedRewardsOnBehalf(address[],address[][],address,address)'( + assets: string[], + rewards: string[][], + user: string, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + claimSelectedRewardsPermit( + asset: string, + rewards: string[], + user: string, + receiver: string, + deadline: BigNumberish, + sig: IRewardsStructs.SignatureParamsStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'setClaimer(address,bool)'( + claimer: string, + flag: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'setClaimer(address,address,bool)'( + user: string, + claimer: string, + flag: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + callStatic: { + 'claimAllRewards(address,address)'( + asset: string, + receiver: string, + overrides?: CallOverrides, + ): Promise< + [string[], BigNumber[]] & { rewards: string[]; amounts: BigNumber[] } + >; + + 'claimAllRewards(address[],address)'( + assets: string[], + receiver: string, + overrides?: CallOverrides, + ): Promise< + [string[][], BigNumber[][]] & { + rewards: string[][]; + amounts: BigNumber[][]; + } + >; + + 'claimAllRewardsOnBehalf(address[],address,address)'( + assets: string[], + user: string, + receiver: string, + overrides?: CallOverrides, + ): Promise< + [string[][], BigNumber[][]] & { + rewards: string[][]; + amounts: BigNumber[][]; + } + >; + + 'claimAllRewardsOnBehalf(address,address,address)'( + asset: string, + user: string, + receiver: string, + overrides?: CallOverrides, + ): Promise< + [string[], BigNumber[]] & { rewards: string[]; amounts: BigNumber[] } + >; + + claimAllRewardsPermit( + asset: string, + user: string, + receiver: string, + deadline: BigNumberish, + sig: IRewardsStructs.SignatureParamsStruct, + overrides?: CallOverrides, + ): Promise< + [string[], BigNumber[]] & { rewards: string[]; amounts: BigNumber[] } + >; + + 'claimSelectedRewards(address[],address[][],address)'( + assets: string[], + rewards: string[][], + receiver: string, + overrides?: CallOverrides, + ): Promise; + + 'claimSelectedRewards(address,address[],address)'( + asset: string, + rewards: string[], + receiver: string, + overrides?: CallOverrides, + ): Promise; + + 'claimSelectedRewardsOnBehalf(address,address[],address,address)'( + asset: string, + rewards: string[], + user: string, + receiver: string, + overrides?: CallOverrides, + ): Promise; + + 'claimSelectedRewardsOnBehalf(address[],address[][],address,address)'( + assets: string[], + rewards: string[][], + user: string, + receiver: string, + overrides?: CallOverrides, + ): Promise; + + claimSelectedRewardsPermit( + asset: string, + rewards: string[], + user: string, + receiver: string, + deadline: BigNumberish, + sig: IRewardsStructs.SignatureParamsStruct, + overrides?: CallOverrides, + ): Promise; + + 'setClaimer(address,bool)'( + claimer: string, + flag: boolean, + overrides?: CallOverrides, + ): Promise; + + 'setClaimer(address,address,bool)'( + user: string, + claimer: string, + flag: boolean, + overrides?: CallOverrides, + ): Promise; + }; + + filters: { + 'ClaimerSet(address,address,address,bool)'( + user?: string | null, + claimer?: string | null, + caller?: string | null, + flag?: null, + ): ClaimerSetEventFilter; + ClaimerSet( + user?: string | null, + claimer?: string | null, + caller?: string | null, + flag?: null, + ): ClaimerSetEventFilter; + }; + + estimateGas: { + 'claimAllRewards(address,address)'( + asset: string, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimAllRewards(address[],address)'( + assets: string[], + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimAllRewardsOnBehalf(address[],address,address)'( + assets: string[], + user: string, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimAllRewardsOnBehalf(address,address,address)'( + asset: string, + user: string, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + claimAllRewardsPermit( + asset: string, + user: string, + receiver: string, + deadline: BigNumberish, + sig: IRewardsStructs.SignatureParamsStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimSelectedRewards(address[],address[][],address)'( + assets: string[], + rewards: string[][], + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimSelectedRewards(address,address[],address)'( + asset: string, + rewards: string[], + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimSelectedRewardsOnBehalf(address,address[],address,address)'( + asset: string, + rewards: string[], + user: string, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimSelectedRewardsOnBehalf(address[],address[][],address,address)'( + assets: string[], + rewards: string[][], + user: string, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + claimSelectedRewardsPermit( + asset: string, + rewards: string[], + user: string, + receiver: string, + deadline: BigNumberish, + sig: IRewardsStructs.SignatureParamsStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'setClaimer(address,bool)'( + claimer: string, + flag: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'setClaimer(address,address,bool)'( + user: string, + claimer: string, + flag: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + }; + + populateTransaction: { + 'claimAllRewards(address,address)'( + asset: string, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimAllRewards(address[],address)'( + assets: string[], + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimAllRewardsOnBehalf(address[],address,address)'( + assets: string[], + user: string, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimAllRewardsOnBehalf(address,address,address)'( + asset: string, + user: string, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + claimAllRewardsPermit( + asset: string, + user: string, + receiver: string, + deadline: BigNumberish, + sig: IRewardsStructs.SignatureParamsStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimSelectedRewards(address[],address[][],address)'( + assets: string[], + rewards: string[][], + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimSelectedRewards(address,address[],address)'( + asset: string, + rewards: string[], + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimSelectedRewardsOnBehalf(address,address[],address,address)'( + asset: string, + rewards: string[], + user: string, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'claimSelectedRewardsOnBehalf(address[],address[][],address,address)'( + assets: string[], + rewards: string[][], + user: string, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + claimSelectedRewardsPermit( + asset: string, + rewards: string[], + user: string, + receiver: string, + deadline: BigNumberish, + sig: IRewardsStructs.SignatureParamsStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'setClaimer(address,bool)'( + claimer: string, + flag: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + 'setClaimer(address,address,bool)'( + user: string, + claimer: string, + flag: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + }; +} diff --git a/packages/contract-helpers/src/umbrella/typechain/IRewardsDistributor__factory.ts b/packages/contract-helpers/src/umbrella/typechain/IRewardsDistributor__factory.ts new file mode 100644 index 00000000..8f2e3591 --- /dev/null +++ b/packages/contract-helpers/src/umbrella/typechain/IRewardsDistributor__factory.ts @@ -0,0 +1,524 @@ +/* Autogenerated file. Do not edit manually. */ +/* eslint-disable */ + +import { Contract, Signer, utils } from 'ethers'; +import type { Provider } from '@ethersproject/providers'; +import type { + IRewardsDistributor, + IRewardsDistributorInterface, +} from './IRewardsDistributor'; + +const _abi = [ + { + type: 'function', + name: 'claimAllRewards', + inputs: [ + { + name: 'asset', + type: 'address', + internalType: 'address', + }, + { + name: 'receiver', + type: 'address', + internalType: 'address', + }, + ], + outputs: [ + { + name: 'rewards', + type: 'address[]', + internalType: 'address[]', + }, + { + name: 'amounts', + type: 'uint256[]', + internalType: 'uint256[]', + }, + ], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'claimAllRewards', + inputs: [ + { + name: 'assets', + type: 'address[]', + internalType: 'address[]', + }, + { + name: 'receiver', + type: 'address', + internalType: 'address', + }, + ], + outputs: [ + { + name: 'rewards', + type: 'address[][]', + internalType: 'address[][]', + }, + { + name: 'amounts', + type: 'uint256[][]', + internalType: 'uint256[][]', + }, + ], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'claimAllRewardsOnBehalf', + inputs: [ + { + name: 'assets', + type: 'address[]', + internalType: 'address[]', + }, + { + name: 'user', + type: 'address', + internalType: 'address', + }, + { + name: 'receiver', + type: 'address', + internalType: 'address', + }, + ], + outputs: [ + { + name: 'rewards', + type: 'address[][]', + internalType: 'address[][]', + }, + { + name: 'amounts', + type: 'uint256[][]', + internalType: 'uint256[][]', + }, + ], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'claimAllRewardsOnBehalf', + inputs: [ + { + name: 'asset', + type: 'address', + internalType: 'address', + }, + { + name: 'user', + type: 'address', + internalType: 'address', + }, + { + name: 'receiver', + type: 'address', + internalType: 'address', + }, + ], + outputs: [ + { + name: 'rewards', + type: 'address[]', + internalType: 'address[]', + }, + { + name: 'amounts', + type: 'uint256[]', + internalType: 'uint256[]', + }, + ], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'claimAllRewardsPermit', + inputs: [ + { + name: 'asset', + type: 'address', + internalType: 'address', + }, + { + name: 'user', + type: 'address', + internalType: 'address', + }, + { + name: 'receiver', + type: 'address', + internalType: 'address', + }, + { + name: 'deadline', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'sig', + type: 'tuple', + internalType: 'struct IRewardsStructs.SignatureParams', + components: [ + { + name: 'v', + type: 'uint8', + internalType: 'uint8', + }, + { + name: 'r', + type: 'bytes32', + internalType: 'bytes32', + }, + { + name: 's', + type: 'bytes32', + internalType: 'bytes32', + }, + ], + }, + ], + outputs: [ + { + name: 'rewards', + type: 'address[]', + internalType: 'address[]', + }, + { + name: 'amounts', + type: 'uint256[]', + internalType: 'uint256[]', + }, + ], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'claimSelectedRewards', + inputs: [ + { + name: 'assets', + type: 'address[]', + internalType: 'address[]', + }, + { + name: 'rewards', + type: 'address[][]', + internalType: 'address[][]', + }, + { + name: 'receiver', + type: 'address', + internalType: 'address', + }, + ], + outputs: [ + { + name: '', + type: 'uint256[][]', + internalType: 'uint256[][]', + }, + ], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'claimSelectedRewards', + inputs: [ + { + name: 'asset', + type: 'address', + internalType: 'address', + }, + { + name: 'rewards', + type: 'address[]', + internalType: 'address[]', + }, + { + name: 'receiver', + type: 'address', + internalType: 'address', + }, + ], + outputs: [ + { + name: 'amounts', + type: 'uint256[]', + internalType: 'uint256[]', + }, + ], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'claimSelectedRewardsOnBehalf', + inputs: [ + { + name: 'asset', + type: 'address', + internalType: 'address', + }, + { + name: 'rewards', + type: 'address[]', + internalType: 'address[]', + }, + { + name: 'user', + type: 'address', + internalType: 'address', + }, + { + name: 'receiver', + type: 'address', + internalType: 'address', + }, + ], + outputs: [ + { + name: 'amounts', + type: 'uint256[]', + internalType: 'uint256[]', + }, + ], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'claimSelectedRewardsOnBehalf', + inputs: [ + { + name: 'assets', + type: 'address[]', + internalType: 'address[]', + }, + { + name: 'rewards', + type: 'address[][]', + internalType: 'address[][]', + }, + { + name: 'user', + type: 'address', + internalType: 'address', + }, + { + name: 'receiver', + type: 'address', + internalType: 'address', + }, + ], + outputs: [ + { + name: '', + type: 'uint256[][]', + internalType: 'uint256[][]', + }, + ], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'claimSelectedRewardsPermit', + inputs: [ + { + name: 'asset', + type: 'address', + internalType: 'address', + }, + { + name: 'rewards', + type: 'address[]', + internalType: 'address[]', + }, + { + name: 'user', + type: 'address', + internalType: 'address', + }, + { + name: 'receiver', + type: 'address', + internalType: 'address', + }, + { + name: 'deadline', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'sig', + type: 'tuple', + internalType: 'struct IRewardsStructs.SignatureParams', + components: [ + { + name: 'v', + type: 'uint8', + internalType: 'uint8', + }, + { + name: 'r', + type: 'bytes32', + internalType: 'bytes32', + }, + { + name: 's', + type: 'bytes32', + internalType: 'bytes32', + }, + ], + }, + ], + outputs: [ + { + name: 'amounts', + type: 'uint256[]', + internalType: 'uint256[]', + }, + ], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'setClaimer', + inputs: [ + { + name: 'claimer', + type: 'address', + internalType: 'address', + }, + { + name: 'flag', + type: 'bool', + internalType: 'bool', + }, + ], + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'setClaimer', + inputs: [ + { + name: 'user', + type: 'address', + internalType: 'address', + }, + { + name: 'claimer', + type: 'address', + internalType: 'address', + }, + { + name: 'flag', + type: 'bool', + internalType: 'bool', + }, + ], + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'event', + name: 'ClaimerSet', + inputs: [ + { + name: 'user', + type: 'address', + indexed: true, + internalType: 'address', + }, + { + name: 'claimer', + type: 'address', + indexed: true, + internalType: 'address', + }, + { + name: 'caller', + type: 'address', + indexed: true, + internalType: 'address', + }, + { + name: 'flag', + type: 'bool', + indexed: false, + internalType: 'bool', + }, + ], + anonymous: false, + }, + { + type: 'error', + name: 'ClaimerNotAuthorized', + inputs: [ + { + name: 'claimer', + type: 'address', + internalType: 'address', + }, + { + name: 'user', + type: 'address', + internalType: 'address', + }, + ], + }, + { + type: 'error', + name: 'ExpiredSignature', + inputs: [ + { + name: 'deadline', + type: 'uint256', + internalType: 'uint256', + }, + ], + }, + { + type: 'error', + name: 'InvalidSigner', + inputs: [ + { + name: 'signer', + type: 'address', + internalType: 'address', + }, + { + name: 'owner', + type: 'address', + internalType: 'address', + }, + ], + }, + { + type: 'error', + name: 'LengthsDontMatch', + inputs: [], + }, + { + type: 'error', + name: 'ZeroAddress', + inputs: [], + }, +] as const; + +export class IRewardsDistributor__factory { + static readonly abi = _abi; + static createInterface(): IRewardsDistributorInterface { + return new utils.Interface(_abi) as IRewardsDistributorInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider, + ): IRewardsDistributor { + return new Contract(address, _abi, signerOrProvider) as IRewardsDistributor; + } +} diff --git a/packages/contract-helpers/src/umbrella/typechain/StakeDataProvider.ts b/packages/contract-helpers/src/umbrella/typechain/StakeDataProvider.ts new file mode 100644 index 00000000..0f09bb08 --- /dev/null +++ b/packages/contract-helpers/src/umbrella/typechain/StakeDataProvider.ts @@ -0,0 +1,366 @@ +/* Autogenerated file. Do not edit manually. */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + PopulatedTransaction, + Signer, + utils, +} from 'ethers'; +import type { FunctionFragment, Result } from '@ethersproject/abi'; +import type { Listener, Provider } from '@ethersproject/providers'; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, +} from './common'; + +export type StataTokenDataStruct = { + asset: string; + assetName: string; + assetSymbol: string; + aToken: string; + aTokenName: string; + aTokenSymbol: string; +}; + +export type StataTokenDataStructOutput = [ + string, + string, + string, + string, + string, + string, +] & { + asset: string; + assetName: string; + assetSymbol: string; + aToken: string; + aTokenName: string; + aTokenSymbol: string; +}; + +export type RewardStruct = { + rewardAddress: string; + rewardName: string; + rewardSymbol: string; + price: BigNumberish; + decimals: BigNumberish; + index: BigNumberish; + maxEmissionPerSecond: BigNumberish; + distributionEnd: BigNumberish; + currentEmissionPerSecond: BigNumberish; + apy: BigNumberish; +}; + +export type RewardStructOutput = [ + string, + string, + string, + BigNumber, + number, + BigNumber, + BigNumber, + BigNumber, + BigNumber, + BigNumber, +] & { + rewardAddress: string; + rewardName: string; + rewardSymbol: string; + price: BigNumber; + decimals: number; + index: BigNumber; + maxEmissionPerSecond: BigNumber; + distributionEnd: BigNumber; + currentEmissionPerSecond: BigNumber; + apy: BigNumber; +}; + +export type StakeDataStruct = { + tokenAddress: string; + name: string; + symbol: string; + price: BigNumberish; + totalAssets: BigNumberish; + underlyingTokenAddress: string; + underlyingTokenName: string; + underlyingTokenSymbol: string; + underlyingTokenDecimals: BigNumberish; + cooldownSeconds: BigNumberish; + unstakeWindowSeconds: BigNumberish; + underlyingIsStataToken: boolean; + stataTokenData: StataTokenDataStruct; + rewards: RewardStruct[]; +}; + +export type StakeDataStructOutput = [ + string, + string, + string, + BigNumber, + BigNumber, + string, + string, + string, + number, + BigNumber, + BigNumber, + boolean, + StataTokenDataStructOutput, + RewardStructOutput[], +] & { + tokenAddress: string; + name: string; + symbol: string; + price: BigNumber; + totalAssets: BigNumber; + underlyingTokenAddress: string; + underlyingTokenName: string; + underlyingTokenSymbol: string; + underlyingTokenDecimals: number; + cooldownSeconds: BigNumber; + unstakeWindowSeconds: BigNumber; + underlyingIsStataToken: boolean; + stataTokenData: StataTokenDataStructOutput; + rewards: RewardStructOutput[]; +}; + +export type StakeUserBalancesStruct = { + stakeTokenBalance: BigNumberish; + stakeTokenRedeemableAmount: BigNumberish; + underlyingTokenBalance: BigNumberish; + stataTokenAssetBalance: BigNumberish; + stataTokenATokenBalance: BigNumberish; +}; + +export type StakeUserBalancesStructOutput = [ + BigNumber, + BigNumber, + BigNumber, + BigNumber, + BigNumber, +] & { + stakeTokenBalance: BigNumber; + stakeTokenRedeemableAmount: BigNumber; + underlyingTokenBalance: BigNumber; + stataTokenAssetBalance: BigNumber; + stataTokenATokenBalance: BigNumber; +}; + +export type StakeUserCooldownStruct = { + cooldownAmount: BigNumberish; + endOfCooldown: BigNumberish; + withdrawalWindow: BigNumberish; +}; + +export type StakeUserCooldownStructOutput = [BigNumber, number, number] & { + cooldownAmount: BigNumber; + endOfCooldown: number; + withdrawalWindow: number; +}; + +export type StakeUserDataStruct = { + stakeToken: string; + stakeTokenName: string; + balances: StakeUserBalancesStruct; + cooldown: StakeUserCooldownStruct; + rewards: string[]; + rewardsAccrued: BigNumberish[]; +}; + +export type StakeUserDataStructOutput = [ + string, + string, + StakeUserBalancesStructOutput, + StakeUserCooldownStructOutput, + string[], + BigNumber[], +] & { + stakeToken: string; + stakeTokenName: string; + balances: StakeUserBalancesStructOutput; + cooldown: StakeUserCooldownStructOutput; + rewards: string[]; + rewardsAccrued: BigNumber[]; +}; + +export interface StakeDataProviderInterface extends utils.Interface { + functions: { + 'aaveOracle()': FunctionFragment; + 'getStakeData()': FunctionFragment; + 'getUserStakeData(address)': FunctionFragment; + 'rewardsController()': FunctionFragment; + 'stataTokenFactory()': FunctionFragment; + 'umbrella()': FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | 'aaveOracle' + | 'getStakeData' + | 'getUserStakeData' + | 'rewardsController' + | 'stataTokenFactory' + | 'umbrella', + ): FunctionFragment; + + encodeFunctionData( + functionFragment: 'aaveOracle', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'getStakeData', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'getUserStakeData', + values: [string], + ): string; + encodeFunctionData( + functionFragment: 'rewardsController', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'stataTokenFactory', + values?: undefined, + ): string; + encodeFunctionData(functionFragment: 'umbrella', values?: undefined): string; + + decodeFunctionResult(functionFragment: 'aaveOracle', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'getStakeData', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'getUserStakeData', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'rewardsController', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'stataTokenFactory', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'umbrella', data: BytesLike): Result; + + events: {}; +} + +export interface StakeDataProvider extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: StakeDataProviderInterface; + + 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: { + aaveOracle(overrides?: CallOverrides): Promise<[string]>; + + getStakeData(overrides?: CallOverrides): Promise<[StakeDataStructOutput[]]>; + + getUserStakeData( + user: string, + overrides?: CallOverrides, + ): Promise<[StakeUserDataStructOutput[]]>; + + rewardsController(overrides?: CallOverrides): Promise<[string]>; + + stataTokenFactory(overrides?: CallOverrides): Promise<[string]>; + + umbrella(overrides?: CallOverrides): Promise<[string]>; + }; + + aaveOracle(overrides?: CallOverrides): Promise; + + getStakeData(overrides?: CallOverrides): Promise; + + getUserStakeData( + user: string, + overrides?: CallOverrides, + ): Promise; + + rewardsController(overrides?: CallOverrides): Promise; + + stataTokenFactory(overrides?: CallOverrides): Promise; + + umbrella(overrides?: CallOverrides): Promise; + + callStatic: { + aaveOracle(overrides?: CallOverrides): Promise; + + getStakeData(overrides?: CallOverrides): Promise; + + getUserStakeData( + user: string, + overrides?: CallOverrides, + ): Promise; + + rewardsController(overrides?: CallOverrides): Promise; + + stataTokenFactory(overrides?: CallOverrides): Promise; + + umbrella(overrides?: CallOverrides): Promise; + }; + + filters: {}; + + estimateGas: { + aaveOracle(overrides?: CallOverrides): Promise; + + getStakeData(overrides?: CallOverrides): Promise; + + getUserStakeData( + user: string, + overrides?: CallOverrides, + ): Promise; + + rewardsController(overrides?: CallOverrides): Promise; + + stataTokenFactory(overrides?: CallOverrides): Promise; + + umbrella(overrides?: CallOverrides): Promise; + }; + + populateTransaction: { + aaveOracle(overrides?: CallOverrides): Promise; + + getStakeData(overrides?: CallOverrides): Promise; + + getUserStakeData( + user: string, + overrides?: CallOverrides, + ): Promise; + + rewardsController(overrides?: CallOverrides): Promise; + + stataTokenFactory(overrides?: CallOverrides): Promise; + + umbrella(overrides?: CallOverrides): Promise; + }; +} diff --git a/packages/contract-helpers/src/umbrella/typechain/StakeDataProvider__factory.ts b/packages/contract-helpers/src/umbrella/typechain/StakeDataProvider__factory.ts new file mode 100644 index 00000000..68b9cc38 --- /dev/null +++ b/packages/contract-helpers/src/umbrella/typechain/StakeDataProvider__factory.ts @@ -0,0 +1,423 @@ +/* Autogenerated file. Do not edit manually. */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from 'ethers'; +import type { Provider, TransactionRequest } from '@ethersproject/providers'; +import type { + StakeDataProvider, + StakeDataProviderInterface, +} from './StakeDataProvider'; + +const _abi = [ + { + type: 'constructor', + inputs: [ + { + name: '_umbrella', + type: 'address', + internalType: 'contract IUmbrellaStkManager', + }, + { + name: '_rewardsController', + type: 'address', + internalType: 'contract IRewardsController', + }, + { + name: '_stataTokenFactory', + type: 'address', + internalType: 'contract IStataTokenFactory', + }, + { + name: '_aaveOracle', + type: 'address', + internalType: 'contract IAaveOracle', + }, + ], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'aaveOracle', + inputs: [], + outputs: [ + { + name: '', + type: 'address', + internalType: 'contract IAaveOracle', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'getStakeData', + inputs: [], + outputs: [ + { + name: '', + type: 'tuple[]', + internalType: 'struct StakeData[]', + components: [ + { + name: 'tokenAddress', + type: 'address', + internalType: 'address', + }, + { + name: 'name', + type: 'string', + internalType: 'string', + }, + { + name: 'symbol', + type: 'string', + internalType: 'string', + }, + { + name: 'price', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'totalAssets', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'underlyingTokenAddress', + type: 'address', + internalType: 'address', + }, + { + name: 'underlyingTokenName', + type: 'string', + internalType: 'string', + }, + { + name: 'underlyingTokenSymbol', + type: 'string', + internalType: 'string', + }, + { + name: 'underlyingTokenDecimals', + type: 'uint8', + internalType: 'uint8', + }, + { + name: 'cooldownSeconds', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'unstakeWindowSeconds', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'underlyingIsStataToken', + type: 'bool', + internalType: 'bool', + }, + { + name: 'stataTokenData', + type: 'tuple', + internalType: 'struct StataTokenData', + components: [ + { + name: 'asset', + type: 'address', + internalType: 'address', + }, + { + name: 'assetName', + type: 'string', + internalType: 'string', + }, + { + name: 'assetSymbol', + type: 'string', + internalType: 'string', + }, + { + name: 'aToken', + type: 'address', + internalType: 'address', + }, + { + name: 'aTokenName', + type: 'string', + internalType: 'string', + }, + { + name: 'aTokenSymbol', + type: 'string', + internalType: 'string', + }, + ], + }, + { + name: 'rewards', + type: 'tuple[]', + internalType: 'struct Reward[]', + components: [ + { + name: 'rewardAddress', + type: 'address', + internalType: 'address', + }, + { + name: 'rewardName', + type: 'string', + internalType: 'string', + }, + { + name: 'rewardSymbol', + type: 'string', + internalType: 'string', + }, + { + name: 'price', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'decimals', + type: 'uint8', + internalType: 'uint8', + }, + { + name: 'index', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'maxEmissionPerSecond', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'distributionEnd', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'currentEmissionPerSecond', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'apy', + type: 'uint256', + internalType: 'uint256', + }, + ], + }, + ], + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'getUserStakeData', + inputs: [ + { + name: 'user', + type: 'address', + internalType: 'address', + }, + ], + outputs: [ + { + name: '', + type: 'tuple[]', + internalType: 'struct StakeUserData[]', + components: [ + { + name: 'stakeToken', + type: 'address', + internalType: 'address', + }, + { + name: 'stakeTokenName', + type: 'string', + internalType: 'string', + }, + { + name: 'balances', + type: 'tuple', + internalType: 'struct StakeUserBalances', + components: [ + { + name: 'stakeTokenBalance', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'stakeTokenRedeemableAmount', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'underlyingTokenBalance', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'stataTokenAssetBalance', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'stataTokenATokenBalance', + type: 'uint256', + internalType: 'uint256', + }, + ], + }, + { + name: 'cooldown', + type: 'tuple', + internalType: 'struct StakeUserCooldown', + components: [ + { + name: 'cooldownAmount', + type: 'uint192', + internalType: 'uint192', + }, + { + name: 'endOfCooldown', + type: 'uint32', + internalType: 'uint32', + }, + { + name: 'withdrawalWindow', + type: 'uint32', + internalType: 'uint32', + }, + ], + }, + { + name: 'rewards', + type: 'address[]', + internalType: 'address[]', + }, + { + name: 'rewardsAccrued', + type: 'uint256[]', + internalType: 'uint256[]', + }, + ], + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'rewardsController', + inputs: [], + outputs: [ + { + name: '', + type: 'address', + internalType: 'contract IRewardsController', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'stataTokenFactory', + inputs: [], + outputs: [ + { + name: '', + type: 'address', + internalType: 'contract IStataTokenFactory', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'umbrella', + inputs: [], + outputs: [ + { + name: '', + type: 'address', + internalType: 'contract IUmbrellaStkManager', + }, + ], + stateMutability: 'view', + }, +] as const; + +const _bytecode = + '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'; + +type StakeDataProviderConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: StakeDataProviderConstructorParams, +): xs is ConstructorParameters => xs.length > 1; + +export class StakeDataProvider__factory extends ContractFactory { + constructor(...args: StakeDataProviderConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + _umbrella: string, + _rewardsController: string, + _stataTokenFactory: string, + _aaveOracle: string, + overrides?: Overrides & { from?: string }, + ): Promise { + return super.deploy( + _umbrella, + _rewardsController, + _stataTokenFactory, + _aaveOracle, + overrides || {}, + ) as Promise; + } + override getDeployTransaction( + _umbrella: string, + _rewardsController: string, + _stataTokenFactory: string, + _aaveOracle: string, + overrides?: Overrides & { from?: string }, + ): TransactionRequest { + return super.getDeployTransaction( + _umbrella, + _rewardsController, + _stataTokenFactory, + _aaveOracle, + overrides || {}, + ); + } + override attach(address: string): StakeDataProvider { + return super.attach(address) as StakeDataProvider; + } + override connect(signer: Signer): StakeDataProvider__factory { + return super.connect(signer) as StakeDataProvider__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): StakeDataProviderInterface { + return new utils.Interface(_abi) as StakeDataProviderInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider, + ): StakeDataProvider { + return new Contract(address, _abi, signerOrProvider) as StakeDataProvider; + } +} diff --git a/packages/contract-helpers/src/umbrella/typechain/StakeToken.ts b/packages/contract-helpers/src/umbrella/typechain/StakeToken.ts new file mode 100644 index 00000000..757a810f --- /dev/null +++ b/packages/contract-helpers/src/umbrella/typechain/StakeToken.ts @@ -0,0 +1,1583 @@ +/* Autogenerated file. Do not edit manually. */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from 'ethers'; +import type { + FunctionFragment, + Result, + EventFragment, +} from '@ethersproject/abi'; +import type { Listener, Provider } from '@ethersproject/providers'; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, +} from './common'; + +export declare namespace IERC4626StakeToken { + export type SignatureParamsStruct = { + v: BigNumberish; + r: BytesLike; + s: BytesLike; + }; + + export type SignatureParamsStructOutput = [number, string, string] & { + v: number; + r: string; + s: string; + }; + + export type CooldownSnapshotStruct = { + amount: BigNumberish; + endOfCooldown: BigNumberish; + withdrawalWindow: BigNumberish; + }; + + export type CooldownSnapshotStructOutput = [BigNumber, number, number] & { + amount: BigNumber; + endOfCooldown: number; + withdrawalWindow: number; + }; +} + +export interface IERC4626StakeTokenInterface extends utils.Interface { + functions: { + 'MIN_ASSETS_REMAINING()': FunctionFragment; + 'allowance(address,address)': FunctionFragment; + 'approve(address,uint256)': FunctionFragment; + 'asset()': FunctionFragment; + 'balanceOf(address)': FunctionFragment; + 'convertToAssets(uint256)': FunctionFragment; + 'convertToShares(uint256)': FunctionFragment; + 'cooldown()': FunctionFragment; + 'cooldownNonces(address)': FunctionFragment; + 'cooldownOnBehalfOf(address)': FunctionFragment; + 'cooldownWithPermit(address,uint256,(uint8,bytes32,bytes32))': FunctionFragment; + 'decimals()': FunctionFragment; + 'deposit(uint256,address)': FunctionFragment; + 'depositWithPermit(uint256,address,uint256,(uint8,bytes32,bytes32))': FunctionFragment; + 'getCooldown()': FunctionFragment; + 'getMaxSlashableAssets()': FunctionFragment; + 'getStakerCooldown(address)': FunctionFragment; + 'getUnstakeWindow()': FunctionFragment; + 'isCooldownOperator(address,address)': FunctionFragment; + 'maxDeposit(address)': FunctionFragment; + 'maxMint(address)': FunctionFragment; + 'maxRedeem(address)': FunctionFragment; + 'maxWithdraw(address)': FunctionFragment; + 'mint(uint256,address)': FunctionFragment; + 'name()': FunctionFragment; + 'pause()': FunctionFragment; + 'previewDeposit(uint256)': FunctionFragment; + 'previewMint(uint256)': FunctionFragment; + 'previewRedeem(uint256)': FunctionFragment; + 'previewWithdraw(uint256)': FunctionFragment; + 'redeem(uint256,address,address)': FunctionFragment; + 'setCooldown(uint256)': FunctionFragment; + 'setCooldownOperator(address,bool)': FunctionFragment; + 'setUnstakeWindow(uint256)': FunctionFragment; + 'slash(address,uint256)': FunctionFragment; + 'symbol()': FunctionFragment; + 'totalAssets()': FunctionFragment; + 'totalSupply()': FunctionFragment; + 'transfer(address,uint256)': FunctionFragment; + 'transferFrom(address,address,uint256)': FunctionFragment; + 'unpause()': FunctionFragment; + 'withdraw(uint256,address,address)': FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | 'MIN_ASSETS_REMAINING' + | 'allowance' + | 'approve' + | 'asset' + | 'balanceOf' + | 'convertToAssets' + | 'convertToShares' + | 'cooldown' + | 'cooldownNonces' + | 'cooldownOnBehalfOf' + | 'cooldownWithPermit' + | 'decimals' + | 'deposit' + | 'depositWithPermit' + | 'getCooldown' + | 'getMaxSlashableAssets' + | 'getStakerCooldown' + | 'getUnstakeWindow' + | 'isCooldownOperator' + | 'maxDeposit' + | 'maxMint' + | 'maxRedeem' + | 'maxWithdraw' + | 'mint' + | 'name' + | 'pause' + | 'previewDeposit' + | 'previewMint' + | 'previewRedeem' + | 'previewWithdraw' + | 'redeem' + | 'setCooldown' + | 'setCooldownOperator' + | 'setUnstakeWindow' + | 'slash' + | 'symbol' + | 'totalAssets' + | 'totalSupply' + | 'transfer' + | 'transferFrom' + | 'unpause' + | 'withdraw', + ): FunctionFragment; + + encodeFunctionData( + functionFragment: 'MIN_ASSETS_REMAINING', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'allowance', + values: [string, string], + ): string; + encodeFunctionData( + functionFragment: 'approve', + values: [string, BigNumberish], + ): string; + encodeFunctionData(functionFragment: 'asset', values?: undefined): string; + encodeFunctionData(functionFragment: 'balanceOf', values: [string]): string; + encodeFunctionData( + functionFragment: 'convertToAssets', + values: [BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'convertToShares', + values: [BigNumberish], + ): string; + encodeFunctionData(functionFragment: 'cooldown', values?: undefined): string; + encodeFunctionData( + functionFragment: 'cooldownNonces', + values: [string], + ): string; + encodeFunctionData( + functionFragment: 'cooldownOnBehalfOf', + values: [string], + ): string; + encodeFunctionData( + functionFragment: 'cooldownWithPermit', + values: [string, BigNumberish, IERC4626StakeToken.SignatureParamsStruct], + ): string; + encodeFunctionData(functionFragment: 'decimals', values?: undefined): string; + encodeFunctionData( + functionFragment: 'deposit', + values: [BigNumberish, string], + ): string; + encodeFunctionData( + functionFragment: 'depositWithPermit', + values: [ + BigNumberish, + string, + BigNumberish, + IERC4626StakeToken.SignatureParamsStruct, + ], + ): string; + encodeFunctionData( + functionFragment: 'getCooldown', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'getMaxSlashableAssets', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'getStakerCooldown', + values: [string], + ): string; + encodeFunctionData( + functionFragment: 'getUnstakeWindow', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'isCooldownOperator', + values: [string, string], + ): string; + encodeFunctionData(functionFragment: 'maxDeposit', values: [string]): string; + encodeFunctionData(functionFragment: 'maxMint', values: [string]): string; + encodeFunctionData(functionFragment: 'maxRedeem', values: [string]): string; + encodeFunctionData(functionFragment: 'maxWithdraw', values: [string]): string; + encodeFunctionData( + functionFragment: 'mint', + values: [BigNumberish, string], + ): string; + encodeFunctionData(functionFragment: 'name', values?: undefined): string; + encodeFunctionData(functionFragment: 'pause', values?: undefined): string; + encodeFunctionData( + functionFragment: 'previewDeposit', + values: [BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'previewMint', + values: [BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'previewRedeem', + values: [BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'previewWithdraw', + values: [BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'redeem', + values: [BigNumberish, string, string], + ): string; + encodeFunctionData( + functionFragment: 'setCooldown', + values: [BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'setCooldownOperator', + values: [string, boolean], + ): string; + encodeFunctionData( + functionFragment: 'setUnstakeWindow', + values: [BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'slash', + values: [string, BigNumberish], + ): string; + encodeFunctionData(functionFragment: 'symbol', values?: undefined): string; + encodeFunctionData( + functionFragment: 'totalAssets', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'totalSupply', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'transfer', + values: [string, BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'transferFrom', + values: [string, string, BigNumberish], + ): string; + encodeFunctionData(functionFragment: 'unpause', values?: undefined): string; + encodeFunctionData( + functionFragment: 'withdraw', + values: [BigNumberish, string, string], + ): string; + + decodeFunctionResult( + functionFragment: 'MIN_ASSETS_REMAINING', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'allowance', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'approve', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'asset', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'balanceOf', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'convertToAssets', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'convertToShares', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'cooldown', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'cooldownNonces', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'cooldownOnBehalfOf', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'cooldownWithPermit', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'decimals', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'deposit', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'depositWithPermit', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'getCooldown', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'getMaxSlashableAssets', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'getStakerCooldown', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'getUnstakeWindow', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'isCooldownOperator', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'maxDeposit', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'maxMint', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'maxRedeem', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'maxWithdraw', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'mint', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'name', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'pause', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'previewDeposit', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'previewMint', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'previewRedeem', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'previewWithdraw', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'redeem', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'setCooldown', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'setCooldownOperator', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'setUnstakeWindow', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'slash', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'symbol', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'totalAssets', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'totalSupply', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'transfer', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'transferFrom', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'unpause', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'withdraw', data: BytesLike): Result; + + events: { + 'Approval(address,address,uint256)': EventFragment; + 'CooldownChanged(uint256,uint256)': EventFragment; + 'CooldownOperatorSet(address,address,bool)': EventFragment; + 'Deposit(address,address,uint256,uint256)': EventFragment; + 'Slashed(address,uint256)': EventFragment; + 'StakerCooldownUpdated(address,uint256,uint256,uint256)': EventFragment; + 'Transfer(address,address,uint256)': EventFragment; + 'UnstakeWindowChanged(uint256,uint256)': EventFragment; + 'Withdraw(address,address,address,uint256,uint256)': EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: 'Approval'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'CooldownChanged'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'CooldownOperatorSet'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Deposit'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Slashed'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'StakerCooldownUpdated'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Transfer'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'UnstakeWindowChanged'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Withdraw'): EventFragment; +} + +export interface ApprovalEventObject { + owner: string; + spender: string; + value: BigNumber; +} +export type ApprovalEvent = TypedEvent< + [string, string, BigNumber], + ApprovalEventObject +>; + +export type ApprovalEventFilter = TypedEventFilter; + +export interface CooldownChangedEventObject { + oldCooldown: BigNumber; + newCooldown: BigNumber; +} +export type CooldownChangedEvent = TypedEvent< + [BigNumber, BigNumber], + CooldownChangedEventObject +>; + +export type CooldownChangedEventFilter = TypedEventFilter; + +export interface CooldownOperatorSetEventObject { + user: string; + operator: string; + flag: boolean; +} +export type CooldownOperatorSetEvent = TypedEvent< + [string, string, boolean], + CooldownOperatorSetEventObject +>; + +export type CooldownOperatorSetEventFilter = + TypedEventFilter; + +export interface DepositEventObject { + sender: string; + owner: string; + assets: BigNumber; + shares: BigNumber; +} +export type DepositEvent = TypedEvent< + [string, string, BigNumber, BigNumber], + DepositEventObject +>; + +export type DepositEventFilter = TypedEventFilter; + +export interface SlashedEventObject { + destination: string; + amount: BigNumber; +} +export type SlashedEvent = TypedEvent<[string, BigNumber], SlashedEventObject>; + +export type SlashedEventFilter = TypedEventFilter; + +export interface StakerCooldownUpdatedEventObject { + user: string; + amount: BigNumber; + endOfCooldown: BigNumber; + unstakeWindow: BigNumber; +} +export type StakerCooldownUpdatedEvent = TypedEvent< + [string, BigNumber, BigNumber, BigNumber], + StakerCooldownUpdatedEventObject +>; + +export type StakerCooldownUpdatedEventFilter = + TypedEventFilter; + +export interface TransferEventObject { + from: string; + to: string; + value: BigNumber; +} +export type TransferEvent = TypedEvent< + [string, string, BigNumber], + TransferEventObject +>; + +export type TransferEventFilter = TypedEventFilter; + +export interface UnstakeWindowChangedEventObject { + oldUnstakeWindow: BigNumber; + newUnstakeWindow: BigNumber; +} +export type UnstakeWindowChangedEvent = TypedEvent< + [BigNumber, BigNumber], + UnstakeWindowChangedEventObject +>; + +export type UnstakeWindowChangedEventFilter = + TypedEventFilter; + +export interface WithdrawEventObject { + sender: string; + receiver: string; + owner: string; + assets: BigNumber; + shares: BigNumber; +} +export type WithdrawEvent = TypedEvent< + [string, string, string, BigNumber, BigNumber], + WithdrawEventObject +>; + +export type WithdrawEventFilter = TypedEventFilter; + +export interface IERC4626StakeToken extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IERC4626StakeTokenInterface; + + 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: { + MIN_ASSETS_REMAINING(overrides?: CallOverrides): Promise<[BigNumber]>; + + allowance( + owner: string, + spender: string, + overrides?: CallOverrides, + ): Promise<[BigNumber]>; + + approve( + spender: string, + value: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + asset( + overrides?: CallOverrides, + ): Promise<[string] & { assetTokenAddress: string }>; + + balanceOf(account: string, overrides?: CallOverrides): Promise<[BigNumber]>; + + convertToAssets( + shares: BigNumberish, + overrides?: CallOverrides, + ): Promise<[BigNumber] & { assets: BigNumber }>; + + convertToShares( + assets: BigNumberish, + overrides?: CallOverrides, + ): Promise<[BigNumber] & { shares: BigNumber }>; + + cooldown( + overrides?: Overrides & { from?: string }, + ): Promise; + + cooldownNonces( + owner: string, + overrides?: CallOverrides, + ): Promise<[BigNumber]>; + + cooldownOnBehalfOf( + from: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + cooldownWithPermit( + user: string, + deadline: BigNumberish, + sig: IERC4626StakeToken.SignatureParamsStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + decimals(overrides?: CallOverrides): Promise<[number]>; + + deposit( + assets: BigNumberish, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + depositWithPermit( + assets: BigNumberish, + receiver: string, + deadline: BigNumberish, + sig: IERC4626StakeToken.SignatureParamsStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + getCooldown(overrides?: CallOverrides): Promise<[BigNumber]>; + + getMaxSlashableAssets(overrides?: CallOverrides): Promise<[BigNumber]>; + + getStakerCooldown( + user: string, + overrides?: CallOverrides, + ): Promise<[IERC4626StakeToken.CooldownSnapshotStructOutput]>; + + getUnstakeWindow(overrides?: CallOverrides): Promise<[BigNumber]>; + + isCooldownOperator( + user: string, + operator: string, + overrides?: CallOverrides, + ): Promise<[boolean]>; + + maxDeposit( + receiver: string, + overrides?: CallOverrides, + ): Promise<[BigNumber] & { maxAssets: BigNumber }>; + + maxMint( + receiver: string, + overrides?: CallOverrides, + ): Promise<[BigNumber] & { maxShares: BigNumber }>; + + maxRedeem( + owner: string, + overrides?: CallOverrides, + ): Promise<[BigNumber] & { maxShares: BigNumber }>; + + maxWithdraw( + owner: string, + overrides?: CallOverrides, + ): Promise<[BigNumber] & { maxAssets: BigNumber }>; + + mint( + shares: BigNumberish, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + name(overrides?: CallOverrides): Promise<[string]>; + + pause( + overrides?: Overrides & { from?: string }, + ): Promise; + + previewDeposit( + assets: BigNumberish, + overrides?: CallOverrides, + ): Promise<[BigNumber] & { shares: BigNumber }>; + + previewMint( + shares: BigNumberish, + overrides?: CallOverrides, + ): Promise<[BigNumber] & { assets: BigNumber }>; + + previewRedeem( + shares: BigNumberish, + overrides?: CallOverrides, + ): Promise<[BigNumber] & { assets: BigNumber }>; + + previewWithdraw( + assets: BigNumberish, + overrides?: CallOverrides, + ): Promise<[BigNumber] & { shares: BigNumber }>; + + redeem( + shares: BigNumberish, + receiver: string, + owner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + setCooldown( + cooldown: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setCooldownOperator( + operator: string, + flag: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setUnstakeWindow( + newUnstakeWindow: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + slash( + destination: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + symbol(overrides?: CallOverrides): Promise<[string]>; + + totalAssets( + overrides?: CallOverrides, + ): Promise<[BigNumber] & { totalManagedAssets: BigNumber }>; + + totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>; + + transfer( + to: string, + value: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferFrom( + from: string, + to: string, + value: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + unpause( + overrides?: Overrides & { from?: string }, + ): Promise; + + withdraw( + assets: BigNumberish, + receiver: string, + owner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + }; + + MIN_ASSETS_REMAINING(overrides?: CallOverrides): Promise; + + allowance( + owner: string, + spender: string, + overrides?: CallOverrides, + ): Promise; + + approve( + spender: string, + value: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + asset(overrides?: CallOverrides): Promise; + + balanceOf(account: string, overrides?: CallOverrides): Promise; + + convertToAssets( + shares: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + convertToShares( + assets: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + cooldown( + overrides?: Overrides & { from?: string }, + ): Promise; + + cooldownNonces(owner: string, overrides?: CallOverrides): Promise; + + cooldownOnBehalfOf( + from: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + cooldownWithPermit( + user: string, + deadline: BigNumberish, + sig: IERC4626StakeToken.SignatureParamsStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + deposit( + assets: BigNumberish, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + depositWithPermit( + assets: BigNumberish, + receiver: string, + deadline: BigNumberish, + sig: IERC4626StakeToken.SignatureParamsStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + getCooldown(overrides?: CallOverrides): Promise; + + getMaxSlashableAssets(overrides?: CallOverrides): Promise; + + getStakerCooldown( + user: string, + overrides?: CallOverrides, + ): Promise; + + getUnstakeWindow(overrides?: CallOverrides): Promise; + + isCooldownOperator( + user: string, + operator: string, + overrides?: CallOverrides, + ): Promise; + + maxDeposit(receiver: string, overrides?: CallOverrides): Promise; + + maxMint(receiver: string, overrides?: CallOverrides): Promise; + + maxRedeem(owner: string, overrides?: CallOverrides): Promise; + + maxWithdraw(owner: string, overrides?: CallOverrides): Promise; + + mint( + shares: BigNumberish, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + name(overrides?: CallOverrides): Promise; + + pause( + overrides?: Overrides & { from?: string }, + ): Promise; + + previewDeposit( + assets: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + previewMint( + shares: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + previewRedeem( + shares: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + previewWithdraw( + assets: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + redeem( + shares: BigNumberish, + receiver: string, + owner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + setCooldown( + cooldown: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setCooldownOperator( + operator: string, + flag: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setUnstakeWindow( + newUnstakeWindow: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + slash( + destination: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalAssets(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: string, + value: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferFrom( + from: string, + to: string, + value: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + unpause( + overrides?: Overrides & { from?: string }, + ): Promise; + + withdraw( + assets: BigNumberish, + receiver: string, + owner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + callStatic: { + MIN_ASSETS_REMAINING(overrides?: CallOverrides): Promise; + + allowance( + owner: string, + spender: string, + overrides?: CallOverrides, + ): Promise; + + approve( + spender: string, + value: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + asset(overrides?: CallOverrides): Promise; + + balanceOf(account: string, overrides?: CallOverrides): Promise; + + convertToAssets( + shares: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + convertToShares( + assets: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + cooldown(overrides?: CallOverrides): Promise; + + cooldownNonces( + owner: string, + overrides?: CallOverrides, + ): Promise; + + cooldownOnBehalfOf(from: string, overrides?: CallOverrides): Promise; + + cooldownWithPermit( + user: string, + deadline: BigNumberish, + sig: IERC4626StakeToken.SignatureParamsStruct, + overrides?: CallOverrides, + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + deposit( + assets: BigNumberish, + receiver: string, + overrides?: CallOverrides, + ): Promise; + + depositWithPermit( + assets: BigNumberish, + receiver: string, + deadline: BigNumberish, + sig: IERC4626StakeToken.SignatureParamsStruct, + overrides?: CallOverrides, + ): Promise; + + getCooldown(overrides?: CallOverrides): Promise; + + getMaxSlashableAssets(overrides?: CallOverrides): Promise; + + getStakerCooldown( + user: string, + overrides?: CallOverrides, + ): Promise; + + getUnstakeWindow(overrides?: CallOverrides): Promise; + + isCooldownOperator( + user: string, + operator: string, + overrides?: CallOverrides, + ): Promise; + + maxDeposit(receiver: string, overrides?: CallOverrides): Promise; + + maxMint(receiver: string, overrides?: CallOverrides): Promise; + + maxRedeem(owner: string, overrides?: CallOverrides): Promise; + + maxWithdraw(owner: string, overrides?: CallOverrides): Promise; + + mint( + shares: BigNumberish, + receiver: string, + overrides?: CallOverrides, + ): Promise; + + name(overrides?: CallOverrides): Promise; + + pause(overrides?: CallOverrides): Promise; + + previewDeposit( + assets: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + previewMint( + shares: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + previewRedeem( + shares: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + previewWithdraw( + assets: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + redeem( + shares: BigNumberish, + receiver: string, + owner: string, + overrides?: CallOverrides, + ): Promise; + + setCooldown( + cooldown: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + setCooldownOperator( + operator: string, + flag: boolean, + overrides?: CallOverrides, + ): Promise; + + setUnstakeWindow( + newUnstakeWindow: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + slash( + destination: string, + amount: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalAssets(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: string, + value: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + transferFrom( + from: string, + to: string, + value: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + unpause(overrides?: CallOverrides): Promise; + + withdraw( + assets: BigNumberish, + receiver: string, + owner: string, + overrides?: CallOverrides, + ): Promise; + }; + + filters: { + 'Approval(address,address,uint256)'( + owner?: string | null, + spender?: string | null, + value?: null, + ): ApprovalEventFilter; + Approval( + owner?: string | null, + spender?: string | null, + value?: null, + ): ApprovalEventFilter; + + 'CooldownChanged(uint256,uint256)'( + oldCooldown?: null, + newCooldown?: null, + ): CooldownChangedEventFilter; + CooldownChanged( + oldCooldown?: null, + newCooldown?: null, + ): CooldownChangedEventFilter; + + 'CooldownOperatorSet(address,address,bool)'( + user?: string | null, + operator?: string | null, + flag?: null, + ): CooldownOperatorSetEventFilter; + CooldownOperatorSet( + user?: string | null, + operator?: string | null, + flag?: null, + ): CooldownOperatorSetEventFilter; + + 'Deposit(address,address,uint256,uint256)'( + sender?: string | null, + owner?: string | null, + assets?: null, + shares?: null, + ): DepositEventFilter; + Deposit( + sender?: string | null, + owner?: string | null, + assets?: null, + shares?: null, + ): DepositEventFilter; + + 'Slashed(address,uint256)'( + destination?: string | null, + amount?: null, + ): SlashedEventFilter; + Slashed(destination?: string | null, amount?: null): SlashedEventFilter; + + 'StakerCooldownUpdated(address,uint256,uint256,uint256)'( + user?: string | null, + amount?: null, + endOfCooldown?: null, + unstakeWindow?: null, + ): StakerCooldownUpdatedEventFilter; + StakerCooldownUpdated( + user?: string | null, + amount?: null, + endOfCooldown?: null, + unstakeWindow?: null, + ): StakerCooldownUpdatedEventFilter; + + 'Transfer(address,address,uint256)'( + from?: string | null, + to?: string | null, + value?: null, + ): TransferEventFilter; + Transfer( + from?: string | null, + to?: string | null, + value?: null, + ): TransferEventFilter; + + 'UnstakeWindowChanged(uint256,uint256)'( + oldUnstakeWindow?: null, + newUnstakeWindow?: null, + ): UnstakeWindowChangedEventFilter; + UnstakeWindowChanged( + oldUnstakeWindow?: null, + newUnstakeWindow?: null, + ): UnstakeWindowChangedEventFilter; + + 'Withdraw(address,address,address,uint256,uint256)'( + sender?: string | null, + receiver?: string | null, + owner?: string | null, + assets?: null, + shares?: null, + ): WithdrawEventFilter; + Withdraw( + sender?: string | null, + receiver?: string | null, + owner?: string | null, + assets?: null, + shares?: null, + ): WithdrawEventFilter; + }; + + estimateGas: { + MIN_ASSETS_REMAINING(overrides?: CallOverrides): Promise; + + allowance( + owner: string, + spender: string, + overrides?: CallOverrides, + ): Promise; + + approve( + spender: string, + value: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + asset(overrides?: CallOverrides): Promise; + + balanceOf(account: string, overrides?: CallOverrides): Promise; + + convertToAssets( + shares: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + convertToShares( + assets: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + cooldown(overrides?: Overrides & { from?: string }): Promise; + + cooldownNonces( + owner: string, + overrides?: CallOverrides, + ): Promise; + + cooldownOnBehalfOf( + from: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + cooldownWithPermit( + user: string, + deadline: BigNumberish, + sig: IERC4626StakeToken.SignatureParamsStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + deposit( + assets: BigNumberish, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + depositWithPermit( + assets: BigNumberish, + receiver: string, + deadline: BigNumberish, + sig: IERC4626StakeToken.SignatureParamsStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + getCooldown(overrides?: CallOverrides): Promise; + + getMaxSlashableAssets(overrides?: CallOverrides): Promise; + + getStakerCooldown( + user: string, + overrides?: CallOverrides, + ): Promise; + + getUnstakeWindow(overrides?: CallOverrides): Promise; + + isCooldownOperator( + user: string, + operator: string, + overrides?: CallOverrides, + ): Promise; + + maxDeposit(receiver: string, overrides?: CallOverrides): Promise; + + maxMint(receiver: string, overrides?: CallOverrides): Promise; + + maxRedeem(owner: string, overrides?: CallOverrides): Promise; + + maxWithdraw(owner: string, overrides?: CallOverrides): Promise; + + mint( + shares: BigNumberish, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + name(overrides?: CallOverrides): Promise; + + pause(overrides?: Overrides & { from?: string }): Promise; + + previewDeposit( + assets: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + previewMint( + shares: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + previewRedeem( + shares: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + previewWithdraw( + assets: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + redeem( + shares: BigNumberish, + receiver: string, + owner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + setCooldown( + cooldown: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setCooldownOperator( + operator: string, + flag: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setUnstakeWindow( + newUnstakeWindow: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + slash( + destination: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalAssets(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: string, + value: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferFrom( + from: string, + to: string, + value: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + unpause(overrides?: Overrides & { from?: string }): Promise; + + withdraw( + assets: BigNumberish, + receiver: string, + owner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + }; + + populateTransaction: { + MIN_ASSETS_REMAINING( + overrides?: CallOverrides, + ): Promise; + + allowance( + owner: string, + spender: string, + overrides?: CallOverrides, + ): Promise; + + approve( + spender: string, + value: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + asset(overrides?: CallOverrides): Promise; + + balanceOf( + account: string, + overrides?: CallOverrides, + ): Promise; + + convertToAssets( + shares: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + convertToShares( + assets: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + cooldown( + overrides?: Overrides & { from?: string }, + ): Promise; + + cooldownNonces( + owner: string, + overrides?: CallOverrides, + ): Promise; + + cooldownOnBehalfOf( + from: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + cooldownWithPermit( + user: string, + deadline: BigNumberish, + sig: IERC4626StakeToken.SignatureParamsStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + deposit( + assets: BigNumberish, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + depositWithPermit( + assets: BigNumberish, + receiver: string, + deadline: BigNumberish, + sig: IERC4626StakeToken.SignatureParamsStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + getCooldown(overrides?: CallOverrides): Promise; + + getMaxSlashableAssets( + overrides?: CallOverrides, + ): Promise; + + getStakerCooldown( + user: string, + overrides?: CallOverrides, + ): Promise; + + getUnstakeWindow(overrides?: CallOverrides): Promise; + + isCooldownOperator( + user: string, + operator: string, + overrides?: CallOverrides, + ): Promise; + + maxDeposit( + receiver: string, + overrides?: CallOverrides, + ): Promise; + + maxMint( + receiver: string, + overrides?: CallOverrides, + ): Promise; + + maxRedeem( + owner: string, + overrides?: CallOverrides, + ): Promise; + + maxWithdraw( + owner: string, + overrides?: CallOverrides, + ): Promise; + + mint( + shares: BigNumberish, + receiver: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + name(overrides?: CallOverrides): Promise; + + pause( + overrides?: Overrides & { from?: string }, + ): Promise; + + previewDeposit( + assets: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + previewMint( + shares: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + previewRedeem( + shares: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + previewWithdraw( + assets: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + redeem( + shares: BigNumberish, + receiver: string, + owner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + setCooldown( + cooldown: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + setCooldownOperator( + operator: string, + flag: boolean, + overrides?: Overrides & { from?: string }, + ): Promise; + + setUnstakeWindow( + newUnstakeWindow: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + slash( + destination: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalAssets(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: string, + value: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + transferFrom( + from: string, + to: string, + value: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + unpause( + overrides?: Overrides & { from?: string }, + ): Promise; + + withdraw( + assets: BigNumberish, + receiver: string, + owner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + }; +} diff --git a/packages/contract-helpers/src/umbrella/typechain/StakeToken__factory.ts b/packages/contract-helpers/src/umbrella/typechain/StakeToken__factory.ts new file mode 100644 index 00000000..768d8c40 --- /dev/null +++ b/packages/contract-helpers/src/umbrella/typechain/StakeToken__factory.ts @@ -0,0 +1,1110 @@ +/* Autogenerated file. Do not edit manually. */ +/* eslint-disable */ + +import { Contract, Signer, utils } from 'ethers'; +import type { Provider } from '@ethersproject/providers'; +import type { + IERC4626StakeToken, + IERC4626StakeTokenInterface, +} from './StakeToken'; + +const _abi = [ + { + type: 'function', + name: 'MIN_ASSETS_REMAINING', + inputs: [], + outputs: [ + { + name: '', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'allowance', + inputs: [ + { + name: 'owner', + type: 'address', + internalType: 'address', + }, + { + name: 'spender', + type: 'address', + internalType: 'address', + }, + ], + outputs: [ + { + name: '', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'approve', + inputs: [ + { + name: 'spender', + type: 'address', + internalType: 'address', + }, + { + name: 'value', + type: 'uint256', + internalType: 'uint256', + }, + ], + outputs: [ + { + name: '', + type: 'bool', + internalType: 'bool', + }, + ], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'asset', + inputs: [], + outputs: [ + { + name: 'assetTokenAddress', + type: 'address', + internalType: 'address', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'balanceOf', + inputs: [ + { + name: 'account', + type: 'address', + internalType: 'address', + }, + ], + outputs: [ + { + name: '', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'convertToAssets', + inputs: [ + { + name: 'shares', + type: 'uint256', + internalType: 'uint256', + }, + ], + outputs: [ + { + name: 'assets', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'convertToShares', + inputs: [ + { + name: 'assets', + type: 'uint256', + internalType: 'uint256', + }, + ], + outputs: [ + { + name: 'shares', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'cooldown', + inputs: [], + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'cooldownNonces', + inputs: [ + { + name: 'owner', + type: 'address', + internalType: 'address', + }, + ], + outputs: [ + { + name: '', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'cooldownOnBehalfOf', + inputs: [ + { + name: 'from', + type: 'address', + internalType: 'address', + }, + ], + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'cooldownWithPermit', + inputs: [ + { + name: 'user', + type: 'address', + internalType: 'address', + }, + { + name: 'deadline', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'sig', + type: 'tuple', + internalType: 'struct IERC4626StakeToken.SignatureParams', + components: [ + { + name: 'v', + type: 'uint8', + internalType: 'uint8', + }, + { + name: 'r', + type: 'bytes32', + internalType: 'bytes32', + }, + { + name: 's', + type: 'bytes32', + internalType: 'bytes32', + }, + ], + }, + ], + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'decimals', + inputs: [], + outputs: [ + { + name: '', + type: 'uint8', + internalType: 'uint8', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'deposit', + inputs: [ + { + name: 'assets', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'receiver', + type: 'address', + internalType: 'address', + }, + ], + outputs: [ + { + name: 'shares', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'depositWithPermit', + inputs: [ + { + name: 'assets', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'receiver', + type: 'address', + internalType: 'address', + }, + { + name: 'deadline', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'sig', + type: 'tuple', + internalType: 'struct IERC4626StakeToken.SignatureParams', + components: [ + { + name: 'v', + type: 'uint8', + internalType: 'uint8', + }, + { + name: 'r', + type: 'bytes32', + internalType: 'bytes32', + }, + { + name: 's', + type: 'bytes32', + internalType: 'bytes32', + }, + ], + }, + ], + outputs: [ + { + name: '', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'getCooldown', + inputs: [], + outputs: [ + { + name: '', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'getMaxSlashableAssets', + inputs: [], + outputs: [ + { + name: '', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'getStakerCooldown', + inputs: [ + { + name: 'user', + type: 'address', + internalType: 'address', + }, + ], + outputs: [ + { + name: '', + type: 'tuple', + internalType: 'struct IERC4626StakeToken.CooldownSnapshot', + components: [ + { + name: 'amount', + type: 'uint192', + internalType: 'uint192', + }, + { + name: 'endOfCooldown', + type: 'uint32', + internalType: 'uint32', + }, + { + name: 'withdrawalWindow', + type: 'uint32', + internalType: 'uint32', + }, + ], + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'getUnstakeWindow', + inputs: [], + outputs: [ + { + name: '', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'isCooldownOperator', + inputs: [ + { + name: 'user', + type: 'address', + internalType: 'address', + }, + { + name: 'operator', + type: 'address', + internalType: 'address', + }, + ], + outputs: [ + { + name: '', + type: 'bool', + internalType: 'bool', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'maxDeposit', + inputs: [ + { + name: 'receiver', + type: 'address', + internalType: 'address', + }, + ], + outputs: [ + { + name: 'maxAssets', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'maxMint', + inputs: [ + { + name: 'receiver', + type: 'address', + internalType: 'address', + }, + ], + outputs: [ + { + name: 'maxShares', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'maxRedeem', + inputs: [ + { + name: 'owner', + type: 'address', + internalType: 'address', + }, + ], + outputs: [ + { + name: 'maxShares', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'maxWithdraw', + inputs: [ + { + name: 'owner', + type: 'address', + internalType: 'address', + }, + ], + outputs: [ + { + name: 'maxAssets', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'mint', + inputs: [ + { + name: 'shares', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'receiver', + type: 'address', + internalType: 'address', + }, + ], + outputs: [ + { + name: 'assets', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'name', + inputs: [], + outputs: [ + { + name: '', + type: 'string', + internalType: 'string', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'pause', + inputs: [], + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'previewDeposit', + inputs: [ + { + name: 'assets', + type: 'uint256', + internalType: 'uint256', + }, + ], + outputs: [ + { + name: 'shares', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'previewMint', + inputs: [ + { + name: 'shares', + type: 'uint256', + internalType: 'uint256', + }, + ], + outputs: [ + { + name: 'assets', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'previewRedeem', + inputs: [ + { + name: 'shares', + type: 'uint256', + internalType: 'uint256', + }, + ], + outputs: [ + { + name: 'assets', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'previewWithdraw', + inputs: [ + { + name: 'assets', + type: 'uint256', + internalType: 'uint256', + }, + ], + outputs: [ + { + name: 'shares', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'redeem', + inputs: [ + { + name: 'shares', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'receiver', + type: 'address', + internalType: 'address', + }, + { + name: 'owner', + type: 'address', + internalType: 'address', + }, + ], + outputs: [ + { + name: 'assets', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'setCooldown', + inputs: [ + { + name: 'cooldown', + type: 'uint256', + internalType: 'uint256', + }, + ], + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'setCooldownOperator', + inputs: [ + { + name: 'operator', + type: 'address', + internalType: 'address', + }, + { + name: 'flag', + type: 'bool', + internalType: 'bool', + }, + ], + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'setUnstakeWindow', + inputs: [ + { + name: 'newUnstakeWindow', + type: 'uint256', + internalType: 'uint256', + }, + ], + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'slash', + inputs: [ + { + name: 'destination', + type: 'address', + internalType: 'address', + }, + { + name: 'amount', + type: 'uint256', + internalType: 'uint256', + }, + ], + outputs: [ + { + name: '', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'symbol', + inputs: [], + outputs: [ + { + name: '', + type: 'string', + internalType: 'string', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'totalAssets', + inputs: [], + outputs: [ + { + name: 'totalManagedAssets', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'totalSupply', + inputs: [], + outputs: [ + { + name: '', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'transfer', + inputs: [ + { + name: 'to', + type: 'address', + internalType: 'address', + }, + { + name: 'value', + type: 'uint256', + internalType: 'uint256', + }, + ], + outputs: [ + { + name: '', + type: 'bool', + internalType: 'bool', + }, + ], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'transferFrom', + inputs: [ + { + name: 'from', + type: 'address', + internalType: 'address', + }, + { + name: 'to', + type: 'address', + internalType: 'address', + }, + { + name: 'value', + type: 'uint256', + internalType: 'uint256', + }, + ], + outputs: [ + { + name: '', + type: 'bool', + internalType: 'bool', + }, + ], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'unpause', + inputs: [], + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'withdraw', + inputs: [ + { + name: 'assets', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'receiver', + type: 'address', + internalType: 'address', + }, + { + name: 'owner', + type: 'address', + internalType: 'address', + }, + ], + outputs: [ + { + name: 'shares', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'nonpayable', + }, + { + type: 'event', + name: 'Approval', + inputs: [ + { + name: 'owner', + type: 'address', + indexed: true, + internalType: 'address', + }, + { + name: 'spender', + type: 'address', + indexed: true, + internalType: 'address', + }, + { + name: 'value', + type: 'uint256', + indexed: false, + internalType: 'uint256', + }, + ], + anonymous: false, + }, + { + type: 'event', + name: 'CooldownChanged', + inputs: [ + { + name: 'oldCooldown', + type: 'uint256', + indexed: false, + internalType: 'uint256', + }, + { + name: 'newCooldown', + type: 'uint256', + indexed: false, + internalType: 'uint256', + }, + ], + anonymous: false, + }, + { + type: 'event', + name: 'CooldownOperatorSet', + inputs: [ + { + name: 'user', + type: 'address', + indexed: true, + internalType: 'address', + }, + { + name: 'operator', + type: 'address', + indexed: true, + internalType: 'address', + }, + { + name: 'flag', + type: 'bool', + indexed: false, + internalType: 'bool', + }, + ], + anonymous: false, + }, + { + type: 'event', + name: 'Deposit', + inputs: [ + { + name: 'sender', + type: 'address', + indexed: true, + internalType: 'address', + }, + { + name: 'owner', + type: 'address', + indexed: true, + internalType: 'address', + }, + { + name: 'assets', + type: 'uint256', + indexed: false, + internalType: 'uint256', + }, + { + name: 'shares', + type: 'uint256', + indexed: false, + internalType: 'uint256', + }, + ], + anonymous: false, + }, + { + type: 'event', + name: 'Slashed', + inputs: [ + { + name: 'destination', + type: 'address', + indexed: true, + internalType: 'address', + }, + { + name: 'amount', + type: 'uint256', + indexed: false, + internalType: 'uint256', + }, + ], + anonymous: false, + }, + { + type: 'event', + name: 'StakerCooldownUpdated', + inputs: [ + { + name: 'user', + type: 'address', + indexed: true, + internalType: 'address', + }, + { + name: 'amount', + type: 'uint256', + indexed: false, + internalType: 'uint256', + }, + { + name: 'endOfCooldown', + type: 'uint256', + indexed: false, + internalType: 'uint256', + }, + { + name: 'unstakeWindow', + type: 'uint256', + indexed: false, + internalType: 'uint256', + }, + ], + anonymous: false, + }, + { + type: 'event', + name: 'Transfer', + inputs: [ + { + name: 'from', + type: 'address', + indexed: true, + internalType: 'address', + }, + { + name: 'to', + type: 'address', + indexed: true, + internalType: 'address', + }, + { + name: 'value', + type: 'uint256', + indexed: false, + internalType: 'uint256', + }, + ], + anonymous: false, + }, + { + type: 'event', + name: 'UnstakeWindowChanged', + inputs: [ + { + name: 'oldUnstakeWindow', + type: 'uint256', + indexed: false, + internalType: 'uint256', + }, + { + name: 'newUnstakeWindow', + type: 'uint256', + indexed: false, + internalType: 'uint256', + }, + ], + anonymous: false, + }, + { + type: 'event', + name: 'Withdraw', + inputs: [ + { + name: 'sender', + type: 'address', + indexed: true, + internalType: 'address', + }, + { + name: 'receiver', + type: 'address', + indexed: true, + internalType: 'address', + }, + { + name: 'owner', + type: 'address', + indexed: true, + internalType: 'address', + }, + { + name: 'assets', + type: 'uint256', + indexed: false, + internalType: 'uint256', + }, + { + name: 'shares', + type: 'uint256', + indexed: false, + internalType: 'uint256', + }, + ], + anonymous: false, + }, + { + type: 'error', + name: 'NotApprovedForCooldown', + inputs: [ + { + name: 'owner', + type: 'address', + internalType: 'address', + }, + { + name: 'spender', + type: 'address', + internalType: 'address', + }, + ], + }, + { + type: 'error', + name: 'ZeroAddress', + inputs: [], + }, + { + type: 'error', + name: 'ZeroAmountSlashing', + inputs: [], + }, + { + type: 'error', + name: 'ZeroBalanceInStaking', + inputs: [], + }, + { + type: 'error', + name: 'ZeroFundsAvailable', + inputs: [], + }, +] as const; + +export class IERC4626StakeToken__factory { + static readonly abi = _abi; + static createInterface(): IERC4626StakeTokenInterface { + return new utils.Interface(_abi) as IERC4626StakeTokenInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider, + ): IERC4626StakeToken { + return new Contract(address, _abi, signerOrProvider) as IERC4626StakeToken; + } +} diff --git a/packages/contract-helpers/src/umbrella/typechain/UmbrellaBatchHelper.ts b/packages/contract-helpers/src/umbrella/typechain/UmbrellaBatchHelper.ts new file mode 100644 index 00000000..29d080d8 --- /dev/null +++ b/packages/contract-helpers/src/umbrella/typechain/UmbrellaBatchHelper.ts @@ -0,0 +1,791 @@ +/* Autogenerated file. Do not edit manually. */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from 'ethers'; +import type { + FunctionFragment, + Result, + EventFragment, +} from '@ethersproject/abi'; +import type { Listener, Provider } from '@ethersproject/providers'; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, +} from './common'; + +export declare namespace IUmbrellaBatchHelper { + export type ClaimPermitStruct = { + stakeToken: string; + rewards: string[]; + deadline: BigNumberish; + v: BigNumberish; + r: BytesLike; + s: BytesLike; + restake: boolean; + }; + + export type ClaimPermitStructOutput = [ + string, + string[], + BigNumber, + number, + string, + string, + boolean, + ] & { + stakeToken: string; + rewards: string[]; + deadline: BigNumber; + v: number; + r: string; + s: string; + restake: boolean; + }; + + export type CooldownPermitStruct = { + stakeToken: string; + deadline: BigNumberish; + v: BigNumberish; + r: BytesLike; + s: BytesLike; + }; + + export type CooldownPermitStructOutput = [ + string, + BigNumber, + number, + string, + string, + ] & { + stakeToken: string; + deadline: BigNumber; + v: number; + r: string; + s: string; + }; + + export type IODataStruct = { + stakeToken: string; + edgeToken: string; + value: BigNumberish; + }; + + export type IODataStructOutput = [string, string, BigNumber] & { + stakeToken: string; + edgeToken: string; + value: BigNumber; + }; + + export type PermitStruct = { + token: string; + value: BigNumberish; + deadline: BigNumberish; + v: BigNumberish; + r: BytesLike; + s: BytesLike; + }; + + export type PermitStructOutput = [ + string, + BigNumber, + BigNumber, + number, + string, + string, + ] & { + token: string; + value: BigNumber; + deadline: BigNumber; + v: number; + r: string; + s: string; + }; +} + +export interface UmbrellaBatchHelperInterface extends utils.Interface { + functions: { + 'REWARDS_CONTROLLER()': FunctionFragment; + 'claimRewardsPermit((address,address[],uint256,uint8,bytes32,bytes32,bool))': FunctionFragment; + 'cooldownPermit((address,uint256,uint8,bytes32,bytes32))': FunctionFragment; + 'deposit((address,address,uint256))': FunctionFragment; + 'emergencyEtherTransfer(address,uint256)': FunctionFragment; + 'emergencyTokenTransfer(address,address,uint256)': FunctionFragment; + 'initializePath(address[])': FunctionFragment; + 'maxRescue(address)': FunctionFragment; + 'multicall(bytes[])': FunctionFragment; + 'owner()': FunctionFragment; + 'pause()': FunctionFragment; + 'paused()': FunctionFragment; + 'permit((address,uint256,uint256,uint8,bytes32,bytes32))': FunctionFragment; + 'redeem((address,address,uint256))': FunctionFragment; + 'renounceOwnership()': FunctionFragment; + 'transferOwnership(address)': FunctionFragment; + 'unpause()': FunctionFragment; + 'whoCanRescue()': FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | 'REWARDS_CONTROLLER' + | 'claimRewardsPermit' + | 'cooldownPermit' + | 'deposit' + | 'emergencyEtherTransfer' + | 'emergencyTokenTransfer' + | 'initializePath' + | 'maxRescue' + | 'multicall' + | 'owner' + | 'pause' + | 'paused' + | 'permit' + | 'redeem' + | 'renounceOwnership' + | 'transferOwnership' + | 'unpause' + | 'whoCanRescue', + ): FunctionFragment; + + encodeFunctionData( + functionFragment: 'REWARDS_CONTROLLER', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'claimRewardsPermit', + values: [IUmbrellaBatchHelper.ClaimPermitStruct], + ): string; + encodeFunctionData( + functionFragment: 'cooldownPermit', + values: [IUmbrellaBatchHelper.CooldownPermitStruct], + ): string; + encodeFunctionData( + functionFragment: 'deposit', + values: [IUmbrellaBatchHelper.IODataStruct], + ): string; + encodeFunctionData( + functionFragment: 'emergencyEtherTransfer', + values: [string, BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'emergencyTokenTransfer', + values: [string, string, BigNumberish], + ): string; + encodeFunctionData( + functionFragment: 'initializePath', + values: [string[]], + ): string; + encodeFunctionData(functionFragment: 'maxRescue', values: [string]): string; + encodeFunctionData( + functionFragment: 'multicall', + values: [BytesLike[]], + ): string; + encodeFunctionData(functionFragment: 'owner', values?: undefined): string; + encodeFunctionData(functionFragment: 'pause', values?: undefined): string; + encodeFunctionData(functionFragment: 'paused', values?: undefined): string; + encodeFunctionData( + functionFragment: 'permit', + values: [IUmbrellaBatchHelper.PermitStruct], + ): string; + encodeFunctionData( + functionFragment: 'redeem', + values: [IUmbrellaBatchHelper.IODataStruct], + ): string; + encodeFunctionData( + functionFragment: 'renounceOwnership', + values?: undefined, + ): string; + encodeFunctionData( + functionFragment: 'transferOwnership', + values: [string], + ): string; + encodeFunctionData(functionFragment: 'unpause', values?: undefined): string; + encodeFunctionData( + functionFragment: 'whoCanRescue', + values?: undefined, + ): string; + + decodeFunctionResult( + functionFragment: 'REWARDS_CONTROLLER', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'claimRewardsPermit', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'cooldownPermit', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'deposit', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'emergencyEtherTransfer', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'emergencyTokenTransfer', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'initializePath', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'maxRescue', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'multicall', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'owner', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'pause', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'paused', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'permit', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'redeem', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'renounceOwnership', + data: BytesLike, + ): Result; + decodeFunctionResult( + functionFragment: 'transferOwnership', + data: BytesLike, + ): Result; + decodeFunctionResult(functionFragment: 'unpause', data: BytesLike): Result; + decodeFunctionResult( + functionFragment: 'whoCanRescue', + data: BytesLike, + ): Result; + + events: { + 'AssetPathInitialized(address)': EventFragment; + 'ERC20Rescued(address,address,address,uint256)': EventFragment; + 'NativeTokensRescued(address,address,uint256)': EventFragment; + 'OwnershipTransferred(address,address)': EventFragment; + 'Paused(address)': EventFragment; + 'Unpaused(address)': EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: 'AssetPathInitialized'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'ERC20Rescued'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'NativeTokensRescued'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'OwnershipTransferred'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Paused'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Unpaused'): EventFragment; +} + +export interface AssetPathInitializedEventObject { + stakeToken: string; +} +export type AssetPathInitializedEvent = TypedEvent< + [string], + AssetPathInitializedEventObject +>; + +export type AssetPathInitializedEventFilter = + TypedEventFilter; + +export interface ERC20RescuedEventObject { + caller: string; + token: string; + to: string; + amount: BigNumber; +} +export type ERC20RescuedEvent = TypedEvent< + [string, string, string, BigNumber], + ERC20RescuedEventObject +>; + +export type ERC20RescuedEventFilter = TypedEventFilter; + +export interface NativeTokensRescuedEventObject { + caller: string; + to: string; + amount: BigNumber; +} +export type NativeTokensRescuedEvent = TypedEvent< + [string, string, BigNumber], + NativeTokensRescuedEventObject +>; + +export type NativeTokensRescuedEventFilter = + 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 UnpausedEventObject { + account: string; +} +export type UnpausedEvent = TypedEvent<[string], UnpausedEventObject>; + +export type UnpausedEventFilter = TypedEventFilter; + +export interface UmbrellaBatchHelper extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: UmbrellaBatchHelperInterface; + + 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: { + REWARDS_CONTROLLER(overrides?: CallOverrides): Promise<[string]>; + + claimRewardsPermit( + p: IUmbrellaBatchHelper.ClaimPermitStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + cooldownPermit( + p: IUmbrellaBatchHelper.CooldownPermitStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + deposit( + io: IUmbrellaBatchHelper.IODataStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + emergencyEtherTransfer( + to: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + emergencyTokenTransfer( + erc20Token: string, + to: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + initializePath( + stakeTokens: string[], + overrides?: Overrides & { from?: string }, + ): Promise; + + maxRescue(arg0: string, overrides?: CallOverrides): Promise<[BigNumber]>; + + multicall( + data: BytesLike[], + overrides?: Overrides & { from?: string }, + ): Promise; + + owner(overrides?: CallOverrides): Promise<[string]>; + + pause( + overrides?: Overrides & { from?: string }, + ): Promise; + + paused(overrides?: CallOverrides): Promise<[boolean]>; + + permit( + p: IUmbrellaBatchHelper.PermitStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + redeem( + io: IUmbrellaBatchHelper.IODataStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: string }, + ): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + unpause( + overrides?: Overrides & { from?: string }, + ): Promise; + + whoCanRescue(overrides?: CallOverrides): Promise<[string]>; + }; + + REWARDS_CONTROLLER(overrides?: CallOverrides): Promise; + + claimRewardsPermit( + p: IUmbrellaBatchHelper.ClaimPermitStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + cooldownPermit( + p: IUmbrellaBatchHelper.CooldownPermitStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + deposit( + io: IUmbrellaBatchHelper.IODataStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + emergencyEtherTransfer( + to: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + emergencyTokenTransfer( + erc20Token: string, + to: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + initializePath( + stakeTokens: string[], + overrides?: Overrides & { from?: string }, + ): Promise; + + maxRescue(arg0: string, overrides?: CallOverrides): Promise; + + multicall( + data: BytesLike[], + overrides?: Overrides & { from?: string }, + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + pause( + overrides?: Overrides & { from?: string }, + ): Promise; + + paused(overrides?: CallOverrides): Promise; + + permit( + p: IUmbrellaBatchHelper.PermitStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + redeem( + io: IUmbrellaBatchHelper.IODataStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: string }, + ): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + unpause( + overrides?: Overrides & { from?: string }, + ): Promise; + + whoCanRescue(overrides?: CallOverrides): Promise; + + callStatic: { + REWARDS_CONTROLLER(overrides?: CallOverrides): Promise; + + claimRewardsPermit( + p: IUmbrellaBatchHelper.ClaimPermitStruct, + overrides?: CallOverrides, + ): Promise; + + cooldownPermit( + p: IUmbrellaBatchHelper.CooldownPermitStruct, + overrides?: CallOverrides, + ): Promise; + + deposit( + io: IUmbrellaBatchHelper.IODataStruct, + overrides?: CallOverrides, + ): Promise; + + emergencyEtherTransfer( + to: string, + amount: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + emergencyTokenTransfer( + erc20Token: string, + to: string, + amount: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + initializePath( + stakeTokens: string[], + overrides?: CallOverrides, + ): Promise; + + maxRescue(arg0: string, overrides?: CallOverrides): Promise; + + multicall(data: BytesLike[], overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + pause(overrides?: CallOverrides): Promise; + + paused(overrides?: CallOverrides): Promise; + + permit( + p: IUmbrellaBatchHelper.PermitStruct, + overrides?: CallOverrides, + ): Promise; + + redeem( + io: IUmbrellaBatchHelper.IODataStruct, + overrides?: CallOverrides, + ): Promise; + + renounceOwnership(overrides?: CallOverrides): Promise; + + transferOwnership( + newOwner: string, + overrides?: CallOverrides, + ): Promise; + + unpause(overrides?: CallOverrides): Promise; + + whoCanRescue(overrides?: CallOverrides): Promise; + }; + + filters: { + 'AssetPathInitialized(address)'( + stakeToken?: null, + ): AssetPathInitializedEventFilter; + AssetPathInitialized(stakeToken?: null): AssetPathInitializedEventFilter; + + 'ERC20Rescued(address,address,address,uint256)'( + caller?: string | null, + token?: string | null, + to?: string | null, + amount?: null, + ): ERC20RescuedEventFilter; + ERC20Rescued( + caller?: string | null, + token?: string | null, + to?: string | null, + amount?: null, + ): ERC20RescuedEventFilter; + + 'NativeTokensRescued(address,address,uint256)'( + caller?: string | null, + to?: string | null, + amount?: null, + ): NativeTokensRescuedEventFilter; + NativeTokensRescued( + caller?: string | null, + to?: string | null, + amount?: null, + ): NativeTokensRescuedEventFilter; + + 'OwnershipTransferred(address,address)'( + previousOwner?: string | null, + newOwner?: string | null, + ): OwnershipTransferredEventFilter; + OwnershipTransferred( + previousOwner?: string | null, + newOwner?: string | null, + ): OwnershipTransferredEventFilter; + + 'Paused(address)'(account?: null): PausedEventFilter; + Paused(account?: null): PausedEventFilter; + + 'Unpaused(address)'(account?: null): UnpausedEventFilter; + Unpaused(account?: null): UnpausedEventFilter; + }; + + estimateGas: { + REWARDS_CONTROLLER(overrides?: CallOverrides): Promise; + + claimRewardsPermit( + p: IUmbrellaBatchHelper.ClaimPermitStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + cooldownPermit( + p: IUmbrellaBatchHelper.CooldownPermitStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + deposit( + io: IUmbrellaBatchHelper.IODataStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + emergencyEtherTransfer( + to: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + emergencyTokenTransfer( + erc20Token: string, + to: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + initializePath( + stakeTokens: string[], + overrides?: Overrides & { from?: string }, + ): Promise; + + maxRescue(arg0: string, overrides?: CallOverrides): Promise; + + multicall( + data: BytesLike[], + overrides?: Overrides & { from?: string }, + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + pause(overrides?: Overrides & { from?: string }): Promise; + + paused(overrides?: CallOverrides): Promise; + + permit( + p: IUmbrellaBatchHelper.PermitStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + redeem( + io: IUmbrellaBatchHelper.IODataStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: string }, + ): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + unpause(overrides?: Overrides & { from?: string }): Promise; + + whoCanRescue(overrides?: CallOverrides): Promise; + }; + + populateTransaction: { + REWARDS_CONTROLLER( + overrides?: CallOverrides, + ): Promise; + + claimRewardsPermit( + p: IUmbrellaBatchHelper.ClaimPermitStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + cooldownPermit( + p: IUmbrellaBatchHelper.CooldownPermitStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + deposit( + io: IUmbrellaBatchHelper.IODataStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + emergencyEtherTransfer( + to: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + emergencyTokenTransfer( + erc20Token: string, + to: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string }, + ): Promise; + + initializePath( + stakeTokens: string[], + overrides?: Overrides & { from?: string }, + ): Promise; + + maxRescue( + arg0: string, + overrides?: CallOverrides, + ): Promise; + + multicall( + data: BytesLike[], + overrides?: Overrides & { from?: string }, + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + pause( + overrides?: Overrides & { from?: string }, + ): Promise; + + paused(overrides?: CallOverrides): Promise; + + permit( + p: IUmbrellaBatchHelper.PermitStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + redeem( + io: IUmbrellaBatchHelper.IODataStruct, + overrides?: Overrides & { from?: string }, + ): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: string }, + ): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string }, + ): Promise; + + unpause( + overrides?: Overrides & { from?: string }, + ): Promise; + + whoCanRescue(overrides?: CallOverrides): Promise; + }; +} diff --git a/packages/contract-helpers/src/umbrella/typechain/UmbrellaBatchHelper__factory.ts b/packages/contract-helpers/src/umbrella/typechain/UmbrellaBatchHelper__factory.ts new file mode 100644 index 00000000..d2d5c5ed --- /dev/null +++ b/packages/contract-helpers/src/umbrella/typechain/UmbrellaBatchHelper__factory.ts @@ -0,0 +1,665 @@ +/* Autogenerated file. Do not edit manually. */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from 'ethers'; +import type { Provider, TransactionRequest } from '@ethersproject/providers'; +import type { + UmbrellaBatchHelper, + UmbrellaBatchHelperInterface, +} from './UmbrellaBatchHelper'; + +const _abi = [ + { + type: 'constructor', + inputs: [ + { + name: 'rewardsController', + type: 'address', + internalType: 'address', + }, + { + name: 'owner', + type: 'address', + internalType: 'address', + }, + ], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'REWARDS_CONTROLLER', + inputs: [], + outputs: [ + { + name: '', + type: 'address', + internalType: 'contract IRewardsController', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'claimRewardsPermit', + inputs: [ + { + name: 'p', + type: 'tuple', + internalType: 'struct IUmbrellaBatchHelper.ClaimPermit', + components: [ + { + name: 'stakeToken', + type: 'address', + internalType: 'contract IStakeToken', + }, + { + name: 'rewards', + type: 'address[]', + internalType: 'address[]', + }, + { + name: 'deadline', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'v', + type: 'uint8', + internalType: 'uint8', + }, + { + name: 'r', + type: 'bytes32', + internalType: 'bytes32', + }, + { + name: 's', + type: 'bytes32', + internalType: 'bytes32', + }, + { + name: 'restake', + type: 'bool', + internalType: 'bool', + }, + ], + }, + ], + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'cooldownPermit', + inputs: [ + { + name: 'p', + type: 'tuple', + internalType: 'struct IUmbrellaBatchHelper.CooldownPermit', + components: [ + { + name: 'stakeToken', + type: 'address', + internalType: 'contract IStakeToken', + }, + { + name: 'deadline', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'v', + type: 'uint8', + internalType: 'uint8', + }, + { + name: 'r', + type: 'bytes32', + internalType: 'bytes32', + }, + { + name: 's', + type: 'bytes32', + internalType: 'bytes32', + }, + ], + }, + ], + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'deposit', + inputs: [ + { + name: 'io', + type: 'tuple', + internalType: 'struct IUmbrellaBatchHelper.IOData', + components: [ + { + name: 'stakeToken', + type: 'address', + internalType: 'contract IStakeToken', + }, + { + name: 'edgeToken', + type: 'address', + internalType: 'address', + }, + { + name: 'value', + type: 'uint256', + internalType: 'uint256', + }, + ], + }, + ], + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'emergencyEtherTransfer', + inputs: [ + { + name: 'to', + type: 'address', + internalType: 'address', + }, + { + name: 'amount', + type: 'uint256', + internalType: 'uint256', + }, + ], + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'emergencyTokenTransfer', + inputs: [ + { + name: 'erc20Token', + type: 'address', + internalType: 'address', + }, + { + name: 'to', + type: 'address', + internalType: 'address', + }, + { + name: 'amount', + type: 'uint256', + internalType: 'uint256', + }, + ], + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'initializePath', + inputs: [ + { + name: 'stakeTokens', + type: 'address[]', + internalType: 'contract IStakeToken[]', + }, + ], + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'maxRescue', + inputs: [ + { + name: '', + type: 'address', + internalType: 'address', + }, + ], + outputs: [ + { + name: '', + type: 'uint256', + internalType: 'uint256', + }, + ], + stateMutability: 'pure', + }, + { + type: 'function', + name: 'multicall', + inputs: [ + { + name: 'data', + type: 'bytes[]', + internalType: 'bytes[]', + }, + ], + outputs: [ + { + name: 'results', + type: 'bytes[]', + internalType: 'bytes[]', + }, + ], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'owner', + inputs: [], + outputs: [ + { + name: '', + type: 'address', + internalType: 'address', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'pause', + inputs: [], + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'paused', + inputs: [], + outputs: [ + { + name: '', + type: 'bool', + internalType: 'bool', + }, + ], + stateMutability: 'view', + }, + { + type: 'function', + name: 'permit', + inputs: [ + { + name: 'p', + type: 'tuple', + internalType: 'struct IUmbrellaBatchHelper.Permit', + components: [ + { + name: 'token', + type: 'address', + internalType: 'address', + }, + { + name: 'value', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'deadline', + type: 'uint256', + internalType: 'uint256', + }, + { + name: 'v', + type: 'uint8', + internalType: 'uint8', + }, + { + name: 'r', + type: 'bytes32', + internalType: 'bytes32', + }, + { + name: 's', + type: 'bytes32', + internalType: 'bytes32', + }, + ], + }, + ], + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'redeem', + inputs: [ + { + name: 'io', + type: 'tuple', + internalType: 'struct IUmbrellaBatchHelper.IOData', + components: [ + { + name: 'stakeToken', + type: 'address', + internalType: 'contract IStakeToken', + }, + { + name: 'edgeToken', + type: 'address', + internalType: 'address', + }, + { + name: 'value', + type: 'uint256', + internalType: 'uint256', + }, + ], + }, + ], + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'renounceOwnership', + inputs: [], + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'transferOwnership', + inputs: [ + { + name: 'newOwner', + type: 'address', + internalType: 'address', + }, + ], + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'unpause', + inputs: [], + outputs: [], + stateMutability: 'nonpayable', + }, + { + type: 'function', + name: 'whoCanRescue', + inputs: [], + outputs: [ + { + name: '', + type: 'address', + internalType: 'address', + }, + ], + stateMutability: 'view', + }, + { + type: 'event', + name: 'AssetPathInitialized', + inputs: [ + { + name: 'stakeToken', + type: 'address', + indexed: false, + internalType: 'address', + }, + ], + anonymous: false, + }, + { + type: 'event', + name: 'ERC20Rescued', + inputs: [ + { + name: 'caller', + type: 'address', + indexed: true, + internalType: 'address', + }, + { + name: 'token', + type: 'address', + indexed: true, + internalType: 'address', + }, + { + name: 'to', + type: 'address', + indexed: true, + internalType: 'address', + }, + { + name: 'amount', + type: 'uint256', + indexed: false, + internalType: 'uint256', + }, + ], + anonymous: false, + }, + { + type: 'event', + name: 'NativeTokensRescued', + inputs: [ + { + name: 'caller', + type: 'address', + indexed: true, + internalType: 'address', + }, + { + name: 'to', + type: 'address', + indexed: true, + internalType: 'address', + }, + { + name: 'amount', + type: 'uint256', + indexed: false, + internalType: 'uint256', + }, + ], + anonymous: false, + }, + { + type: 'event', + name: 'OwnershipTransferred', + inputs: [ + { + name: 'previousOwner', + type: 'address', + indexed: true, + internalType: 'address', + }, + { + name: 'newOwner', + type: 'address', + indexed: true, + internalType: 'address', + }, + ], + anonymous: false, + }, + { + type: 'event', + name: 'Paused', + inputs: [ + { + name: 'account', + type: 'address', + indexed: false, + internalType: 'address', + }, + ], + anonymous: false, + }, + { + type: 'event', + name: 'Unpaused', + inputs: [ + { + name: 'account', + type: 'address', + indexed: false, + internalType: 'address', + }, + ], + anonymous: false, + }, + { + type: 'error', + name: 'AddressEmptyCode', + inputs: [ + { + name: 'target', + type: 'address', + internalType: 'address', + }, + ], + }, + { + type: 'error', + name: 'EnforcedPause', + inputs: [], + }, + { + type: 'error', + name: 'EthTransferFailed', + inputs: [], + }, + { + type: 'error', + name: 'ExpectedPause', + inputs: [], + }, + { + type: 'error', + name: 'FailedCall', + inputs: [], + }, + { + type: 'error', + name: 'InvalidEdgeToken', + inputs: [], + }, + { + type: 'error', + name: 'NotInitializedStake', + inputs: [], + }, + { + type: 'error', + name: 'OnlyRescueGuardian', + inputs: [], + }, + { + type: 'error', + name: 'OwnableInvalidOwner', + inputs: [ + { + name: 'owner', + type: 'address', + internalType: 'address', + }, + ], + }, + { + type: 'error', + name: 'OwnableUnauthorizedAccount', + inputs: [ + { + name: 'account', + type: 'address', + internalType: 'address', + }, + ], + }, + { + type: 'error', + name: 'SafeERC20FailedOperation', + inputs: [ + { + name: 'token', + type: 'address', + internalType: 'address', + }, + ], + }, + { + type: 'error', + name: 'ZeroAddress', + inputs: [], + }, + { + type: 'error', + name: 'ZeroAmount', + inputs: [], + }, +] as const; + +const _bytecode = + '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'; + +type UmbrellaBatchHelperConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: UmbrellaBatchHelperConstructorParams, +): xs is ConstructorParameters => xs.length > 1; + +export class UmbrellaBatchHelper__factory extends ContractFactory { + constructor(...args: UmbrellaBatchHelperConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + rewardsController: string, + owner: string, + overrides?: Overrides & { from?: string }, + ): Promise { + return super.deploy( + rewardsController, + owner, + overrides || {}, + ) as Promise; + } + override getDeployTransaction( + rewardsController: string, + owner: string, + overrides?: Overrides & { from?: string }, + ): TransactionRequest { + return super.getDeployTransaction( + rewardsController, + owner, + overrides || {}, + ); + } + override attach(address: string): UmbrellaBatchHelper { + return super.attach(address) as UmbrellaBatchHelper; + } + override connect(signer: Signer): UmbrellaBatchHelper__factory { + return super.connect(signer) as UmbrellaBatchHelper__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): UmbrellaBatchHelperInterface { + return new utils.Interface(_abi) as UmbrellaBatchHelperInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider, + ): UmbrellaBatchHelper { + return new Contract(address, _abi, signerOrProvider) as UmbrellaBatchHelper; + } +} diff --git a/packages/contract-helpers/src/umbrella/typechain/common.ts b/packages/contract-helpers/src/umbrella/typechain/common.ts new file mode 100644 index 00000000..0fb82cd3 --- /dev/null +++ b/packages/contract-helpers/src/umbrella/typechain/common.ts @@ -0,0 +1,43 @@ +/* Autogenerated file. Do not edit manually. */ +/* eslint-disable */ +import type { Listener } from '@ethersproject/providers'; +import type { Event, EventFilter } from 'ethers'; + +export interface TypedEvent< + TArgsArray extends Array = 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< + infer C, + any +> + ? C + : never; + +export type GetARGsTypeFromFactory = F extends MinEthersFactory + ? Parameters + : never;