feat: deploy aero oracle

rhlsthrm · rhlsthrm · commit a0a70db73564 · 2024-07-28T19:47:26.000+04:00
diff --git a/chainDeploy/helpers/oracles/aerodrome.ts b/chainDeploy/helpers/oracles/aerodrome.ts
@@ -0,0 +1,75 @@
+import { addTransaction, prepareAndLogTransaction } from "../logging";
+import {
+  AerodromeDeployFnParams,
+  ChainlinkAsset,
+  ChainlinkDeployFnParams,
+  ChainlinkFeedBaseCurrency
+} from "../../../chains/types";
+
+import { addUnderlyingsToMpo } from "./utils";
+import { Address, encodeFunctionData } from "viem";
+import { underlying } from "../utils";
+import { DeployResult } from "hardhat-deploy/types";
+
+export const deployAerodromeOracle = async ({
+  viem,
+  getNamedAccounts,
+  deployments,
+  pricesContract,
+  assets
+}: AerodromeDeployFnParams): Promise<{ apo: DeployResult }> => {
+  const { deployer } = await getNamedAccounts();
+  const publicClient = await viem.getPublicClient();
+  const walletClient = await viem.getWalletClient(deployer as Address);
+  let tx;
+
+  //// Aerodrome Oracle
+  const apo = await deployments.deploy("AerodromePriceOracle", {
+    from: deployer,
+    args: [pricesContract],
+    log: true,
+    waitConfirmations: 1
+  });
+  if (apo.transactionHash) await publicClient.waitForTransactionReceipt({ hash: apo.transactionHash as Address });
+  console.log("ChainlinkPriceOracleV2: ", apo.address);
+
+  const aerodrome = await viem.getContractAt(
+    "AerodromePriceOracle",
+    (await deployments.get("AerodromePriceOracle")).address as Address
+  );
+
+  const underlyings = assets.map((c) => underlying(assets, c.symbol));
+
+  const mpo = await viem.getContractAt(
+    "MasterPriceOracle",
+    (await deployments.get("MasterPriceOracle")).address as Address
+  );
+  await addUnderlyingsToMpo(mpo as any, underlyings, aerodrome.address, deployer, publicClient, walletClient);
+
+  const addressesProvider = await viem.getContractAt(
+    "AddressesProvider",
+    (await deployments.get("AddressesProvider")).address as Address
+  );
+  const aerodromeAddress = await addressesProvider.read.getAddress(["AerodromePriceOracle"]);
+  if (aerodromeAddress !== aerodrome.address) {
+    if (((await addressesProvider.read.owner()) as Address).toLowerCase() === deployer.toLowerCase()) {
+      tx = await addressesProvider.write.setAddress(["AerodromePriceOracle", aerodrome.address]);
+      await publicClient.waitForTransactionReceipt({ hash: tx });
+      console.log(`setAddress AerodromePriceOracle at ${tx}`);
+    } else {
+      prepareAndLogTransaction({
+        contractInstance: addressesProvider,
+        functionName: "setAddress",
+        args: ["AerodromePriceOracle", aerodrome.address],
+        description: "Set AerodromePriceOracle address on AddressProvider",
+        inputs: [
+          { internalType: "string", name: "id", type: "string" },
+          { internalType: "address", name: "newAddress", type: "address" }
+        ]
+      });
+      console.log("Logged Transaction to setAddress ChainlinkPriceOracleV2 on AddressProvider");
+    }
+  }
+
+  return { apo };
+};
diff --git a/chainDeploy/mainnets/base.ts b/chainDeploy/mainnets/base.ts
@@ -1,64 +1,65 @@
-// import { ChainDeployConfig, deployChainlinkOracle } from "../helpers";
-// import { ChainlinkAsset } from "../../chains/types";
+import { ChainDeployConfig } from "../helpers";
+import { OracleTypes, SupportedAsset } from "../../chains/types";
+import { base } from "../../chains";
+import { deployAerodromeOracle } from "../helpers/oracles/aerodrome";
+import { HardhatRuntimeEnvironment } from "hardhat/types";
 
-// const assets = base.assets;
+const assets = base.assets;
 
-// export const deployConfig: ChainDeployConfig = {
-//   blocksPerYear: Number(base.specificParams.blocksPerYear),
-//   cgId: base.specificParams.cgId,
-//   nativeTokenName: "Base",
-//   nativeTokenSymbol: "ETH",
-//   stableToken: base.chainAddresses.STABLE_TOKEN,
-//   uniswap: {
-//     flashSwapFee: 30, // TODO set the correct fee
-//     hardcoded: [],
-//     uniswapData: [],
-//     uniswapOracleInitialDeployTokens: [],
-//     uniswapV2FactoryAddress: "0x8909Dc15e40173Ff4699343b6eB8132c65e18eC6",
-//     uniswapV2RouterAddress: "0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24",
-//     uniswapV3SwapRouter: "0x2626664c2603336E57B271c5C0b26F421741e481",
-//     uniswapV3Quoter: "0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a"
-//   },
-//   wtoken: base.chainAddresses.W_TOKEN,
-//   nativeTokenUsdChainlinkFeed: base.chainAddresses.W_TOKEN_USD_CHAINLINK_PRICE_FEED
-// };
+const pricesContract = "0xee717411f6E44F9feE011835C8E6FAaC5dEfF166";
 
