From da5fb42dbe4a868cc779be67c2b2ea874ab8eeae Mon Sep 17 00:00:00 2001 From: tonzgao Date: Thu, 12 May 2022 18:03:07 +0100 Subject: [PATCH] feat(concentrator): Add AladdinDAO Concentrator (#423) --- src/apps/concentrator/assets/logo.png | Bin 0 -> 4400 bytes .../concentrator/concentrator.definition.ts | 44 + src/apps/concentrator/concentrator.module.ts | 20 + .../contracts/abis/aladdin-convex-vault.json | 1041 +++++++++++++ .../contracts/abis/aladdin-crv.json | 913 ++++++++++++ .../contracts/ethers/AladdinConvexVault.ts | 1311 +++++++++++++++++ .../contracts/ethers/AladdinCrv.ts | 1103 ++++++++++++++ .../concentrator/contracts/ethers/common.ts | 30 + .../factories/AladdinConvexVault__factory.ts | 1059 +++++++++++++ .../ethers/factories/AladdinCrv__factory.ts | 931 ++++++++++++ .../contracts/ethers/factories/index.ts | 5 + .../concentrator/contracts/ethers/index.ts | 8 + src/apps/concentrator/contracts/index.ts | 28 + .../concentrator.acrv.token-fetcher.ts | 69 + .../ethereum/concentrator.balance-fetcher.ts | 69 + ...entrator.pool.contract-position-fetcher.ts | 56 + 16 files changed, 6687 insertions(+) create mode 100644 src/apps/concentrator/assets/logo.png create mode 100644 src/apps/concentrator/concentrator.definition.ts create mode 100644 src/apps/concentrator/concentrator.module.ts create mode 100644 src/apps/concentrator/contracts/abis/aladdin-convex-vault.json create mode 100644 src/apps/concentrator/contracts/abis/aladdin-crv.json create mode 100644 src/apps/concentrator/contracts/ethers/AladdinConvexVault.ts create mode 100644 src/apps/concentrator/contracts/ethers/AladdinCrv.ts create mode 100644 src/apps/concentrator/contracts/ethers/common.ts create mode 100644 src/apps/concentrator/contracts/ethers/factories/AladdinConvexVault__factory.ts create mode 100644 src/apps/concentrator/contracts/ethers/factories/AladdinCrv__factory.ts create mode 100644 src/apps/concentrator/contracts/ethers/factories/index.ts create mode 100644 src/apps/concentrator/contracts/ethers/index.ts create mode 100644 src/apps/concentrator/contracts/index.ts create mode 100644 src/apps/concentrator/ethereum/concentrator.acrv.token-fetcher.ts create mode 100644 src/apps/concentrator/ethereum/concentrator.balance-fetcher.ts create mode 100644 src/apps/concentrator/ethereum/concentrator.pool.contract-position-fetcher.ts diff --git a/src/apps/concentrator/assets/logo.png b/src/apps/concentrator/assets/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..438989926960da5cac6d699cfe6b5be77c25ff0c GIT binary patch literal 4400 zcmV-05zp?4P)Px_>PbXFRA_;{nrm=e#g)f@r|-QpqtT2Wwq#2q>t#J=3^ou1;SmQ!2n2|=kOWBK z6cmBQ>_V1JFq^Qoo5EC5Nfm2YD*2G$CD~LG>?A;5W(!0rf3=N z1E78AA?mV8I0d$H2bU?z_x$?i;^sIwYByqCIc64&WwymNq5HciWL--&@7fQh@^ z0Br4EkFsU=2H^vE?mcYFHjS|_6OHr|RrUCCI!F#1AHv!wXD4o^ zD?X1PxB|=&3*&dw99ama7gRszjIXE8nb|+2@@&iGh&#QEcWtCDn>p^a{05GC9Bn>@C5x30u`GTrso*LA zB5oZ~wGg2L$9Wo0PNPEo455el&Jdn_n3(fR#IB^I*KykDzmrf+03_5}w7Hkvnf$Rq zDoD~gv~mupIh&$=Wc3`(lFgqd6-nXi4YZA{!g1FlY6a7!pCY7C(F9e_DJ*b(D&4aX zo=2Grh^t9rZu*e6mL|@oBeoO~kEDAQi=#dPx1r7N*;`tUl|gD^r{i!YZ*+W{w&67x zwT^A&n3H3I9Pmn|>cg0RwqUKQmR=%chz94Az*cq!FOpDKq0RRh z2{P2H7}&SjT%5)-L_=gA1#=2dwS4Sg^Nv5*$GZCQ_0IB)loCRr*QOr z`1X1nbsq)$AW?M#=Oy>j;Qlj~9aO3kj!H4lwaoKcs8+QAoS$6EIf;+riKQvpMO!q3 z%Wm4@x6o5LiKk9wUL;42m!>f?j^fkQICs3;JmYQQ-@Td|?^o;%Z%6S3o>=tMyUi0CU%!l@C5W5kPfErazwWk;@L|7c1LQ6gK zBQcVW#ac^Xg{U}qN>Q>Qg2iAcghI@5*%Op-WD-y2v$?bfYj-g?TS;KP$8Q#W7lFM@(&^ zE^-NR8Ko|A8cCHW?p9HD2}HU0v*P^gmIIkoadMvE74R&t76 zK|RgU860V#&a=dn0u;VA#FXG*3GF0?83F>LQjbFdW6LHPEP=5&I82&pX0)Kqg?zE{ zrQ-uRSdFh=hVT~qi3Ret-ZwjLAY zfT~{aq^aVE82cxX2T8>egu#6%X$5;93u0#wm6gQQA83eNgy6F%T18U1xJuy)Xx;|- z6xYbp@7Z1%>SnOt1Y*qS=eWW9(0ko-WRUVZ<3gaHv93)3bd20URQ(OwR^ah17F787 z;lHvV(!`S3cJjJ|GZG63q)4?>i6;t$#mFSvVPOEu|!F&qzmpP~Aava8(?`@?@T}sq(sBveBNi{JC90AzD z)vEP`0RBSlpS7}ST&Me;>M+Onl7YEmT{cPF>7^-pBem|?g!XCXxmjZBBUGrfab%W` zSP@uAD(V7YWhWJ~`a3@xN&qD9lw0l)ds|c2xaMVZ0`&G=S zkW(v#sB%z%ryf0-5O6#mY0jpIxQ$qoW`3lDj*1&`sKP3R7(=GAz?;&+dlOLeQOOSFG5?8e(-C7h1WAl8*t9{=s zf0y1FS_gfk9HP2x60PHiQ+G(cwgH}9LcvtxC`C06o)Uz}`)ct~bmSNTNM}9XE5nPU^;1y zp3B1MQf7^hh)Y}?T#me9@jmO=!QL{`0|6-2LsRUdB%O;8DPk;WJ4!kpqcK{CD-Lb3 z6bc6=8b?0PC*-#$i2*p0N7_bKVRaf&c_0Vw5Jm>rV>dEis@NVTs8ye4S>??*R4^5W z#8rvV`alG%;BXyqQbFE(`aN@N588YNvC9zJ&@zJ6&vIc+iYZ%5+&POgDqF#ZRC^8% zE=uxTt*TFg{c}1Tq%NBz;hc$~3Pm1eGb9`Z@_SxgJjfN>ze3!(1|{{tHWs>DX{uO` zZxggeEm84sl*O?d_@s0F$pa}H-h(+1q>^L2bKsDx+J<{k>O#b(Xo*%*Eq`Kb|?mbvP<&VCv<%c^7g8yK1=dEn%UQdO4 z36|$kb`helq$%gL#@}!KD`@jExt7rjio}Gu;!2aBv^jJmTd@c;o;J2 zY_NytVUD0<2YYiig;Kqs8ZqGpTIT0@d%6eAom9#&rzErFN`H&k1m{%kU`8)zQEU&@ z?gHXU<4F{44H0F~JWGY#@}6t3pV>MOT1I*hdco{u z#%yGFCQoLh2UrEN6C11}6~7tJxgEpz$y9t0SI)-h-_e!0g3wOj+j^QJf+q@B6vkRy zWzlvVZ66_`22gCpAwftp+APAzttgt2{jUYzT4uCnU+@Q3S6+5vAgx0y5y>&u)jwC4 z*|G}g!TJv{m>J~U@rQ}4Gnp*iK_FLgda{ooc#J^ZPMh~X#Jx*c=Qxp9jjo#-dg)g#4FC(3p0zHrVXbfvZTxE$$gpz@n5<+WD5Vhe}yPp#O`p&UMu2 zPF(Y4M6PFAHuLIqJ5&C(OqBi}vA@HpB_P{*HSe-3+{CO|Ld2OsQzRco@vYCSnPJBG zZ1YPLO~~8fKDHNpEP}FAY%lF)Td|fs;mf=@J%eSM>PQS@g?-_MztAH##n$v{a+yI= z*))Ds@#^C9$?I-hvzmSSADObNF?t7;>IJlJ;H~0!32i-7K^|>)^Zb-YcIHV8mglE- zv!ghO)`o3G!(_M{YYP;O!=}mCnehLYgu4i@g5qKxjGu}Bs`*0tY9=3F^WO2p6fQm6$`UiISpXJ%Hc8uXFVlK}TxM_%VytToscf3v;SgTMwb;m7jJluJ=v{>N4fd8A zd2#A7Cj1VxeVXSc3+%Dq0%Pc(`UNk~mS@GOaFXr5k8daO^(b1p$pw!w611{6e4dFQ zhmw#+uN`a0X^MOv6Fz`)?>snJdu)(YHci~^W~{4!ZYNSpjgB(1R4%T?*KsiC`u3~HF{j_J( z2rC#`d_Qd?s~DTTl^vz!81o7xljJS`cjQbb0k5&kw@ijlfOr)7Ay4i5KeT!n07t!q z)~B;8{0$Sq4Az9yd5g7SF=`zu>?#hhaI6d=Xyn zxSRIjK9F+$F|XJ0OePPM@7q%P+My4Yojl(?*fHv|NvzzDM9Z-% zrkA>GlJTyM#GT#)PdG7<@y>z6hFf{&=w+;{pSo<4Fx0d!dQ^g%=HuLs$kDWBLm*c%1%b8uqIy; + +export type AddPoolEventFilter = TypedEventFilter; + +export interface ClaimEventObject { + _sender: string; + _reward: BigNumber; + _option: number; +} +export type ClaimEvent = TypedEvent<[string, BigNumber, number], ClaimEventObject>; + +export type ClaimEventFilter = TypedEventFilter; + +export interface DepositEventObject { + _pid: BigNumber; + _sender: string; + _amount: BigNumber; +} +export type DepositEvent = TypedEvent<[BigNumber, string, BigNumber], DepositEventObject>; + +export type DepositEventFilter = TypedEventFilter; + +export interface HarvestEventObject { + _caller: string; + _reward: BigNumber; + _platformFee: BigNumber; + _harvestBounty: BigNumber; +} +export type HarvestEvent = TypedEvent<[string, BigNumber, BigNumber, BigNumber], HarvestEventObject>; + +export type HarvestEventFilter = TypedEventFilter; + +export interface OwnershipTransferredEventObject { + previousOwner: string; + newOwner: string; +} +export type OwnershipTransferredEvent = TypedEvent<[string, string], OwnershipTransferredEventObject>; + +export type OwnershipTransferredEventFilter = TypedEventFilter; + +export interface PausePoolDepositEventObject { + _pid: BigNumber; + _status: boolean; +} +export type PausePoolDepositEvent = TypedEvent<[BigNumber, boolean], PausePoolDepositEventObject>; + +export type PausePoolDepositEventFilter = TypedEventFilter; + +export interface PausePoolWithdrawEventObject { + _pid: BigNumber; + _status: boolean; +} +export type PausePoolWithdrawEvent = TypedEvent<[BigNumber, boolean], PausePoolWithdrawEventObject>; + +export type PausePoolWithdrawEventFilter = TypedEventFilter; + +export interface UpdateHarvestBountyPercentageEventObject { + _pid: BigNumber; + _percentage: BigNumber; +} +export type UpdateHarvestBountyPercentageEvent = TypedEvent< + [BigNumber, BigNumber], + UpdateHarvestBountyPercentageEventObject +>; + +export type UpdateHarvestBountyPercentageEventFilter = TypedEventFilter; + +export interface UpdatePlatformEventObject { + _platform: string; +} +export type UpdatePlatformEvent = TypedEvent<[string], UpdatePlatformEventObject>; + +export type UpdatePlatformEventFilter = TypedEventFilter; + +export interface UpdatePlatformFeePercentageEventObject { + _pid: BigNumber; + _feePercentage: BigNumber; +} +export type UpdatePlatformFeePercentageEvent = TypedEvent< + [BigNumber, BigNumber], + UpdatePlatformFeePercentageEventObject +>; + +export type UpdatePlatformFeePercentageEventFilter = TypedEventFilter; + +export interface UpdatePoolRewardTokensEventObject { + _pid: BigNumber; + _rewardTokens: string[]; +} +export type UpdatePoolRewardTokensEvent = TypedEvent<[BigNumber, string[]], UpdatePoolRewardTokensEventObject>; + +export type UpdatePoolRewardTokensEventFilter = TypedEventFilter; + +export interface UpdateWithdrawalFeePercentageEventObject { + _pid: BigNumber; + _feePercentage: BigNumber; +} +export type UpdateWithdrawalFeePercentageEvent = TypedEvent< + [BigNumber, BigNumber], + UpdateWithdrawalFeePercentageEventObject +>; + +export type UpdateWithdrawalFeePercentageEventFilter = TypedEventFilter; + +export interface UpdateZapEventObject { + _zap: string; +} +export type UpdateZapEvent = TypedEvent<[string], UpdateZapEventObject>; + +export type UpdateZapEventFilter = TypedEventFilter; + +export interface WithdrawEventObject { + _pid: BigNumber; + _sender: string; + _shares: BigNumber; +} +export type WithdrawEvent = TypedEvent<[BigNumber, string, BigNumber], WithdrawEventObject>; + +export type WithdrawEventFilter = TypedEventFilter; + +export interface AladdinConvexVault extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: AladdinConvexVaultInterface; + + 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: { + addPool( + _convexPid: BigNumberish, + _rewardTokens: string[], + _withdrawFeePercentage: BigNumberish, + _platformFeePercentage: BigNumberish, + _harvestBountyPercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + aladdinCRV(overrides?: CallOverrides): Promise<[string]>; + + claim( + _pid: BigNumberish, + _minOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + claimAll( + _minOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + deposit( + _pid: BigNumberish, + _amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + depositAll( + _pid: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + harvest( + _pid: BigNumberish, + _recipient: string, + _minimumOut: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + initialize( + _aladdinCRV: string, + _zap: string, + _platform: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + owner(overrides?: CallOverrides): Promise<[string]>; + + pausePoolDeposit( + _pid: BigNumberish, + _status: boolean, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + pausePoolWithdraw( + _pid: BigNumberish, + _status: boolean, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + pendingReward(_pid: BigNumberish, _account: string, overrides?: CallOverrides): Promise<[BigNumber]>; + + pendingRewardAll(_account: string, overrides?: CallOverrides): Promise<[BigNumber]>; + + platform(overrides?: CallOverrides): Promise<[string]>; + + poolInfo( + arg0: BigNumberish, + overrides?: CallOverrides, + ): Promise< + [ + BigNumber, + BigNumber, + BigNumber, + BigNumber, + string, + string, + BigNumber, + BigNumber, + BigNumber, + boolean, + boolean, + ] & { + totalUnderlying: BigNumber; + totalShare: BigNumber; + accRewardPerShare: BigNumber; + convexPoolId: BigNumber; + lpToken: string; + crvRewards: string; + withdrawFeePercentage: BigNumber; + platformFeePercentage: BigNumber; + harvestBountyPercentage: BigNumber; + pauseDeposit: boolean; + pauseWithdraw: boolean; + } + >; + + poolLength(overrides?: CallOverrides): Promise<[BigNumber] & { pools: BigNumber }>; + + renounceOwnership(overrides?: Overrides & { from?: string | Promise }): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateHarvestBountyPercentage( + _pid: BigNumberish, + _percentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updatePlatform( + _platform: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updatePlatformFeePercentage( + _pid: BigNumberish, + _feePercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updatePoolRewardTokens( + _pid: BigNumberish, + _rewardTokens: string[], + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateWithdrawFeePercentage( + _pid: BigNumberish, + _feePercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateZap(_zap: string, overrides?: Overrides & { from?: string | Promise }): Promise; + + userInfo( + arg0: BigNumberish, + arg1: string, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber, BigNumber] & { + shares: BigNumber; + rewards: BigNumber; + rewardPerSharePaid: BigNumber; + } + >; + + withdrawAllAndClaim( + _pid: BigNumberish, + _minOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + withdrawAllAndZap( + _pid: BigNumberish, + _token: string, + _minOut: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + withdrawAndClaim( + _pid: BigNumberish, + _shares: BigNumberish, + _minOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + withdrawAndZap( + _pid: BigNumberish, + _shares: BigNumberish, + _token: string, + _minOut: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + zap(overrides?: CallOverrides): Promise<[string]>; + + zapAllAndDeposit( + _pid: BigNumberish, + _token: string, + _minAmount: BigNumberish, + overrides?: PayableOverrides & { from?: string | Promise }, + ): Promise; + + zapAndDeposit( + _pid: BigNumberish, + _token: string, + _amount: BigNumberish, + _minAmount: BigNumberish, + overrides?: PayableOverrides & { from?: string | Promise }, + ): Promise; + }; + + addPool( + _convexPid: BigNumberish, + _rewardTokens: string[], + _withdrawFeePercentage: BigNumberish, + _platformFeePercentage: BigNumberish, + _harvestBountyPercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + aladdinCRV(overrides?: CallOverrides): Promise; + + claim( + _pid: BigNumberish, + _minOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + claimAll( + _minOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + deposit( + _pid: BigNumberish, + _amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + depositAll( + _pid: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + harvest( + _pid: BigNumberish, + _recipient: string, + _minimumOut: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + initialize( + _aladdinCRV: string, + _zap: string, + _platform: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + pausePoolDeposit( + _pid: BigNumberish, + _status: boolean, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + pausePoolWithdraw( + _pid: BigNumberish, + _status: boolean, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + pendingReward(_pid: BigNumberish, _account: string, overrides?: CallOverrides): Promise; + + pendingRewardAll(_account: string, overrides?: CallOverrides): Promise; + + platform(overrides?: CallOverrides): Promise; + + poolInfo( + arg0: BigNumberish, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber, BigNumber, BigNumber, string, string, BigNumber, BigNumber, BigNumber, boolean, boolean] & { + totalUnderlying: BigNumber; + totalShare: BigNumber; + accRewardPerShare: BigNumber; + convexPoolId: BigNumber; + lpToken: string; + crvRewards: string; + withdrawFeePercentage: BigNumber; + platformFeePercentage: BigNumber; + harvestBountyPercentage: BigNumber; + pauseDeposit: boolean; + pauseWithdraw: boolean; + } + >; + + poolLength(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: Overrides & { from?: string | Promise }): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateHarvestBountyPercentage( + _pid: BigNumberish, + _percentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updatePlatform( + _platform: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updatePlatformFeePercentage( + _pid: BigNumberish, + _feePercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updatePoolRewardTokens( + _pid: BigNumberish, + _rewardTokens: string[], + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateWithdrawFeePercentage( + _pid: BigNumberish, + _feePercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateZap(_zap: string, overrides?: Overrides & { from?: string | Promise }): Promise; + + userInfo( + arg0: BigNumberish, + arg1: string, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber, BigNumber] & { + shares: BigNumber; + rewards: BigNumber; + rewardPerSharePaid: BigNumber; + } + >; + + withdrawAllAndClaim( + _pid: BigNumberish, + _minOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + withdrawAllAndZap( + _pid: BigNumberish, + _token: string, + _minOut: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + withdrawAndClaim( + _pid: BigNumberish, + _shares: BigNumberish, + _minOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + withdrawAndZap( + _pid: BigNumberish, + _shares: BigNumberish, + _token: string, + _minOut: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + zap(overrides?: CallOverrides): Promise; + + zapAllAndDeposit( + _pid: BigNumberish, + _token: string, + _minAmount: BigNumberish, + overrides?: PayableOverrides & { from?: string | Promise }, + ): Promise; + + zapAndDeposit( + _pid: BigNumberish, + _token: string, + _amount: BigNumberish, + _minAmount: BigNumberish, + overrides?: PayableOverrides & { from?: string | Promise }, + ): Promise; + + callStatic: { + addPool( + _convexPid: BigNumberish, + _rewardTokens: string[], + _withdrawFeePercentage: BigNumberish, + _platformFeePercentage: BigNumberish, + _harvestBountyPercentage: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + aladdinCRV(overrides?: CallOverrides): Promise; + + claim( + _pid: BigNumberish, + _minOut: BigNumberish, + _option: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + claimAll(_minOut: BigNumberish, _option: BigNumberish, overrides?: CallOverrides): Promise; + + deposit(_pid: BigNumberish, _amount: BigNumberish, overrides?: CallOverrides): Promise; + + depositAll(_pid: BigNumberish, overrides?: CallOverrides): Promise; + + harvest( + _pid: BigNumberish, + _recipient: string, + _minimumOut: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + initialize(_aladdinCRV: string, _zap: string, _platform: string, overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + pausePoolDeposit(_pid: BigNumberish, _status: boolean, overrides?: CallOverrides): Promise; + + pausePoolWithdraw(_pid: BigNumberish, _status: boolean, overrides?: CallOverrides): Promise; + + pendingReward(_pid: BigNumberish, _account: string, overrides?: CallOverrides): Promise; + + pendingRewardAll(_account: string, overrides?: CallOverrides): Promise; + + platform(overrides?: CallOverrides): Promise; + + poolInfo( + arg0: BigNumberish, + overrides?: CallOverrides, + ): Promise< + [ + BigNumber, + BigNumber, + BigNumber, + BigNumber, + string, + string, + BigNumber, + BigNumber, + BigNumber, + boolean, + boolean, + ] & { + totalUnderlying: BigNumber; + totalShare: BigNumber; + accRewardPerShare: BigNumber; + convexPoolId: BigNumber; + lpToken: string; + crvRewards: string; + withdrawFeePercentage: BigNumber; + platformFeePercentage: BigNumber; + harvestBountyPercentage: BigNumber; + pauseDeposit: boolean; + pauseWithdraw: boolean; + } + >; + + poolLength(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: CallOverrides): Promise; + + transferOwnership(newOwner: string, overrides?: CallOverrides): Promise; + + updateHarvestBountyPercentage( + _pid: BigNumberish, + _percentage: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + updatePlatform(_platform: string, overrides?: CallOverrides): Promise; + + updatePlatformFeePercentage( + _pid: BigNumberish, + _feePercentage: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + updatePoolRewardTokens(_pid: BigNumberish, _rewardTokens: string[], overrides?: CallOverrides): Promise; + + updateWithdrawFeePercentage( + _pid: BigNumberish, + _feePercentage: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + updateZap(_zap: string, overrides?: CallOverrides): Promise; + + userInfo( + arg0: BigNumberish, + arg1: string, + overrides?: CallOverrides, + ): Promise< + [BigNumber, BigNumber, BigNumber] & { + shares: BigNumber; + rewards: BigNumber; + rewardPerSharePaid: BigNumber; + } + >; + + withdrawAllAndClaim( + _pid: BigNumberish, + _minOut: BigNumberish, + _option: BigNumberish, + overrides?: CallOverrides, + ): Promise<[BigNumber, BigNumber] & { withdrawn: BigNumber; claimed: BigNumber }>; + + withdrawAllAndZap( + _pid: BigNumberish, + _token: string, + _minOut: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + withdrawAndClaim( + _pid: BigNumberish, + _shares: BigNumberish, + _minOut: BigNumberish, + _option: BigNumberish, + overrides?: CallOverrides, + ): Promise<[BigNumber, BigNumber] & { withdrawn: BigNumber; claimed: BigNumber }>; + + withdrawAndZap( + _pid: BigNumberish, + _shares: BigNumberish, + _token: string, + _minOut: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + zap(overrides?: CallOverrides): Promise; + + zapAllAndDeposit( + _pid: BigNumberish, + _token: string, + _minAmount: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + zapAndDeposit( + _pid: BigNumberish, + _token: string, + _amount: BigNumberish, + _minAmount: BigNumberish, + overrides?: CallOverrides, + ): Promise; + }; + + filters: { + 'AddPool(uint256,uint256,address[])'( + _pid?: BigNumberish | null, + _convexPid?: null, + _rewardTokens?: null, + ): AddPoolEventFilter; + AddPool(_pid?: BigNumberish | null, _convexPid?: null, _rewardTokens?: null): AddPoolEventFilter; + + 'Claim(address,uint256,uint8)'(_sender?: string | null, _reward?: null, _option?: null): ClaimEventFilter; + Claim(_sender?: string | null, _reward?: null, _option?: null): ClaimEventFilter; + + 'Deposit(uint256,address,uint256)'( + _pid?: BigNumberish | null, + _sender?: string | null, + _amount?: null, + ): DepositEventFilter; + Deposit(_pid?: BigNumberish | null, _sender?: string | null, _amount?: null): DepositEventFilter; + + 'Harvest(address,uint256,uint256,uint256)'( + _caller?: string | null, + _reward?: null, + _platformFee?: null, + _harvestBounty?: null, + ): HarvestEventFilter; + Harvest(_caller?: string | null, _reward?: null, _platformFee?: null, _harvestBounty?: null): HarvestEventFilter; + + 'OwnershipTransferred(address,address)'( + previousOwner?: string | null, + newOwner?: string | null, + ): OwnershipTransferredEventFilter; + OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter; + + 'PausePoolDeposit(uint256,bool)'(_pid?: BigNumberish | null, _status?: null): PausePoolDepositEventFilter; + PausePoolDeposit(_pid?: BigNumberish | null, _status?: null): PausePoolDepositEventFilter; + + 'PausePoolWithdraw(uint256,bool)'(_pid?: BigNumberish | null, _status?: null): PausePoolWithdrawEventFilter; + PausePoolWithdraw(_pid?: BigNumberish | null, _status?: null): PausePoolWithdrawEventFilter; + + 'UpdateHarvestBountyPercentage(uint256,uint256)'( + _pid?: BigNumberish | null, + _percentage?: null, + ): UpdateHarvestBountyPercentageEventFilter; + UpdateHarvestBountyPercentage( + _pid?: BigNumberish | null, + _percentage?: null, + ): UpdateHarvestBountyPercentageEventFilter; + + 'UpdatePlatform(address)'(_platform?: string | null): UpdatePlatformEventFilter; + UpdatePlatform(_platform?: string | null): UpdatePlatformEventFilter; + + 'UpdatePlatformFeePercentage(uint256,uint256)'( + _pid?: BigNumberish | null, + _feePercentage?: null, + ): UpdatePlatformFeePercentageEventFilter; + UpdatePlatformFeePercentage( + _pid?: BigNumberish | null, + _feePercentage?: null, + ): UpdatePlatformFeePercentageEventFilter; + + 'UpdatePoolRewardTokens(uint256,address[])'( + _pid?: BigNumberish | null, + _rewardTokens?: null, + ): UpdatePoolRewardTokensEventFilter; + UpdatePoolRewardTokens(_pid?: BigNumberish | null, _rewardTokens?: null): UpdatePoolRewardTokensEventFilter; + + 'UpdateWithdrawalFeePercentage(uint256,uint256)'( + _pid?: BigNumberish | null, + _feePercentage?: null, + ): UpdateWithdrawalFeePercentageEventFilter; + UpdateWithdrawalFeePercentage( + _pid?: BigNumberish | null, + _feePercentage?: null, + ): UpdateWithdrawalFeePercentageEventFilter; + + 'UpdateZap(address)'(_zap?: string | null): UpdateZapEventFilter; + UpdateZap(_zap?: string | null): UpdateZapEventFilter; + + 'Withdraw(uint256,address,uint256)'( + _pid?: BigNumberish | null, + _sender?: string | null, + _shares?: null, + ): WithdrawEventFilter; + Withdraw(_pid?: BigNumberish | null, _sender?: string | null, _shares?: null): WithdrawEventFilter; + }; + + estimateGas: { + addPool( + _convexPid: BigNumberish, + _rewardTokens: string[], + _withdrawFeePercentage: BigNumberish, + _platformFeePercentage: BigNumberish, + _harvestBountyPercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + aladdinCRV(overrides?: CallOverrides): Promise; + + claim( + _pid: BigNumberish, + _minOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + claimAll( + _minOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + deposit( + _pid: BigNumberish, + _amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + depositAll(_pid: BigNumberish, overrides?: Overrides & { from?: string | Promise }): Promise; + + harvest( + _pid: BigNumberish, + _recipient: string, + _minimumOut: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + initialize( + _aladdinCRV: string, + _zap: string, + _platform: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + pausePoolDeposit( + _pid: BigNumberish, + _status: boolean, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + pausePoolWithdraw( + _pid: BigNumberish, + _status: boolean, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + pendingReward(_pid: BigNumberish, _account: string, overrides?: CallOverrides): Promise; + + pendingRewardAll(_account: string, overrides?: CallOverrides): Promise; + + platform(overrides?: CallOverrides): Promise; + + poolInfo(arg0: BigNumberish, overrides?: CallOverrides): Promise; + + poolLength(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: Overrides & { from?: string | Promise }): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateHarvestBountyPercentage( + _pid: BigNumberish, + _percentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updatePlatform(_platform: string, overrides?: Overrides & { from?: string | Promise }): Promise; + + updatePlatformFeePercentage( + _pid: BigNumberish, + _feePercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updatePoolRewardTokens( + _pid: BigNumberish, + _rewardTokens: string[], + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateWithdrawFeePercentage( + _pid: BigNumberish, + _feePercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateZap(_zap: string, overrides?: Overrides & { from?: string | Promise }): Promise; + + userInfo(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise; + + withdrawAllAndClaim( + _pid: BigNumberish, + _minOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + withdrawAllAndZap( + _pid: BigNumberish, + _token: string, + _minOut: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + withdrawAndClaim( + _pid: BigNumberish, + _shares: BigNumberish, + _minOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + withdrawAndZap( + _pid: BigNumberish, + _shares: BigNumberish, + _token: string, + _minOut: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + zap(overrides?: CallOverrides): Promise; + + zapAllAndDeposit( + _pid: BigNumberish, + _token: string, + _minAmount: BigNumberish, + overrides?: PayableOverrides & { from?: string | Promise }, + ): Promise; + + zapAndDeposit( + _pid: BigNumberish, + _token: string, + _amount: BigNumberish, + _minAmount: BigNumberish, + overrides?: PayableOverrides & { from?: string | Promise }, + ): Promise; + }; + + populateTransaction: { + addPool( + _convexPid: BigNumberish, + _rewardTokens: string[], + _withdrawFeePercentage: BigNumberish, + _platformFeePercentage: BigNumberish, + _harvestBountyPercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + aladdinCRV(overrides?: CallOverrides): Promise; + + claim( + _pid: BigNumberish, + _minOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + claimAll( + _minOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + deposit( + _pid: BigNumberish, + _amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + depositAll( + _pid: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + harvest( + _pid: BigNumberish, + _recipient: string, + _minimumOut: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + initialize( + _aladdinCRV: string, + _zap: string, + _platform: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + pausePoolDeposit( + _pid: BigNumberish, + _status: boolean, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + pausePoolWithdraw( + _pid: BigNumberish, + _status: boolean, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + pendingReward(_pid: BigNumberish, _account: string, overrides?: CallOverrides): Promise; + + pendingRewardAll(_account: string, overrides?: CallOverrides): Promise; + + platform(overrides?: CallOverrides): Promise; + + poolInfo(arg0: BigNumberish, overrides?: CallOverrides): Promise; + + poolLength(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: Overrides & { from?: string | Promise }): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateHarvestBountyPercentage( + _pid: BigNumberish, + _percentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updatePlatform( + _platform: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updatePlatformFeePercentage( + _pid: BigNumberish, + _feePercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updatePoolRewardTokens( + _pid: BigNumberish, + _rewardTokens: string[], + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateWithdrawFeePercentage( + _pid: BigNumberish, + _feePercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateZap(_zap: string, overrides?: Overrides & { from?: string | Promise }): Promise; + + userInfo(arg0: BigNumberish, arg1: string, overrides?: CallOverrides): Promise; + + withdrawAllAndClaim( + _pid: BigNumberish, + _minOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + withdrawAllAndZap( + _pid: BigNumberish, + _token: string, + _minOut: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + withdrawAndClaim( + _pid: BigNumberish, + _shares: BigNumberish, + _minOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + withdrawAndZap( + _pid: BigNumberish, + _shares: BigNumberish, + _token: string, + _minOut: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + zap(overrides?: CallOverrides): Promise; + + zapAllAndDeposit( + _pid: BigNumberish, + _token: string, + _minAmount: BigNumberish, + overrides?: PayableOverrides & { from?: string | Promise }, + ): Promise; + + zapAndDeposit( + _pid: BigNumberish, + _token: string, + _amount: BigNumberish, + _minAmount: BigNumberish, + overrides?: PayableOverrides & { from?: string | Promise }, + ): Promise; + }; +} diff --git a/src/apps/concentrator/contracts/ethers/AladdinCrv.ts b/src/apps/concentrator/contracts/ethers/AladdinCrv.ts new file mode 100644 index 000000000..3f2664eef --- /dev/null +++ b/src/apps/concentrator/contracts/ethers/AladdinCrv.ts @@ -0,0 +1,1103 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from 'ethers'; +import type { FunctionFragment, Result, EventFragment } from '@ethersproject/abi'; +import type { Listener, Provider } from '@ethersproject/providers'; +import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from './common'; + +export interface AladdinCrvInterface extends utils.Interface { + functions: { + 'allowance(address,address)': FunctionFragment; + 'approve(address,uint256)': FunctionFragment; + 'balanceOf(address)': FunctionFragment; + 'balanceOfUnderlying(address)': FunctionFragment; + 'claimEPS(address,address,uint256,uint256,uint256,bytes32[])': FunctionFragment; + 'decimals()': FunctionFragment; + 'decreaseAllowance(address,uint256)': FunctionFragment; + 'deposit(address,uint256)': FunctionFragment; + 'depositAll(address)': FunctionFragment; + 'depositAllWithCRV(address)': FunctionFragment; + 'depositWithCRV(address,uint256)': FunctionFragment; + 'harvest(address,uint256)': FunctionFragment; + 'harvestBountyPercentage()': FunctionFragment; + 'increaseAllowance(address,uint256)': FunctionFragment; + 'initialize(address,address,uint256,uint256,uint256)': FunctionFragment; + 'name()': FunctionFragment; + 'owner()': FunctionFragment; + 'pending3CRVRewards()': FunctionFragment; + 'pendingCRVRewards()': FunctionFragment; + 'pendingCVXRewards()': FunctionFragment; + 'platform()': FunctionFragment; + 'platformFeePercentage()': FunctionFragment; + 'renounceOwnership()': FunctionFragment; + 'symbol()': FunctionFragment; + 'totalSupply()': FunctionFragment; + 'totalUnderlying()': FunctionFragment; + 'transfer(address,uint256)': FunctionFragment; + 'transferFrom(address,address,uint256)': FunctionFragment; + 'transferOwnership(address)': FunctionFragment; + 'updateHarvestBountyPercentage(uint256)': FunctionFragment; + 'updatePlatform(address)': FunctionFragment; + 'updatePlatformFeePercentage(uint256)': FunctionFragment; + 'updateWithdrawFeePercentage(uint256)': FunctionFragment; + 'updateZap(address)': FunctionFragment; + 'withdraw(address,uint256,uint256,uint8)': FunctionFragment; + 'withdrawAll(address,uint256,uint8)': FunctionFragment; + 'withdrawFeePercentage()': FunctionFragment; + 'zap()': FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | 'allowance' + | 'approve' + | 'balanceOf' + | 'balanceOfUnderlying' + | 'claimEPS' + | 'decimals' + | 'decreaseAllowance' + | 'deposit' + | 'depositAll' + | 'depositAllWithCRV' + | 'depositWithCRV' + | 'harvest' + | 'harvestBountyPercentage' + | 'increaseAllowance' + | 'initialize' + | 'name' + | 'owner' + | 'pending3CRVRewards' + | 'pendingCRVRewards' + | 'pendingCVXRewards' + | 'platform' + | 'platformFeePercentage' + | 'renounceOwnership' + | 'symbol' + | 'totalSupply' + | 'totalUnderlying' + | 'transfer' + | 'transferFrom' + | 'transferOwnership' + | 'updateHarvestBountyPercentage' + | 'updatePlatform' + | 'updatePlatformFeePercentage' + | 'updateWithdrawFeePercentage' + | 'updateZap' + | 'withdraw' + | 'withdrawAll' + | 'withdrawFeePercentage' + | 'zap', + ): FunctionFragment; + + encodeFunctionData(functionFragment: 'allowance', values: [string, string]): string; + encodeFunctionData(functionFragment: 'approve', values: [string, BigNumberish]): string; + encodeFunctionData(functionFragment: 'balanceOf', values: [string]): string; + encodeFunctionData(functionFragment: 'balanceOfUnderlying', values: [string]): string; + encodeFunctionData( + functionFragment: 'claimEPS', + values: [string, string, BigNumberish, BigNumberish, BigNumberish, BytesLike[]], + ): string; + encodeFunctionData(functionFragment: 'decimals', values?: undefined): string; + encodeFunctionData(functionFragment: 'decreaseAllowance', values: [string, BigNumberish]): string; + encodeFunctionData(functionFragment: 'deposit', values: [string, BigNumberish]): string; + encodeFunctionData(functionFragment: 'depositAll', values: [string]): string; + encodeFunctionData(functionFragment: 'depositAllWithCRV', values: [string]): string; + encodeFunctionData(functionFragment: 'depositWithCRV', values: [string, BigNumberish]): string; + encodeFunctionData(functionFragment: 'harvest', values: [string, BigNumberish]): string; + encodeFunctionData(functionFragment: 'harvestBountyPercentage', values?: undefined): string; + encodeFunctionData(functionFragment: 'increaseAllowance', values: [string, BigNumberish]): string; + encodeFunctionData( + functionFragment: 'initialize', + values: [string, string, BigNumberish, BigNumberish, BigNumberish], + ): string; + encodeFunctionData(functionFragment: 'name', values?: undefined): string; + encodeFunctionData(functionFragment: 'owner', values?: undefined): string; + encodeFunctionData(functionFragment: 'pending3CRVRewards', values?: undefined): string; + encodeFunctionData(functionFragment: 'pendingCRVRewards', values?: undefined): string; + encodeFunctionData(functionFragment: 'pendingCVXRewards', values?: undefined): string; + encodeFunctionData(functionFragment: 'platform', values?: undefined): string; + encodeFunctionData(functionFragment: 'platformFeePercentage', values?: undefined): string; + encodeFunctionData(functionFragment: 'renounceOwnership', values?: undefined): string; + encodeFunctionData(functionFragment: 'symbol', values?: undefined): string; + encodeFunctionData(functionFragment: 'totalSupply', values?: undefined): string; + encodeFunctionData(functionFragment: 'totalUnderlying', values?: undefined): string; + encodeFunctionData(functionFragment: 'transfer', values: [string, BigNumberish]): string; + encodeFunctionData(functionFragment: 'transferFrom', values: [string, string, BigNumberish]): string; + encodeFunctionData(functionFragment: 'transferOwnership', values: [string]): string; + encodeFunctionData(functionFragment: 'updateHarvestBountyPercentage', values: [BigNumberish]): string; + encodeFunctionData(functionFragment: 'updatePlatform', values: [string]): string; + encodeFunctionData(functionFragment: 'updatePlatformFeePercentage', values: [BigNumberish]): string; + encodeFunctionData(functionFragment: 'updateWithdrawFeePercentage', values: [BigNumberish]): string; + encodeFunctionData(functionFragment: 'updateZap', values: [string]): string; + encodeFunctionData(functionFragment: 'withdraw', values: [string, BigNumberish, BigNumberish, BigNumberish]): string; + encodeFunctionData(functionFragment: 'withdrawAll', values: [string, BigNumberish, BigNumberish]): string; + encodeFunctionData(functionFragment: 'withdrawFeePercentage', values?: undefined): string; + encodeFunctionData(functionFragment: 'zap', values?: undefined): string; + + decodeFunctionResult(functionFragment: 'allowance', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'approve', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'balanceOf', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'balanceOfUnderlying', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'claimEPS', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'decimals', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'decreaseAllowance', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'deposit', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'depositAll', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'depositAllWithCRV', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'depositWithCRV', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'harvest', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'harvestBountyPercentage', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'increaseAllowance', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'initialize', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'name', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'owner', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'pending3CRVRewards', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'pendingCRVRewards', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'pendingCVXRewards', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'platform', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'platformFeePercentage', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'renounceOwnership', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'symbol', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'totalSupply', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'totalUnderlying', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'transfer', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'transferFrom', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'transferOwnership', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'updateHarvestBountyPercentage', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'updatePlatform', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'updatePlatformFeePercentage', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'updateWithdrawFeePercentage', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'updateZap', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'withdraw', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'withdrawAll', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'withdrawFeePercentage', data: BytesLike): Result; + decodeFunctionResult(functionFragment: 'zap', data: BytesLike): Result; + + events: { + 'Approval(address,address,uint256)': EventFragment; + 'Deposit(address,address,uint256)': EventFragment; + 'Harvest(address,uint256)': EventFragment; + 'OwnershipTransferred(address,address)': EventFragment; + 'Transfer(address,address,uint256)': EventFragment; + 'UpdateHarvestBountyPercentage(uint256)': EventFragment; + 'UpdatePlatform(address)': EventFragment; + 'UpdatePlatformFeePercentage(uint256)': EventFragment; + 'UpdateWithdrawalFeePercentage(uint256)': EventFragment; + 'UpdateZap(address)': EventFragment; + 'Withdraw(address,address,uint256,uint8)': EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: 'Approval'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Deposit'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Harvest'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'OwnershipTransferred'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'Transfer'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'UpdateHarvestBountyPercentage'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'UpdatePlatform'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'UpdatePlatformFeePercentage'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'UpdateWithdrawalFeePercentage'): EventFragment; + getEvent(nameOrSignatureOrTopic: 'UpdateZap'): 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 DepositEventObject { + _sender: string; + _recipient: string; + _amount: BigNumber; +} +export type DepositEvent = TypedEvent<[string, string, BigNumber], DepositEventObject>; + +export type DepositEventFilter = TypedEventFilter; + +export interface HarvestEventObject { + _caller: string; + _amount: BigNumber; +} +export type HarvestEvent = TypedEvent<[string, BigNumber], HarvestEventObject>; + +export type HarvestEventFilter = TypedEventFilter; + +export interface OwnershipTransferredEventObject { + previousOwner: string; + newOwner: string; +} +export type OwnershipTransferredEvent = TypedEvent<[string, string], OwnershipTransferredEventObject>; + +export type OwnershipTransferredEventFilter = TypedEventFilter; + +export interface TransferEventObject { + from: string; + to: string; + value: BigNumber; +} +export type TransferEvent = TypedEvent<[string, string, BigNumber], TransferEventObject>; + +export type TransferEventFilter = TypedEventFilter; + +export interface UpdateHarvestBountyPercentageEventObject { + _percentage: BigNumber; +} +export type UpdateHarvestBountyPercentageEvent = TypedEvent<[BigNumber], UpdateHarvestBountyPercentageEventObject>; + +export type UpdateHarvestBountyPercentageEventFilter = TypedEventFilter; + +export interface UpdatePlatformEventObject { + _platform: string; +} +export type UpdatePlatformEvent = TypedEvent<[string], UpdatePlatformEventObject>; + +export type UpdatePlatformEventFilter = TypedEventFilter; + +export interface UpdatePlatformFeePercentageEventObject { + _feePercentage: BigNumber; +} +export type UpdatePlatformFeePercentageEvent = TypedEvent<[BigNumber], UpdatePlatformFeePercentageEventObject>; + +export type UpdatePlatformFeePercentageEventFilter = TypedEventFilter; + +export interface UpdateWithdrawalFeePercentageEventObject { + _feePercentage: BigNumber; +} +export type UpdateWithdrawalFeePercentageEvent = TypedEvent<[BigNumber], UpdateWithdrawalFeePercentageEventObject>; + +export type UpdateWithdrawalFeePercentageEventFilter = TypedEventFilter; + +export interface UpdateZapEventObject { + _zap: string; +} +export type UpdateZapEvent = TypedEvent<[string], UpdateZapEventObject>; + +export type UpdateZapEventFilter = TypedEventFilter; + +export interface WithdrawEventObject { + _sender: string; + _recipient: string; + _shares: BigNumber; + _option: number; +} +export type WithdrawEvent = TypedEvent<[string, string, BigNumber, number], WithdrawEventObject>; + +export type WithdrawEventFilter = TypedEventFilter; + +export interface AladdinCrv extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: AladdinCrvInterface; + + 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: { + allowance(owner: string, spender: string, overrides?: CallOverrides): Promise<[BigNumber]>; + + approve( + spender: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + balanceOf(account: string, overrides?: CallOverrides): Promise<[BigNumber]>; + + balanceOfUnderlying(_user: string, overrides?: CallOverrides): Promise<[BigNumber]>; + + claimEPS( + _distributor: string, + _recipient: string, + merkleIndex: BigNumberish, + index: BigNumberish, + amount: BigNumberish, + merkleProof: BytesLike[], + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + decimals(overrides?: CallOverrides): Promise<[number]>; + + decreaseAllowance( + spender: string, + subtractedValue: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + deposit( + _recipient: string, + _amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + depositAll( + _recipient: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + depositAllWithCRV( + _recipient: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + depositWithCRV( + _recipient: string, + _amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + harvest( + _recipient: string, + _minimumOut: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + harvestBountyPercentage(overrides?: CallOverrides): Promise<[BigNumber]>; + + increaseAllowance( + spender: string, + addedValue: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + initialize( + _zap: string, + _platform: string, + _withdrawFeePercentage: BigNumberish, + _platformFeePercentage: BigNumberish, + _harvestBountyPercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + name(overrides?: CallOverrides): Promise<[string]>; + + owner(overrides?: CallOverrides): Promise<[string]>; + + pending3CRVRewards(overrides?: CallOverrides): Promise<[BigNumber]>; + + pendingCRVRewards(overrides?: CallOverrides): Promise<[BigNumber]>; + + pendingCVXRewards(overrides?: CallOverrides): Promise<[BigNumber]>; + + platform(overrides?: CallOverrides): Promise<[string]>; + + platformFeePercentage(overrides?: CallOverrides): Promise<[BigNumber]>; + + renounceOwnership(overrides?: Overrides & { from?: string | Promise }): Promise; + + symbol(overrides?: CallOverrides): Promise<[string]>; + + totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>; + + totalUnderlying(overrides?: CallOverrides): Promise<[BigNumber]>; + + transfer( + recipient: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + transferFrom( + sender: string, + recipient: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateHarvestBountyPercentage( + _percentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updatePlatform( + _platform: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updatePlatformFeePercentage( + _feePercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateWithdrawFeePercentage( + _feePercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateZap(_zap: string, overrides?: Overrides & { from?: string | Promise }): Promise; + + withdraw( + _recipient: string, + _shares: BigNumberish, + _minimumOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + withdrawAll( + _recipient: string, + _minimumOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + withdrawFeePercentage(overrides?: CallOverrides): Promise<[BigNumber]>; + + zap(overrides?: CallOverrides): Promise<[string]>; + }; + + allowance(owner: string, spender: string, overrides?: CallOverrides): Promise; + + approve( + spender: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + balanceOf(account: string, overrides?: CallOverrides): Promise; + + balanceOfUnderlying(_user: string, overrides?: CallOverrides): Promise; + + claimEPS( + _distributor: string, + _recipient: string, + merkleIndex: BigNumberish, + index: BigNumberish, + amount: BigNumberish, + merkleProof: BytesLike[], + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + decreaseAllowance( + spender: string, + subtractedValue: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + deposit( + _recipient: string, + _amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + depositAll( + _recipient: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + depositAllWithCRV( + _recipient: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + depositWithCRV( + _recipient: string, + _amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + harvest( + _recipient: string, + _minimumOut: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + harvestBountyPercentage(overrides?: CallOverrides): Promise; + + increaseAllowance( + spender: string, + addedValue: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + initialize( + _zap: string, + _platform: string, + _withdrawFeePercentage: BigNumberish, + _platformFeePercentage: BigNumberish, + _harvestBountyPercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + name(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + pending3CRVRewards(overrides?: CallOverrides): Promise; + + pendingCRVRewards(overrides?: CallOverrides): Promise; + + pendingCVXRewards(overrides?: CallOverrides): Promise; + + platform(overrides?: CallOverrides): Promise; + + platformFeePercentage(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: Overrides & { from?: string | Promise }): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + totalUnderlying(overrides?: CallOverrides): Promise; + + transfer( + recipient: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + transferFrom( + sender: string, + recipient: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateHarvestBountyPercentage( + _percentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updatePlatform( + _platform: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updatePlatformFeePercentage( + _feePercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateWithdrawFeePercentage( + _feePercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateZap(_zap: string, overrides?: Overrides & { from?: string | Promise }): Promise; + + withdraw( + _recipient: string, + _shares: BigNumberish, + _minimumOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + withdrawAll( + _recipient: string, + _minimumOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + withdrawFeePercentage(overrides?: CallOverrides): Promise; + + zap(overrides?: CallOverrides): Promise; + + callStatic: { + allowance(owner: string, spender: string, overrides?: CallOverrides): Promise; + + approve(spender: string, amount: BigNumberish, overrides?: CallOverrides): Promise; + + balanceOf(account: string, overrides?: CallOverrides): Promise; + + balanceOfUnderlying(_user: string, overrides?: CallOverrides): Promise; + + claimEPS( + _distributor: string, + _recipient: string, + merkleIndex: BigNumberish, + index: BigNumberish, + amount: BigNumberish, + merkleProof: BytesLike[], + overrides?: CallOverrides, + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + decreaseAllowance(spender: string, subtractedValue: BigNumberish, overrides?: CallOverrides): Promise; + + deposit(_recipient: string, _amount: BigNumberish, overrides?: CallOverrides): Promise; + + depositAll(_recipient: string, overrides?: CallOverrides): Promise; + + depositAllWithCRV(_recipient: string, overrides?: CallOverrides): Promise; + + depositWithCRV(_recipient: string, _amount: BigNumberish, overrides?: CallOverrides): Promise; + + harvest(_recipient: string, _minimumOut: BigNumberish, overrides?: CallOverrides): Promise; + + harvestBountyPercentage(overrides?: CallOverrides): Promise; + + increaseAllowance(spender: string, addedValue: BigNumberish, overrides?: CallOverrides): Promise; + + initialize( + _zap: string, + _platform: string, + _withdrawFeePercentage: BigNumberish, + _platformFeePercentage: BigNumberish, + _harvestBountyPercentage: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + name(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + pending3CRVRewards(overrides?: CallOverrides): Promise; + + pendingCRVRewards(overrides?: CallOverrides): Promise; + + pendingCVXRewards(overrides?: CallOverrides): Promise; + + platform(overrides?: CallOverrides): Promise; + + platformFeePercentage(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + totalUnderlying(overrides?: CallOverrides): Promise; + + transfer(recipient: string, amount: BigNumberish, overrides?: CallOverrides): Promise; + + transferFrom(sender: string, recipient: string, amount: BigNumberish, overrides?: CallOverrides): Promise; + + transferOwnership(newOwner: string, overrides?: CallOverrides): Promise; + + updateHarvestBountyPercentage(_percentage: BigNumberish, overrides?: CallOverrides): Promise; + + updatePlatform(_platform: string, overrides?: CallOverrides): Promise; + + updatePlatformFeePercentage(_feePercentage: BigNumberish, overrides?: CallOverrides): Promise; + + updateWithdrawFeePercentage(_feePercentage: BigNumberish, overrides?: CallOverrides): Promise; + + updateZap(_zap: string, overrides?: CallOverrides): Promise; + + withdraw( + _recipient: string, + _shares: BigNumberish, + _minimumOut: BigNumberish, + _option: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + withdrawAll( + _recipient: string, + _minimumOut: BigNumberish, + _option: BigNumberish, + overrides?: CallOverrides, + ): Promise; + + withdrawFeePercentage(overrides?: CallOverrides): Promise; + + zap(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; + + 'Deposit(address,address,uint256)'( + _sender?: string | null, + _recipient?: string | null, + _amount?: null, + ): DepositEventFilter; + Deposit(_sender?: string | null, _recipient?: string | null, _amount?: null): DepositEventFilter; + + 'Harvest(address,uint256)'(_caller?: string | null, _amount?: null): HarvestEventFilter; + Harvest(_caller?: string | null, _amount?: null): HarvestEventFilter; + + 'OwnershipTransferred(address,address)'( + previousOwner?: string | null, + newOwner?: string | null, + ): OwnershipTransferredEventFilter; + OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter; + + 'Transfer(address,address,uint256)'(from?: string | null, to?: string | null, value?: null): TransferEventFilter; + Transfer(from?: string | null, to?: string | null, value?: null): TransferEventFilter; + + 'UpdateHarvestBountyPercentage(uint256)'(_percentage?: null): UpdateHarvestBountyPercentageEventFilter; + UpdateHarvestBountyPercentage(_percentage?: null): UpdateHarvestBountyPercentageEventFilter; + + 'UpdatePlatform(address)'(_platform?: string | null): UpdatePlatformEventFilter; + UpdatePlatform(_platform?: string | null): UpdatePlatformEventFilter; + + 'UpdatePlatformFeePercentage(uint256)'(_feePercentage?: null): UpdatePlatformFeePercentageEventFilter; + UpdatePlatformFeePercentage(_feePercentage?: null): UpdatePlatformFeePercentageEventFilter; + + 'UpdateWithdrawalFeePercentage(uint256)'(_feePercentage?: null): UpdateWithdrawalFeePercentageEventFilter; + UpdateWithdrawalFeePercentage(_feePercentage?: null): UpdateWithdrawalFeePercentageEventFilter; + + 'UpdateZap(address)'(_zap?: string | null): UpdateZapEventFilter; + UpdateZap(_zap?: string | null): UpdateZapEventFilter; + + 'Withdraw(address,address,uint256,uint8)'( + _sender?: string | null, + _recipient?: string | null, + _shares?: null, + _option?: null, + ): WithdrawEventFilter; + Withdraw(_sender?: string | null, _recipient?: string | null, _shares?: null, _option?: null): WithdrawEventFilter; + }; + + estimateGas: { + allowance(owner: string, spender: string, overrides?: CallOverrides): Promise; + + approve( + spender: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + balanceOf(account: string, overrides?: CallOverrides): Promise; + + balanceOfUnderlying(_user: string, overrides?: CallOverrides): Promise; + + claimEPS( + _distributor: string, + _recipient: string, + merkleIndex: BigNumberish, + index: BigNumberish, + amount: BigNumberish, + merkleProof: BytesLike[], + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + decreaseAllowance( + spender: string, + subtractedValue: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + deposit( + _recipient: string, + _amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + depositAll(_recipient: string, overrides?: Overrides & { from?: string | Promise }): Promise; + + depositAllWithCRV( + _recipient: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + depositWithCRV( + _recipient: string, + _amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + harvest( + _recipient: string, + _minimumOut: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + harvestBountyPercentage(overrides?: CallOverrides): Promise; + + increaseAllowance( + spender: string, + addedValue: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + initialize( + _zap: string, + _platform: string, + _withdrawFeePercentage: BigNumberish, + _platformFeePercentage: BigNumberish, + _harvestBountyPercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + name(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + pending3CRVRewards(overrides?: CallOverrides): Promise; + + pendingCRVRewards(overrides?: CallOverrides): Promise; + + pendingCVXRewards(overrides?: CallOverrides): Promise; + + platform(overrides?: CallOverrides): Promise; + + platformFeePercentage(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: Overrides & { from?: string | Promise }): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + totalUnderlying(overrides?: CallOverrides): Promise; + + transfer( + recipient: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + transferFrom( + sender: string, + recipient: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateHarvestBountyPercentage( + _percentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updatePlatform(_platform: string, overrides?: Overrides & { from?: string | Promise }): Promise; + + updatePlatformFeePercentage( + _feePercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateWithdrawFeePercentage( + _feePercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateZap(_zap: string, overrides?: Overrides & { from?: string | Promise }): Promise; + + withdraw( + _recipient: string, + _shares: BigNumberish, + _minimumOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + withdrawAll( + _recipient: string, + _minimumOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + withdrawFeePercentage(overrides?: CallOverrides): Promise; + + zap(overrides?: CallOverrides): Promise; + }; + + populateTransaction: { + allowance(owner: string, spender: string, overrides?: CallOverrides): Promise; + + approve( + spender: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + balanceOf(account: string, overrides?: CallOverrides): Promise; + + balanceOfUnderlying(_user: string, overrides?: CallOverrides): Promise; + + claimEPS( + _distributor: string, + _recipient: string, + merkleIndex: BigNumberish, + index: BigNumberish, + amount: BigNumberish, + merkleProof: BytesLike[], + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + decreaseAllowance( + spender: string, + subtractedValue: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + deposit( + _recipient: string, + _amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + depositAll( + _recipient: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + depositAllWithCRV( + _recipient: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + depositWithCRV( + _recipient: string, + _amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + harvest( + _recipient: string, + _minimumOut: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + harvestBountyPercentage(overrides?: CallOverrides): Promise; + + increaseAllowance( + spender: string, + addedValue: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + initialize( + _zap: string, + _platform: string, + _withdrawFeePercentage: BigNumberish, + _platformFeePercentage: BigNumberish, + _harvestBountyPercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + name(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + pending3CRVRewards(overrides?: CallOverrides): Promise; + + pendingCRVRewards(overrides?: CallOverrides): Promise; + + pendingCVXRewards(overrides?: CallOverrides): Promise; + + platform(overrides?: CallOverrides): Promise; + + platformFeePercentage(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: Overrides & { from?: string | Promise }): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + totalUnderlying(overrides?: CallOverrides): Promise; + + transfer( + recipient: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + transferFrom( + sender: string, + recipient: string, + amount: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + transferOwnership( + newOwner: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateHarvestBountyPercentage( + _percentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updatePlatform( + _platform: string, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updatePlatformFeePercentage( + _feePercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateWithdrawFeePercentage( + _feePercentage: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + updateZap(_zap: string, overrides?: Overrides & { from?: string | Promise }): Promise; + + withdraw( + _recipient: string, + _shares: BigNumberish, + _minimumOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + withdrawAll( + _recipient: string, + _minimumOut: BigNumberish, + _option: BigNumberish, + overrides?: Overrides & { from?: string | Promise }, + ): Promise; + + withdrawFeePercentage(overrides?: CallOverrides): Promise; + + zap(overrides?: CallOverrides): Promise; + }; +} diff --git a/src/apps/concentrator/contracts/ethers/common.ts b/src/apps/concentrator/contracts/ethers/common.ts new file mode 100644 index 000000000..6cfb10425 --- /dev/null +++ b/src/apps/concentrator/contracts/ethers/common.ts @@ -0,0 +1,30 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { Listener } from '@ethersproject/providers'; +import type { Event, EventFilter } from 'ethers'; + +export interface TypedEvent = any, TArgsObject = any> extends Event { + args: TArgsArray & TArgsObject; +} + +export interface TypedEventFilter<_TEvent extends TypedEvent> extends EventFilter {} + +export interface TypedListener { + (...listenerArg: [...__TypechainArgsArray, TEvent]): void; +} + +type __TypechainArgsArray = T extends TypedEvent ? U : never; + +export interface OnEvent { + (eventFilter: TypedEventFilter, listener: TypedListener): TRes; + (eventName: string, listener: Listener): TRes; +} + +export type MinEthersFactory = { + deploy(...a: ARGS[]): Promise; +}; + +export type GetContractTypeFromFactory = F extends MinEthersFactory ? C : never; + +export type GetARGsTypeFromFactory = F extends MinEthersFactory ? Parameters : never; diff --git a/src/apps/concentrator/contracts/ethers/factories/AladdinConvexVault__factory.ts b/src/apps/concentrator/contracts/ethers/factories/AladdinConvexVault__factory.ts new file mode 100644 index 000000000..f707c82dd --- /dev/null +++ b/src/apps/concentrator/contracts/ethers/factories/AladdinConvexVault__factory.ts @@ -0,0 +1,1059 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from 'ethers'; +import type { Provider } from '@ethersproject/providers'; +import type { AladdinConvexVault, AladdinConvexVaultInterface } from '../AladdinConvexVault'; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: '_convexPid', + type: 'uint256', + }, + { + indexed: false, + internalType: 'address[]', + name: '_rewardTokens', + type: 'address[]', + }, + ], + name: 'AddPool', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: '_sender', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: '_reward', + type: 'uint256', + }, + { + indexed: false, + internalType: 'enum IAladdinConvexVault.ClaimOption', + name: '_option', + type: 'uint8', + }, + ], + name: 'Claim', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + indexed: true, + internalType: 'address', + name: '_sender', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: '_amount', + type: 'uint256', + }, + ], + name: 'Deposit', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: '_caller', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: '_reward', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: '_platformFee', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: '_harvestBounty', + type: 'uint256', + }, + ], + name: 'Harvest', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'previousOwner', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'newOwner', + type: 'address', + }, + ], + name: 'OwnershipTransferred', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + indexed: false, + internalType: 'bool', + name: '_status', + type: 'bool', + }, + ], + name: 'PausePoolDeposit', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + indexed: false, + internalType: 'bool', + name: '_status', + type: 'bool', + }, + ], + name: 'PausePoolWithdraw', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: '_percentage', + type: 'uint256', + }, + ], + name: 'UpdateHarvestBountyPercentage', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: '_platform', + type: 'address', + }, + ], + name: 'UpdatePlatform', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: '_feePercentage', + type: 'uint256', + }, + ], + name: 'UpdatePlatformFeePercentage', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + indexed: false, + internalType: 'address[]', + name: '_rewardTokens', + type: 'address[]', + }, + ], + name: 'UpdatePoolRewardTokens', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + indexed: false, + internalType: 'uint256', + name: '_feePercentage', + type: 'uint256', + }, + ], + name: 'UpdateWithdrawalFeePercentage', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: '_zap', + type: 'address', + }, + ], + name: 'UpdateZap', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + indexed: true, + internalType: 'address', + name: '_sender', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: '_shares', + type: 'uint256', + }, + ], + name: 'Withdraw', + type: 'event', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_convexPid', + type: 'uint256', + }, + { + internalType: 'address[]', + name: '_rewardTokens', + type: 'address[]', + }, + { + internalType: 'uint256', + name: '_withdrawFeePercentage', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_platformFeePercentage', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_harvestBountyPercentage', + type: 'uint256', + }, + ], + name: 'addPool', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'aladdinCRV', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_minOut', + type: 'uint256', + }, + { + internalType: 'enum IAladdinConvexVault.ClaimOption', + name: '_option', + type: 'uint8', + }, + ], + name: 'claim', + outputs: [ + { + internalType: 'uint256', + name: 'claimed', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_minOut', + type: 'uint256', + }, + { + internalType: 'enum IAladdinConvexVault.ClaimOption', + name: '_option', + type: 'uint8', + }, + ], + name: 'claimAll', + outputs: [ + { + internalType: 'uint256', + name: 'claimed', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_amount', + type: 'uint256', + }, + ], + name: 'deposit', + outputs: [ + { + internalType: 'uint256', + name: 'share', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + ], + name: 'depositAll', + outputs: [ + { + internalType: 'uint256', + name: 'share', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + internalType: 'address', + name: '_recipient', + type: 'address', + }, + { + internalType: 'uint256', + name: '_minimumOut', + type: 'uint256', + }, + ], + name: 'harvest', + outputs: [ + { + internalType: 'uint256', + name: 'harvested', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_aladdinCRV', + type: 'address', + }, + { + internalType: 'address', + name: '_zap', + type: 'address', + }, + { + internalType: 'address', + name: '_platform', + type: 'address', + }, + ], + name: 'initialize', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'owner', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + internalType: 'bool', + name: '_status', + type: 'bool', + }, + ], + name: 'pausePoolDeposit', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + internalType: 'bool', + name: '_status', + type: 'bool', + }, + ], + name: 'pausePoolWithdraw', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + internalType: 'address', + name: '_account', + type: 'address', + }, + ], + name: 'pendingReward', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_account', + type: 'address', + }, + ], + name: 'pendingRewardAll', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'platform', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + name: 'poolInfo', + outputs: [ + { + internalType: 'uint128', + name: 'totalUnderlying', + type: 'uint128', + }, + { + internalType: 'uint128', + name: 'totalShare', + type: 'uint128', + }, + { + internalType: 'uint256', + name: 'accRewardPerShare', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'convexPoolId', + type: 'uint256', + }, + { + internalType: 'address', + name: 'lpToken', + type: 'address', + }, + { + internalType: 'address', + name: 'crvRewards', + type: 'address', + }, + { + internalType: 'uint256', + name: 'withdrawFeePercentage', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'platformFeePercentage', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'harvestBountyPercentage', + type: 'uint256', + }, + { + internalType: 'bool', + name: 'pauseDeposit', + type: 'bool', + }, + { + internalType: 'bool', + name: 'pauseWithdraw', + type: 'bool', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'poolLength', + outputs: [ + { + internalType: 'uint256', + name: 'pools', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'renounceOwnership', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'newOwner', + type: 'address', + }, + ], + name: 'transferOwnership', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_percentage', + type: 'uint256', + }, + ], + name: 'updateHarvestBountyPercentage', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_platform', + type: 'address', + }, + ], + name: 'updatePlatform', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_feePercentage', + type: 'uint256', + }, + ], + name: 'updatePlatformFeePercentage', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + internalType: 'address[]', + name: '_rewardTokens', + type: 'address[]', + }, + ], + name: 'updatePoolRewardTokens', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_feePercentage', + type: 'uint256', + }, + ], + name: 'updateWithdrawFeePercentage', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_zap', + type: 'address', + }, + ], + name: 'updateZap', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + name: 'userInfo', + outputs: [ + { + internalType: 'uint128', + name: 'shares', + type: 'uint128', + }, + { + internalType: 'uint128', + name: 'rewards', + type: 'uint128', + }, + { + internalType: 'uint256', + name: 'rewardPerSharePaid', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_minOut', + type: 'uint256', + }, + { + internalType: 'enum IAladdinConvexVault.ClaimOption', + name: '_option', + type: 'uint8', + }, + ], + name: 'withdrawAllAndClaim', + outputs: [ + { + internalType: 'uint256', + name: 'withdrawn', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'claimed', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + internalType: 'address', + name: '_token', + type: 'address', + }, + { + internalType: 'uint256', + name: '_minOut', + type: 'uint256', + }, + ], + name: 'withdrawAllAndZap', + outputs: [ + { + internalType: 'uint256', + name: 'withdrawn', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_shares', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_minOut', + type: 'uint256', + }, + { + internalType: 'enum IAladdinConvexVault.ClaimOption', + name: '_option', + type: 'uint8', + }, + ], + name: 'withdrawAndClaim', + outputs: [ + { + internalType: 'uint256', + name: 'withdrawn', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'claimed', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_shares', + type: 'uint256', + }, + { + internalType: 'address', + name: '_token', + type: 'address', + }, + { + internalType: 'uint256', + name: '_minOut', + type: 'uint256', + }, + ], + name: 'withdrawAndZap', + outputs: [ + { + internalType: 'uint256', + name: 'withdrawn', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'zap', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + internalType: 'address', + name: '_token', + type: 'address', + }, + { + internalType: 'uint256', + name: '_minAmount', + type: 'uint256', + }, + ], + name: 'zapAllAndDeposit', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'payable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_pid', + type: 'uint256', + }, + { + internalType: 'address', + name: '_token', + type: 'address', + }, + { + internalType: 'uint256', + name: '_amount', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_minAmount', + type: 'uint256', + }, + ], + name: 'zapAndDeposit', + outputs: [ + { + internalType: 'uint256', + name: 'share', + type: 'uint256', + }, + ], + stateMutability: 'payable', + type: 'function', + }, + { + stateMutability: 'payable', + type: 'receive', + }, +]; + +export class AladdinConvexVault__factory { + static readonly abi = _abi; + static createInterface(): AladdinConvexVaultInterface { + return new utils.Interface(_abi) as AladdinConvexVaultInterface; + } + static connect(address: string, signerOrProvider: Signer | Provider): AladdinConvexVault { + return new Contract(address, _abi, signerOrProvider) as AladdinConvexVault; + } +} diff --git a/src/apps/concentrator/contracts/ethers/factories/AladdinCrv__factory.ts b/src/apps/concentrator/contracts/ethers/factories/AladdinCrv__factory.ts new file mode 100644 index 000000000..6cea5e242 --- /dev/null +++ b/src/apps/concentrator/contracts/ethers/factories/AladdinCrv__factory.ts @@ -0,0 +1,931 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from 'ethers'; +import type { Provider } from '@ethersproject/providers'; +import type { AladdinCrv, AladdinCrvInterface } from '../AladdinCrv'; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'owner', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'spender', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: 'value', + type: 'uint256', + }, + ], + name: 'Approval', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: '_sender', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: '_recipient', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: '_amount', + type: 'uint256', + }, + ], + name: 'Deposit', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: '_caller', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: '_amount', + type: 'uint256', + }, + ], + name: 'Harvest', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'previousOwner', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'newOwner', + type: 'address', + }, + ], + name: 'OwnershipTransferred', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: 'from', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: 'to', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: 'value', + type: 'uint256', + }, + ], + name: 'Transfer', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint256', + name: '_percentage', + type: 'uint256', + }, + ], + name: 'UpdateHarvestBountyPercentage', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: '_platform', + type: 'address', + }, + ], + name: 'UpdatePlatform', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint256', + name: '_feePercentage', + type: 'uint256', + }, + ], + name: 'UpdatePlatformFeePercentage', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: 'uint256', + name: '_feePercentage', + type: 'uint256', + }, + ], + name: 'UpdateWithdrawalFeePercentage', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: '_zap', + type: 'address', + }, + ], + name: 'UpdateZap', + type: 'event', + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: 'address', + name: '_sender', + type: 'address', + }, + { + indexed: true, + internalType: 'address', + name: '_recipient', + type: 'address', + }, + { + indexed: false, + internalType: 'uint256', + name: '_shares', + type: 'uint256', + }, + { + indexed: false, + internalType: 'enum IAladdinCRV.WithdrawOption', + name: '_option', + type: 'uint8', + }, + ], + name: 'Withdraw', + type: 'event', + }, + { + inputs: [ + { + internalType: 'address', + name: 'owner', + type: 'address', + }, + { + internalType: 'address', + name: 'spender', + type: 'address', + }, + ], + name: 'allowance', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'spender', + type: 'address', + }, + { + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + ], + name: 'approve', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'account', + type: 'address', + }, + ], + name: 'balanceOf', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_user', + type: 'address', + }, + ], + name: 'balanceOfUnderlying', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_distributor', + type: 'address', + }, + { + internalType: 'address', + name: '_recipient', + type: 'address', + }, + { + internalType: 'uint256', + name: 'merkleIndex', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'index', + type: 'uint256', + }, + { + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + { + internalType: 'bytes32[]', + name: 'merkleProof', + type: 'bytes32[]', + }, + ], + name: 'claimEPS', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'decimals', + outputs: [ + { + internalType: 'uint8', + name: '', + type: 'uint8', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'spender', + type: 'address', + }, + { + internalType: 'uint256', + name: 'subtractedValue', + type: 'uint256', + }, + ], + name: 'decreaseAllowance', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_recipient', + type: 'address', + }, + { + internalType: 'uint256', + name: '_amount', + type: 'uint256', + }, + ], + name: 'deposit', + outputs: [ + { + internalType: 'uint256', + name: 'share', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_recipient', + type: 'address', + }, + ], + name: 'depositAll', + outputs: [ + { + internalType: 'uint256', + name: 'share', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_recipient', + type: 'address', + }, + ], + name: 'depositAllWithCRV', + outputs: [ + { + internalType: 'uint256', + name: 'share', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_recipient', + type: 'address', + }, + { + internalType: 'uint256', + name: '_amount', + type: 'uint256', + }, + ], + name: 'depositWithCRV', + outputs: [ + { + internalType: 'uint256', + name: 'share', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_recipient', + type: 'address', + }, + { + internalType: 'uint256', + name: '_minimumOut', + type: 'uint256', + }, + ], + name: 'harvest', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'harvestBountyPercentage', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'spender', + type: 'address', + }, + { + internalType: 'uint256', + name: 'addedValue', + type: 'uint256', + }, + ], + name: 'increaseAllowance', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_zap', + type: 'address', + }, + { + internalType: 'address', + name: '_platform', + type: 'address', + }, + { + internalType: 'uint256', + name: '_withdrawFeePercentage', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_platformFeePercentage', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_harvestBountyPercentage', + type: 'uint256', + }, + ], + name: 'initialize', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'name', + outputs: [ + { + internalType: 'string', + name: '', + type: 'string', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'owner', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'pending3CRVRewards', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'pendingCRVRewards', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'pendingCVXRewards', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'platform', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'platformFeePercentage', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'renounceOwnership', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'symbol', + outputs: [ + { + internalType: 'string', + name: '', + type: 'string', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'totalSupply', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'totalUnderlying', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'recipient', + type: 'address', + }, + { + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + ], + name: 'transfer', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'sender', + type: 'address', + }, + { + internalType: 'address', + name: 'recipient', + type: 'address', + }, + { + internalType: 'uint256', + name: 'amount', + type: 'uint256', + }, + ], + name: 'transferFrom', + outputs: [ + { + internalType: 'bool', + name: '', + type: 'bool', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: 'newOwner', + type: 'address', + }, + ], + name: 'transferOwnership', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_percentage', + type: 'uint256', + }, + ], + name: 'updateHarvestBountyPercentage', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_platform', + type: 'address', + }, + ], + name: 'updatePlatform', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_feePercentage', + type: 'uint256', + }, + ], + name: 'updatePlatformFeePercentage', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'uint256', + name: '_feePercentage', + type: 'uint256', + }, + ], + name: 'updateWithdrawFeePercentage', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_zap', + type: 'address', + }, + ], + name: 'updateZap', + outputs: [], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_recipient', + type: 'address', + }, + { + internalType: 'uint256', + name: '_shares', + type: 'uint256', + }, + { + internalType: 'uint256', + name: '_minimumOut', + type: 'uint256', + }, + { + internalType: 'enum IAladdinCRV.WithdrawOption', + name: '_option', + type: 'uint8', + }, + ], + name: 'withdraw', + outputs: [ + { + internalType: 'uint256', + name: 'withdrawn', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [ + { + internalType: 'address', + name: '_recipient', + type: 'address', + }, + { + internalType: 'uint256', + name: '_minimumOut', + type: 'uint256', + }, + { + internalType: 'enum IAladdinCRV.WithdrawOption', + name: '_option', + type: 'uint8', + }, + ], + name: 'withdrawAll', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'nonpayable', + type: 'function', + }, + { + inputs: [], + name: 'withdrawFeePercentage', + outputs: [ + { + internalType: 'uint256', + name: '', + type: 'uint256', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + inputs: [], + name: 'zap', + outputs: [ + { + internalType: 'address', + name: '', + type: 'address', + }, + ], + stateMutability: 'view', + type: 'function', + }, + { + stateMutability: 'payable', + type: 'receive', + }, +]; + +export class AladdinCrv__factory { + static readonly abi = _abi; + static createInterface(): AladdinCrvInterface { + return new utils.Interface(_abi) as AladdinCrvInterface; + } + static connect(address: string, signerOrProvider: Signer | Provider): AladdinCrv { + return new Contract(address, _abi, signerOrProvider) as AladdinCrv; + } +} diff --git a/src/apps/concentrator/contracts/ethers/factories/index.ts b/src/apps/concentrator/contracts/ethers/factories/index.ts new file mode 100644 index 000000000..12d8a7c8c --- /dev/null +++ b/src/apps/concentrator/contracts/ethers/factories/index.ts @@ -0,0 +1,5 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { AladdinConvexVault__factory } from './AladdinConvexVault__factory'; +export { AladdinCrv__factory } from './AladdinCrv__factory'; diff --git a/src/apps/concentrator/contracts/ethers/index.ts b/src/apps/concentrator/contracts/ethers/index.ts new file mode 100644 index 000000000..7ec433a75 --- /dev/null +++ b/src/apps/concentrator/contracts/ethers/index.ts @@ -0,0 +1,8 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { AladdinConvexVault } from './AladdinConvexVault'; +export type { AladdinCrv } from './AladdinCrv'; +export * as factories from './factories'; +export { AladdinConvexVault__factory } from './factories/AladdinConvexVault__factory'; +export { AladdinCrv__factory } from './factories/AladdinCrv__factory'; diff --git a/src/apps/concentrator/contracts/index.ts b/src/apps/concentrator/contracts/index.ts new file mode 100644 index 000000000..d268dae3a --- /dev/null +++ b/src/apps/concentrator/contracts/index.ts @@ -0,0 +1,28 @@ +import { Injectable, Inject } from '@nestjs/common'; + +import { IAppToolkit, APP_TOOLKIT } from '~app-toolkit/app-toolkit.interface'; +import { ContractFactory } from '~contract/contracts'; +import { Network } from '~types/network.interface'; + +import { AladdinConvexVault__factory } from './ethers'; +import { AladdinCrv__factory } from './ethers'; + +// eslint-disable-next-line +type ContractOpts = { address: string; network: Network }; + +@Injectable() +export class ConcentratorContractFactory extends ContractFactory { + constructor(@Inject(APP_TOOLKIT) protected readonly appToolkit: IAppToolkit) { + super((network: Network) => appToolkit.getNetworkProvider(network)); + } + + aladdinConvexVault({ address, network }: ContractOpts) { + return AladdinConvexVault__factory.connect(address, this.appToolkit.getNetworkProvider(network)); + } + aladdinCrv({ address, network }: ContractOpts) { + return AladdinCrv__factory.connect(address, this.appToolkit.getNetworkProvider(network)); + } +} + +export type { AladdinConvexVault } from './ethers'; +export type { AladdinCrv } from './ethers'; diff --git a/src/apps/concentrator/ethereum/concentrator.acrv.token-fetcher.ts b/src/apps/concentrator/ethereum/concentrator.acrv.token-fetcher.ts new file mode 100644 index 000000000..c576d994a --- /dev/null +++ b/src/apps/concentrator/ethereum/concentrator.acrv.token-fetcher.ts @@ -0,0 +1,69 @@ +import { Inject } from '@nestjs/common'; + +import { IAppToolkit, APP_TOOLKIT } from '~app-toolkit/app-toolkit.interface'; +import { Register } from '~app-toolkit/decorators'; +import { getAppImg } from '~app-toolkit/helpers/presentation/image.present'; +import { ContractType } from '~position/contract.interface'; +import { PositionFetcher } from '~position/position-fetcher.interface'; +import { AppTokenPosition } from '~position/position.interface'; +import { Network } from '~types/network.interface'; + +import { CONCENTRATOR_DEFINITION } from '../concentrator.definition'; +import { ConcentratorContractFactory } from '../contracts'; + +const appId = CONCENTRATOR_DEFINITION.id; +const groupId = CONCENTRATOR_DEFINITION.groups.acrv.id; +const network = Network.ETHEREUM_MAINNET; +export const address = '0x2b95A1Dcc3D405535f9ed33c219ab38E8d7e0884'.toLowerCase(); // EIP-1967 proxy + +@Register.TokenPositionFetcher({ appId, groupId, network }) +export class EthereumConcentratorAcrvTokenFetcher implements PositionFetcher { + constructor( + @Inject(APP_TOOLKIT) private readonly appToolkit: IAppToolkit, + @Inject(ConcentratorContractFactory) private readonly concentratorContractFactory: ConcentratorContractFactory, + ) {} + + async getPositions() { + const multicall = this.appToolkit.getMulticall(network); + const baseTokens = await this.appToolkit.getBaseTokenPrices(network); + const underlyingToken = baseTokens.find(token => token.symbol == 'cvxCRV'); + if (!underlyingToken) return []; + + const contract = this.concentratorContractFactory.aladdinCrv({ address, network }); + const [symbol, decimals, supplyRaw, underlyingRaw] = await Promise.all([ + multicall.wrap(contract).symbol(), + multicall.wrap(contract).decimals(), + multicall.wrap(contract).totalSupply(), + multicall.wrap(contract).totalUnderlying(), + ]); + + const supply = Number(supplyRaw) / 10 ** decimals; + const pricePerShare = Number(underlyingRaw) / Number(supplyRaw); + const price = underlyingToken.price * pricePerShare; + + // TODO: add additional properties from https://concentrator-api.aladdin.club/apy/ + const label = `Concentrator aCRV`; + const images = [getAppImg(appId)]; + + const token: AppTokenPosition = { + type: ContractType.APP_TOKEN, + appId, + groupId, + address, + network, + symbol, + decimals, + supply, + tokens: [underlyingToken], + price, + pricePerShare, + dataProps: {}, + displayProps: { + label, + images, + }, + }; + + return [token]; + } +} diff --git a/src/apps/concentrator/ethereum/concentrator.balance-fetcher.ts b/src/apps/concentrator/ethereum/concentrator.balance-fetcher.ts new file mode 100644 index 000000000..7c6df4f76 --- /dev/null +++ b/src/apps/concentrator/ethereum/concentrator.balance-fetcher.ts @@ -0,0 +1,69 @@ +import { Inject } from '@nestjs/common'; + +import { IAppToolkit, APP_TOOLKIT } from '~app-toolkit/app-toolkit.interface'; +import { Register } from '~app-toolkit/decorators'; +import { presentBalanceFetcherResponse } from '~app-toolkit/helpers/presentation/balance-fetcher-response.present'; +import { BalanceFetcher } from '~balance/balance-fetcher.interface'; +import { Network } from '~types/network.interface'; + +import { CONCENTRATOR_DEFINITION } from '../concentrator.definition'; +import { ConcentratorContractFactory, AladdinConvexVault } from '../contracts'; + +const network = Network.ETHEREUM_MAINNET; + +@Register.BalanceFetcher(CONCENTRATOR_DEFINITION.id, network) +export class EthereumConcentratorBalanceFetcher implements BalanceFetcher { + constructor( + @Inject(APP_TOOLKIT) private readonly appToolkit: IAppToolkit, + @Inject(ConcentratorContractFactory) private readonly concentratorContractFactory: ConcentratorContractFactory, + ) {} + + async getTokenBalances(address: string) { + return await this.appToolkit.helpers.tokenBalanceHelper.getTokenBalances({ + address, + appId: CONCENTRATOR_DEFINITION.id, + groupId: CONCENTRATOR_DEFINITION.groups.acrv.id, + network: Network.ETHEREUM_MAINNET, + }); + } + + async getPoolBalances(address: string) { + return this.appToolkit.helpers.masterChefContractPositionBalanceHelper.getBalances({ + address, + appId: CONCENTRATOR_DEFINITION.id, + groupId: CONCENTRATOR_DEFINITION.groups.pool.id, + network: Network.ETHEREUM_MAINNET, + resolveChefContract: ({ contractAddress, network }) => + this.concentratorContractFactory.aladdinConvexVault({ address: contractAddress, network }), + resolveStakedTokenBalance: this.appToolkit.helpers.masterChefDefaultStakedBalanceStrategy.build({ + resolveStakedBalance: ({ contract, multicall, contractPosition }) => + multicall + .wrap(contract) + .userInfo(contractPosition.dataProps.poolIndex, address) + .then(v => v[0]), + }), + resolveClaimableTokenBalances: this.appToolkit.helpers.masterChefDefaultClaimableBalanceStrategy.build({ + resolveClaimableBalance: ({ multicall, contract, contractPosition, address }) => + multicall.wrap(contract).pendingReward(contractPosition.dataProps.poolIndex, address), + }), + }); + } + + async getBalances(address: string) { + const [aCrvTokenBalances, poolBalances] = await Promise.all([ + this.getTokenBalances(address), + this.getPoolBalances(address), + ]); + + return presentBalanceFetcherResponse([ + { + label: 'aCrv', + assets: aCrvTokenBalances, + }, + { + label: 'Pools', + assets: poolBalances, + }, + ]); + } +} diff --git a/src/apps/concentrator/ethereum/concentrator.pool.contract-position-fetcher.ts b/src/apps/concentrator/ethereum/concentrator.pool.contract-position-fetcher.ts new file mode 100644 index 000000000..919826609 --- /dev/null +++ b/src/apps/concentrator/ethereum/concentrator.pool.contract-position-fetcher.ts @@ -0,0 +1,56 @@ +import { Inject } from '@nestjs/common'; + +import { IAppToolkit, APP_TOOLKIT } from '~app-toolkit/app-toolkit.interface'; +import { Register } from '~app-toolkit/decorators'; +import { CURVE_DEFINITION } from '~apps/curve'; +import { PositionFetcher } from '~position/position-fetcher.interface'; +import { ContractPosition } from '~position/position.interface'; +import { Network } from '~types/network.interface'; + +import { CONCENTRATOR_DEFINITION } from '../concentrator.definition'; +import { ConcentratorContractFactory, AladdinConvexVault } from '../contracts'; + +import { address as aCrvAddress } from './concentrator.acrv.token-fetcher'; + +const appId = CONCENTRATOR_DEFINITION.id; +const groupId = CONCENTRATOR_DEFINITION.groups.pool.id; +const network = Network.ETHEREUM_MAINNET; +const address = '0xc8fF37F7d057dF1BB9Ad681b53Fa4726f268E0e8'.toLowerCase(); + +@Register.ContractPositionFetcher({ appId, groupId, network }) +export class EthereumConcentratorPoolContractPositionFetcher implements PositionFetcher { + constructor( + @Inject(APP_TOOLKIT) private readonly appToolkit: IAppToolkit, + @Inject(ConcentratorContractFactory) private readonly concentratorContractFactory: ConcentratorContractFactory, + ) {} + + async getPositions() { + return this.appToolkit.helpers.masterChefContractPositionHelper.getContractPositions({ + address, + appId, + groupId, + network, + dependencies: [ + { + appId: CURVE_DEFINITION.id, + groupIds: [CURVE_DEFINITION.groups.pool.id], + network, + }, + { + appId: CONCENTRATOR_DEFINITION.id, + groupIds: [CONCENTRATOR_DEFINITION.groups.acrv.id], + network, + }, + ], + resolveContract: ({ address, network }) => + this.concentratorContractFactory.aladdinConvexVault({ address, network }), + resolvePoolLength: ({ multicall, contract }) => multicall.wrap(contract).poolLength(), + resolveDepositTokenAddress: ({ poolIndex, contract, multicall }) => + multicall + .wrap(contract) + .poolInfo(poolIndex) + .then(v => v.lpToken), + resolveRewardTokenAddresses: () => Promise.resolve([aCrvAddress]), + }); + } +}