From 36cde41b14aca1ef6681aa95eb171738cbcf2c40 Mon Sep 17 00:00:00 2001 From: Mikhailo Shabodyash Date: Tue, 25 Jun 2024 13:06:34 +0300 Subject: [PATCH] feat: add ezETH to weth mainnet --- contracts/test/MockOracle.sol | 46 ++++++ .../1718352598_add_ezeth_as_collateral.ts | 155 ++++++++++++++++++ deployments/mainnet/weth/relations.ts | 20 ++- scenario/LiquidationBotScenario.ts | 2 +- scenario/utils/index.ts | 33 +++- 5 files changed, 252 insertions(+), 4 deletions(-) create mode 100644 contracts/test/MockOracle.sol create mode 100644 deployments/mainnet/weth/migrations/1718352598_add_ezeth_as_collateral.ts diff --git a/contracts/test/MockOracle.sol b/contracts/test/MockOracle.sol new file mode 100644 index 000000000..9576720c5 --- /dev/null +++ b/contracts/test/MockOracle.sol @@ -0,0 +1,46 @@ +// SPDX-License-Identifier: BUSL-1.1 +pragma solidity 0.8.15; + +import "../vendor/@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol"; + +/** + * @title Mock oracle + * @notice Mock oracle to test the scaling price feed with updated update time + * @author Compound + */ +contract MockOracle { + + /// @notice Number of decimals for returned prices + uint8 public immutable decimals; + + /// @notice Underlying Chainlink price feed where prices are fetched from + address public immutable underlyingPriceFeed; + + /** + * @notice Construct a new scaling price feed + * @param underlyingPriceFeed_ The address of the underlying price feed to fetch prices from + **/ + constructor(address underlyingPriceFeed_) { + underlyingPriceFeed = underlyingPriceFeed_; + decimals = AggregatorV3Interface(underlyingPriceFeed_).decimals(); + } + + /** + * @notice Price for the latest round + * @return roundId Round id from the underlying price feed + * @return answer Latest price for the asset in terms of ETH + * @return startedAt Timestamp when the round was started; passed on from underlying price feed + * @return updatedAt Current timestamp + * @return answeredInRound Round id in which the answer was computed; passed on from underlying price feed + **/ + function latestRoundData() external view returns ( + uint80 roundId, + int256 answer, + uint256 startedAt, + uint256 updatedAt, + uint80 answeredInRound + ) { + (uint80 roundId_, int256 price, uint256 startedAt_, , uint80 answeredInRound_) = AggregatorV3Interface(underlyingPriceFeed).latestRoundData(); + return (roundId_, price, startedAt_, block.timestamp, answeredInRound_); + } +} diff --git a/deployments/mainnet/weth/migrations/1718352598_add_ezeth_as_collateral.ts b/deployments/mainnet/weth/migrations/1718352598_add_ezeth_as_collateral.ts new file mode 100644 index 000000000..4345ed66b --- /dev/null +++ b/deployments/mainnet/weth/migrations/1718352598_add_ezeth_as_collateral.ts @@ -0,0 +1,155 @@ +import { expect } from 'chai'; +import { DeploymentManager } from '../../../../plugins/deployment_manager/DeploymentManager'; +import { migration } from '../../../../plugins/deployment_manager/Migration'; +import { exp, proposal } from '../../../../src/deploy'; + +const EZETH_ADDRESS = '0xbf5495Efe5DB9ce00f80364C8B423567e58d2110'; +const EZETH_PRICE_FEED_ADDRESS = '0x387dBc0fB00b26fb085aa658527D5BE98302c84C'; + +export default migration('1718352598_add_ezeth_as_collateral', { + async prepare(deploymentManager: DeploymentManager) { + const _ezETHScalingPriceFeed = await deploymentManager.deploy( + 'ezETH:priceFeed', + 'pricefeeds/EzETHExchangeRatePriceFeed.sol', + [ + EZETH_PRICE_FEED_ADDRESS, // ezETH / ETH exchange rate price feed + 8, // decimals + 'ezETH / ETH exchange rate', // description + ] + ); + return { ezETHScalingPriceFeed: _ezETHScalingPriceFeed.address }; + }, + + async enact(deploymentManager: DeploymentManager, _, { ezETHScalingPriceFeed }) { + const trace = deploymentManager.tracer(); + + const ezETH = await deploymentManager.existing( + 'ezETH', + EZETH_ADDRESS, + 'mainnet', + 'contracts/ERC20.sol:ERC20' + ); + + const ezEthPricefeed = await deploymentManager.existing( + 'ezETH:priceFeed', + ezETHScalingPriceFeed, + 'mainnet' + ); + + const { + governor, + comet, + cometAdmin, + configurator, + } = await deploymentManager.getContracts(); + + const ezETHAssetConfig = { + asset: ezETH.address, + priceFeed: ezEthPricefeed.address, + decimals: await ezETH.decimals(), + borrowCollateralFactor: exp(0.80, 18), + liquidateCollateralFactor: exp(0.85, 18), + liquidationFactor: exp(0.90, 18), + supplyCap: exp(2_900, 18), + }; + + const mainnetActions = [ + // 1. Add ezETH as asset + { + contract: configurator, + signature: 'addAsset(address,(address,address,uint8,uint64,uint64,uint64,uint128))', + args: [comet.address, ezETHAssetConfig], + }, + // 2. Deploy and upgrade to a new version of Comet + { + contract: cometAdmin, + signature: 'deployAndUpgradeTo(address,address)', + args: [configurator.address, comet.address], + }, + ]; + + const description = '# Add ezETH as collateral into cWETHv3 on Mainnet\n\n## Proposal summary\n\nCompound Growth Program [AlphaGrowth] proposes to add ezETH into cWETHv3 on Ethereum network. This proposal takes the governance steps recommended and necessary to update a Compound III WETH market on Ethereum. Simulations have confirmed the market’s readiness, as much as possible, using the [Comet scenario suite](https://github.com/compound-finance/comet/tree/main/scenario). The new parameters include setting the risk parameters based off of the [recommendations from Gauntlet](https://www.comp.xyz/t/add-market-ezeth-on-eth-mainnet/5062/7).\n\nFurther detailed information can be found on the corresponding [proposal pull request](https://github.com/compound-finance/comet/pull/867), [deploy market GitHub action run](https://github.com/woof-software/comet/actions/runs/9545875152/job/26307579839) and [forum discussion](https://www.comp.xyz/t/add-market-ezeth-on-eth-mainnet/5062).\n\n# [Yield Risk](https://www.comp.xyz/t/add-market-ezeth-on-eth-mainnet/5062/7#yield-risk-7)\n\nCurrently LRTs such as ezETH have elevated yields due to points program. EigenLayer maturity and AVS launch will cause yield shocks and consequentially elevate slippage magnitude and liquidity on DEXs. Gauntlet flags this potential risk to the community.\n\n\n## Proposal Actions\n\nThe first proposal action adds ezETH asset as collateral with the corresponding configuration.\n\nThe second action deploys and upgrades Comet to a new version.'; + const txn = await deploymentManager.retry(async () => + trace( + await governor.propose(...(await proposal(mainnetActions, description))) + ) + ); + + const event = txn.events.find( + (event) => event.event === 'ProposalCreated' + ); + const [proposalId] = event.args; + trace(`Created proposal ${proposalId}.`); + }, + + async enacted(): Promise { + return false; + }, + + async verify(deploymentManager: DeploymentManager) { + const { comet, configurator } = await deploymentManager.getContracts(); + + const ezETHAssetIndex = Number(await comet.numAssets()) - 1; + + const ezETH = await deploymentManager.existing( + 'ezETH', + EZETH_ADDRESS, + 'mainnet', + 'contracts/ERC20.sol:ERC20' + ); + + const ezETHAssetConfig = { + asset: ezETH.address, + priceFeed: '', + decimals: await ezETH.decimals(), + borrowCollateralFactor: exp(0.80, 18), + liquidateCollateralFactor: exp(0.85, 18), + liquidationFactor: exp(0.9, 18), + supplyCap: exp(2_900, 18), // 2_900 + }; + + // 1. & 2. Compare ezETH asset config with Comet and Configurator asset info + const cometEzETHAssetInfo = await comet.getAssetInfoByAddress( + EZETH_ADDRESS + ); + + expect(ezETHAssetIndex).to.be.equal(cometEzETHAssetInfo.offset); + expect(ezETHAssetConfig.asset).to.be.equal(cometEzETHAssetInfo.asset); + expect(exp(1, ezETHAssetConfig.decimals)).to.be.equal( + cometEzETHAssetInfo.scale + ); + expect(ezETHAssetConfig.borrowCollateralFactor).to.be.equal( + cometEzETHAssetInfo.borrowCollateralFactor + ); + expect(ezETHAssetConfig.liquidateCollateralFactor).to.be.equal( + cometEzETHAssetInfo.liquidateCollateralFactor + ); + expect(ezETHAssetConfig.liquidationFactor).to.be.equal( + cometEzETHAssetInfo.liquidationFactor + ); + expect(ezETHAssetConfig.supplyCap).to.be.equal( + cometEzETHAssetInfo.supplyCap + ); + const configuratorEsETHAssetConfig = ( + await configurator.getConfiguration(comet.address) + ).assetConfigs[ezETHAssetIndex]; + expect(ezETHAssetConfig.asset).to.be.equal( + configuratorEsETHAssetConfig.asset + ); + expect(ezETHAssetConfig.decimals).to.be.equal( + configuratorEsETHAssetConfig.decimals + ); + expect(ezETHAssetConfig.borrowCollateralFactor).to.be.equal( + configuratorEsETHAssetConfig.borrowCollateralFactor + ); + expect(ezETHAssetConfig.liquidateCollateralFactor).to.be.equal( + configuratorEsETHAssetConfig.liquidateCollateralFactor + ); + expect(ezETHAssetConfig.liquidationFactor).to.be.equal( + configuratorEsETHAssetConfig.liquidationFactor + ); + expect(ezETHAssetConfig.supplyCap).to.be.equal( + configuratorEsETHAssetConfig.supplyCap + ); + }, +}); diff --git a/deployments/mainnet/weth/relations.ts b/deployments/mainnet/weth/relations.ts index 37278965c..031976417 100644 --- a/deployments/mainnet/weth/relations.ts +++ b/deployments/mainnet/weth/relations.ts @@ -13,5 +13,21 @@ export default { }, 'AppProxyUpgradeable': { artifact: 'contracts/ERC20.sol:ERC20', - } -}; \ No newline at end of file + }, + 'UUPSProxy': { + artifact: 'contracts/ERC20.sol:ERC20', + delegates: { + field: { + slot: '0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc' + } + } + }, + 'TransparentUpgradeableProxy': { + artifact: 'contracts/ERC20.sol:ERC20', + delegates: { + field: { + slot: '0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc' + } + } + }, +}; diff --git a/scenario/LiquidationBotScenario.ts b/scenario/LiquidationBotScenario.ts index 763468c9e..6cf5b64ec 100644 --- a/scenario/LiquidationBotScenario.ts +++ b/scenario/LiquidationBotScenario.ts @@ -739,7 +739,7 @@ scenario( const assetAmounts = { mainnet: { usdc: ' == 5000', // COMP - weth: ' == 10000', // CB_ETH + weth: ' == 7000', // CB_ETH }, }; diff --git a/scenario/utils/index.ts b/scenario/utils/index.ts index 492c0ab8e..03f59d4d8 100644 --- a/scenario/utils/index.ts +++ b/scenario/utils/index.ts @@ -327,6 +327,36 @@ export async function fetchLogs( } } +async function redeployRenzoOracle(dm: DeploymentManager){ + if(dm.network === 'mainnet' && dm.deployment === 'weth') { + // renzo admin 0xD1e6626310fD54Eceb5b9a51dA2eC329D6D4B68A + const renzoOracle = new Contract( + '0x5a12796f7e7EBbbc8a402667d266d2e65A814042', + [ + 'function setOracleAddress(address _token, address _oracleAddress) external', + ], + dm.hre.ethers.provider + ); + + const admin = await impersonateAddress(dm, '0xD1e6626310fD54Eceb5b9a51dA2eC329D6D4B68A'); + // set balance + await dm.hre.ethers.provider.send('hardhat_setBalance', [ + admin.address, + dm.hre.ethers.utils.hexStripZeros(dm.hre.ethers.utils.parseUnits('100', 'ether').toHexString()), + ]); + + const newOracle = await dm.deploy( + 'stETH:Oracle', + 'test/MockOracle.sol', + [ + '0x86392dC19c0b719886221c78AB11eb8Cf5c52812', // stETH / ETH oracle address + ] + ); + + await renzoOracle.connect(admin).setOracleAddress('0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84', newOracle.address); + } +} + export async function executeOpenProposal( dm: DeploymentManager, { id, startBlock, endBlock }: OpenProposal @@ -370,6 +400,7 @@ export async function executeOpenProposal( await setNextBaseFeeToZero(dm); await governor.execute(id, { gasPrice: 0, gasLimit: 12000000 }); } + await redeployRenzoOracle(dm); } // Instantly executes some actions through the governance proposal process @@ -606,4 +637,4 @@ export async function timeUntilUnderwater({ comet, actor, fudgeFactor = 0n }: { // XXX throw error if baseBalanceOf is positive and liquidationMargin is positive return Number((-liquidationMargin * factorScale / baseLiquidity / borrowRate) + fudgeFactor); -} +} \ No newline at end of file