-// const chainlinkAssets: ChainlinkAsset[] = base.assets
-//   .filter((asset) => asset.oracle === OracleTypes.ChainlinkPriceOracleV2)
-//   .map((asset) => ({
-//     aggregator: (asset.oracleSpecificParams as ChainlinkSpecificParams).aggregator,
-//     feedBaseCurrency: (asset.oracleSpecificParams as ChainlinkSpecificParams).feedBaseCurrency,
-//     symbol: asset.symbol
-//   }));
+export const deployConfig: ChainDeployConfig = {
+  blocksPerYear: Number(base.specificParams.blocksPerYear),
+  cgId: base.specificParams.cgId,
+  nativeTokenName: "Base",
+  nativeTokenSymbol: "ETH",
+  stableToken: base.chainAddresses.STABLE_TOKEN,
+  uniswap: {
+    flashSwapFee: 30, // TODO set the correct fee
+    hardcoded: [],
+    uniswapData: [],
+    uniswapOracleInitialDeployTokens: [],
+    uniswapV2FactoryAddress: "0x8909Dc15e40173Ff4699343b6eB8132c65e18eC6",
+    uniswapV2RouterAddress: "0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24",
+    uniswapV3SwapRouter: "0x2626664c2603336E57B271c5C0b26F421741e481",
+    uniswapV3Quoter: "0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a"
+  },
+  wtoken: base.chainAddresses.W_TOKEN,
+  nativeTokenUsdChainlinkFeed: base.chainAddresses.W_TOKEN_USD_CHAINLINK_PRICE_FEED
+};
 
-// export const deploy = async ({ run, ethers, getNamedAccounts, deployments }): Promise<void> => {
-//   const { deployer } = await getNamedAccounts();
+const aerodromeAssets: SupportedAsset[] = base.assets.filter(
+  (asset) => asset.oracle === OracleTypes.AerodromePriceOracle
+);
 
-//   //// ChainLinkV2 Oracle
-//   await deployChainlinkOracle({
-//     run,
-//     ethers,
-//     getNamedAccounts,
-//     deployments,
-//     deployConfig,
-//     assets,
-//     chainlinkAssets
-//   });
+export const deploy = async ({ run, viem, getNamedAccounts, deployments }: HardhatRuntimeEnvironment): Promise<void> => {
+  const { deployer } = await getNamedAccounts();
 
-//   //// Uniswap V3 Liquidator Funder
-//   const uniswapV3LiquidatorFunder = await deployments.deploy("UniswapV3LiquidatorFunder", {
-//     from: deployer,
-//     args: [],
-//     log: true,
-//     waitConfirmations: 1
-//   });
-//   console.log("UniswapV3LiquidatorFunder: ", uniswapV3LiquidatorFunder.address);
+  //// ChainLinkV2 Oracle
+  await deployAerodromeOracle({
+    run,
+    viem,
+    getNamedAccounts,
+    deployments,
+    deployConfig,
+    assets: aerodromeAssets,
+    pricesContract
+  });
 
-//   const solidlySwapLiquidator = await deployments.deploy("SolidlySwapLiquidator", {
-//     from: deployer,
-//     args: [],
-//     log: true,
-//     waitConfirmations: 1
-//   });
-//   console.log("solidlySwapLiquidator: ", solidlySwapLiquidator.address);
-// };
+  //// Uniswap V3 Liquidator Funder
+  const uniswapV3LiquidatorFunder = await deployments.deploy("UniswapV3LiquidatorFunder", {
+    from: deployer,
+    args: [],
+    log: true,
+    waitConfirmations: 1
+  });
+  console.log("UniswapV3LiquidatorFunder: ", uniswapV3LiquidatorFunder.address);
+
+  const solidlySwapLiquidator = await deployments.deploy("SolidlySwapLiquidator", {
+    from: deployer,
+    args: [],
+    log: true,
+    waitConfirmations: 1
+  });
+  console.log("solidlySwapLiquidator: ", solidlySwapLiquidator.address);
+};
diff --git a/chainDeploy/mainnets/mode.ts b/chainDeploy/mainnets/mode.ts
@@ -1,7 +1,6 @@
 import { Hash, zeroAddress } from "viem";
 
 import { ChainDeployConfig, deployChainlinkOracle, deployPythPriceOracle } from "../helpers";
-import { writeTransactionsToFile } from "../helpers/logging";
 import { addRedstoneFallbacks } from "../helpers/oracles/redstoneFallbacks";
 import { addRedstoneWeETHFallbacks } from "../helpers/oracles/redstoneWeETHFallbacks";
 import { deployRedStoneWrsETHPriceOracle } from "../helpers/oracles/redstoneWrsETH";
@@ -145,5 +144,4 @@ export const deploy = async ({
     await publicClient.waitForTransactionReceipt({ hash: algebraSwapLiquidator.transactionHash as Hash });
   }
   console.log("AlgebraSwapLiquidator: ", algebraSwapLiquidator.address);
-  await writeTransactionsToFile();
 };
diff --git a/chains/assets.ts b/chains/assets.ts
@@ -16,5 +16,6 @@ export enum assetSymbols {
   OP = "OP",
   LUSD = "LUSD",
   SOV = "SOV",
-  tBTC = "tBTC"
+  tBTC = "tBTC",
+  ION = "ION"
 }
diff --git a/chains/base/assets.ts b/chains/base/assets.ts
@@ -13,6 +13,7 @@ export const WBTC = "0x1ceA84203673764244E05693e42E6Ace62bE9BA5";
 export const weETH = "0x04C0599Ae5A44757c0af6F9eC3b93da8976c150A";
 export const eUSD = "0xcfa3ef56d303ae4faaba0592388f19d7c3399fb4";
 export const bsdETH = "0xcb327b99ff831bf8223cced12b1338ff3aa322ff";
+export const ION = "0x3eE5e23eEE121094f1cFc0Ccc79d6C809Ebd22e5";
 
 export const assets: SupportedAsset[] = [
   {
@@ -138,6 +139,13 @@ export const assets: SupportedAsset[] = [
     initialSupplyCap: parseEther(String(6_500)).toString(),
     initialBorrowCap: parseEther(String(5_200)).toString(),
     initialCf: "70"
+  },
+  {
+    symbol: assetSymbols.ION,
+    underlying: ION,
+    name: "Ionic",
+    decimals: 18,
+    oracle: OracleTypes.AerodromePriceOracle
   }
 ];
 
diff --git a/chains/index.ts b/chains/index.ts
@@ -1,8 +1,10 @@
 import { default as mode } from "./mode";
+import { default as base } from "./base";
 import { ChainConfig } from "./types";
 
-export { mode };
+export { mode, base };
 
 export const chainIdToConfig: { [chainId: number]: ChainConfig } = {
-  [mode.chainId]: mode
+  [mode.chainId]: mode,
+  [base.chainId]: base
 };
diff --git a/chains/types.ts b/chains/types.ts
@@ -168,6 +168,12 @@ export type ChainlinkDeployFnParams = ChainDeployFnParams & {
   deployConfig: ChainDeployConfig;
 };
 
+export type AerodromeDeployFnParams = ChainDeployFnParams & {
+  assets: SupportedAsset[];
+  pricesContract: Address;
+  deployConfig: ChainDeployConfig;
+};
+
 export type DiaDeployFnParams = ChainDeployFnParams & {
   diaAssets: DiaAsset[];
   deployConfig: ChainDeployConfig;
@@ -281,6 +287,10 @@ export type PythSpecificParams = {
   feed: string;
 };
 
+export type VelodromeSpecificParams = {
+  pricesContract: Address;
+};
+
 export type SupportedAsset = {
   symbol: string;
   underlying: Address;
@@ -291,7 +301,7 @@ export type SupportedAsset = {
   oracle?: OracleTypes;
   simplePriceOracleAssetPrice?: bigint;
   originalSymbol?: string;
-  oracleSpecificParams?: ChainlinkSpecificParams | PythSpecificParams;
+  oracleSpecificParams?: ChainlinkSpecificParams | PythSpecificParams | VelodromeSpecificParams;
   initialCf?: string;
   initialBorrowCap?: string;
   initialSupplyCap?: string;
@@ -309,7 +319,9 @@ export enum OracleTypes {
   ERC4626Oracle = "ERC4626Oracle",
   PythPriceOracle = "PythPriceOracle",
   RedstoneAdapterPriceOracle = "RedstoneAdapterPriceOracle",
-  RedstoneAdapterWrsETHPriceOracle = "RedstoneAdapterWrsETHPriceOracle"
+  RedstoneAdapterWrsETHPriceOracle = "RedstoneAdapterWrsETHPriceOracle",
+  VelodromePriceOracle = "VelodromePriceOracle",
+  AerodromePriceOracle = "AerodromePriceOracle"
 }
 
 export type ChainAddresses = {
diff --git a/contracts/oracles/default/AerodromePriceOracle.sol b/contracts/oracles/default/AerodromePriceOracle.sol
@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity >=0.8.0;
+
+import "../BasePriceOracle.sol";
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+interface BasePrices {
+  function getManyRatesWithConnectors(
+    uint8 src_len,
+    address[] memory connectors
+  ) external view returns (uint256[] memory rates);
+}
+
+contract AerodromePriceOracle is BasePriceOracle {
+  BasePrices immutable prices;
+  address constant WETH = 0x4200000000000000000000000000000000000006;
+
+  constructor(address _prices) {
+    prices = BasePrices(_prices);
+  }
+
+  /**
+   * @notice Fetches the token/ETH price, with 18 decimals of precision.
+   * @param underlying The underlying token address for which to get the price.
+   * @return Price denominated in ETH (scaled by 1e18)
+   */
+  function price(address underlying) external view override returns (uint256) {
+    return _price(underlying);
+  }
+
+  /**
+   * @notice Returns the price in ETH of the token underlying `cToken`.
+   * @dev Implements the `PriceOracle` interface for Ionic pools (and Compound v2).
+   * @return Price in ETH of the token underlying `cToken`, scaled by `10 ** (36 - underlyingDecimals)`.
+   */
+  function getUnderlyingPrice(ICErc20 cToken) external view override returns (uint256) {
+    address underlying = cToken.underlying();
+    // Comptroller needs prices to be scaled by 1e(36 - decimals)
+    // Since `_price` returns prices scaled by 18 decimals, we must scale them by 1e(36 - 18 - decimals)
+    return (_price(underlying));
+  }
+
+  /**
+   * @notice Fetches the token/ETH price, with 18 decimals of precision.
+   */
+  function _price(address token) internal view returns (uint256) {
+    address[] memory connectors = new address[](2);
+    connectors[0] = token;
+    connectors[1] = WETH;
+    return prices.getManyRatesWithConnectors(1, connectors)[0];
+  }
+}
diff --git a/contracts/oracles/default/VelodromePriceOracle.sol b/contracts/oracles/default/VelodromePriceOracle.sol
@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity >=0.8.0;
+
+import "../BasePriceOracle.sol";
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+interface Prices {
+  function getRateToEth(address srcToken, bool useSrcWrappers) external view returns (uint256 weightedRate);
+}
+
+contract VelodromePriceOracle is BasePriceOracle {
+  Prices immutable prices;
+
+  constructor(address _prices) {
+    prices = Prices(_prices);
+  }
+  /**
+   * @notice Fetches the token/ETH price, with 18 decimals of precision.
+   * @param underlying The underlying token address for which to get the price.
+   * @return Price denominated in ETH (scaled by 1e18)
+   */
+  function price(address underlying) external view override returns (uint256) {
+    return _price(underlying);
+  }
+
+  /**
+   * @notice Returns the price in ETH of the token underlying `cToken`.
+   * @dev Implements the `PriceOracle` interface for Ionic pools (and Compound v2).
+   * @return Price in ETH of the token underlying `cToken`, scaled by `10 ** (36 - underlyingDecimals)`.
+   */
+  function getUnderlyingPrice(ICErc20 cToken) external view override returns (uint256) {
+    address underlying = cToken.underlying();
+    // Comptroller needs prices to be scaled by 1e(36 - decimals)
+    // Since `_price` returns prices scaled by 18 decimals, we must scale them by 1e(36 - 18 - decimals)
+    return (_price(underlying));
+  }
+
+  /**
+   * @notice Fetches the token/ETH price, with 18 decimals of precision.
+   */
+  function _price(address token) internal view returns (uint256) {
+    return prices.getRateToEth(token, false);
+  }
+}
diff --git a/deployments/base/AerodromePriceOracle.json b/deployments/base/AerodromePriceOracle.json
diff --git a/deployments/base/SolidlySwapLiquidator.json b/deployments/base/SolidlySwapLiquidator.json
diff --git a/deployments/base/UniswapV3LiquidatorFunder.json b/deployments/base/UniswapV3LiquidatorFunder.json
diff --git a/deployments/base/solcInputs/49404c9788cc2cd20379cd4520092cf4.json b/deployments/base/solcInputs/49404c9788cc2cd20379cd4520092cf4.json

Original file line number	Diff line number	Diff line change
`@@ -16,5 +16,6 @@ export enum assetSymbols {`
`16`	`16`	`OP = "OP",`
`17`	`17`	`LUSD = "LUSD",`
`18`	`18`	`SOV = "SOV",`
`19`		`- tBTC = "tBTC"`
	`19`	`+ tBTC = "tBTC",`
	`20`	`+ ION = "ION"`
`20`	`21`	`}`