@venusprotocol/venus-protocol 9.8.0-dev.6 → 9.8.0-dev.7

package/deploy/002-interest-rate-model.ts

@@ -1,18 +1,19 @@
-import { BigNumber, BigNumberish } from "ethers";
-import { parseUnits } from "ethers/lib/utils";
 import { DeployFunction } from "hardhat-deploy/types";
 import { HardhatRuntimeEnvironment } from "hardhat/types";
 
-const mantissaToBps = (num: BigNumberish) => {
-  return BigNumber.from(num).div(parseUnits("1", 14)).toString();
-};
+import { assertBlockBasedChain, blocksPerYear as chainBlocksPerYear } from "../helpers/chains";
+import { skipRemoteNetworks } from "../helpers/deploymentConfig";
+import { markets } from "../helpers/markets";
+import { getRateModelName } from "../helpers/rateModelHelpers";
 
 const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
   const { deployments, getNamedAccounts, network } = hre;
   const { deploy } = deployments;
+  const chain = assertBlockBasedChain(hre.network.name);
 
   const { deployer } = await getNamedAccounts();
 
+  // Keeping this hardcoded since 003-deploy-VBep20 (used in subgraph tests) depends on it
   if (!network.live) {
     await deploy("InterestRateModelVUSDC", {
       contract: "JumpRateModel",
@@ -31,89 +32,64 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
     });
   }
 
-  if (network.name === "bscmainnet") {
-    await deploy("InterestRateModelVETH", {
-      contract: "JumpRateModel",
-      from: deployer,
-      log: true,
-      autoMine: true,
-      args: [0, parseUnits("0.03", 18), parseUnits("4.5", 18), parseUnits("0.9", 18)],
-    });
+  const marketsConfig = markets[chain];
+  const blocksPerYear = chainBlocksPerYear[chain];
 
-    let baseRatePerYear = parseUnits("0", 18);
-    let multiplierPerYear = parseUnits("0.175", 18);
-    let jumpMultiplierPerYear = parseUnits("2.5", 18);
-    let kink = parseUnits("0.8", 18);
-    const [b, m, j, k] = [baseRatePerYear, multiplierPerYear, jumpMultiplierPerYear, kink].map(mantissaToBps);
-    let rateModelName = `JumpRateModel_base${b}bps_slope${m}bps_jump${j}bps_kink${k}bps`;
-
-    await deploy(rateModelName, {
-      contract: "JumpRateModel",
-      from: deployer,
-      log: true,
-      autoMine: true,
-      args: [baseRatePerYear, multiplierPerYear, jumpMultiplierPerYear, kink],
-      skipIfAlreadyDeployed: true,
-    });
+  for (const market of marketsConfig) {
+    const { interestRateModel, symbol } = market;
+    const rateModelName = getRateModelName(interestRateModel, blocksPerYear);
+    console.log(`Deploying interest rate model ${rateModelName} for ${symbol}`);
 
-    baseRatePerYear = parseUnits("0", 18);
-    multiplierPerYear = parseUnits("0.15", 18);
-    jumpMultiplierPerYear = parseUnits("3", 18);
-    kink = parseUnits("0.8", 18);
-    const baseRatePerYear2 = parseUnits("0", 18);
-    const multiplierPerYear2 = parseUnits("0.9", 18);
-    const kink2_ = parseUnits("0.9", 18);
-
-    const [b1, m1, k1, m2, b2, k2, j2] = [
-      baseRatePerYear,
-      multiplierPerYear,
-      kink,
-      multiplierPerYear2,
-      baseRatePerYear2,
-      kink2_,
-      jumpMultiplierPerYear,
-    ].map(mantissaToBps);
-    rateModelName = `TwoKinks_base${b1}bps_slope${m1}bps_kink${k1}bps_slope2${m2}bps_base2${b2}bps_kink2${k2}bps_jump${j2}bps`;
-
-    await deploy(rateModelName, {
-      contract: "TwoKinksInterestRateModel",
-      from: deployer,
-      log: true,
-      autoMine: true,
-      args: [
-        baseRatePerYear,
-        multiplierPerYear,
-        kink,
-        multiplierPerYear2,
-        baseRatePerYear2,
-        kink2_,
-        jumpMultiplierPerYear,
-      ],
-      skipIfAlreadyDeployed: true,
-    });
-  }
-
-  if (network.name === "bscmainnet" || network.name === "bsctestnet") {
-    await deploy("InterestRateModelVBNB", {
-      contract: "TwoKinksInterestRateModel",
-      from: deployer,
-      log: true,
-      autoMine: true,
-      args: [
-        parseUnits("0", 18), // base rate 1
-        parseUnits("0.035", 18), // multiplier 1
-        parseUnits("0.8", 18), // kink 1
-        parseUnits("1.75", 18), // multiplier 2
-        parseUnits("0", 18), // base rate 2
-        parseUnits("0.9", 18), // kink 2
-        parseUnits("3", 18), // jump multiplier
-      ],
-    });
+    if (interestRateModel.model === "whitepaper") {
+      await deploy(rateModelName, {
+        from: deployer,
+        contract: "WhitePaperInterestRateModel",
+        args: [
+          interestRateModel.baseRatePerYear,
+          interestRateModel.multiplierPerYear,
+          //blocksPerYear
+        ],
+        log: true,
+        autoMine: true,
+        skipIfAlreadyDeployed: true,
+      });
+    } else if (interestRateModel.model === "jump") {
+      await deploy(rateModelName, {
+        from: deployer,
+        contract: "JumpRateModel",
+        args: [
+          interestRateModel.baseRatePerYear,
+          interestRateModel.multiplierPerYear,
+          interestRateModel.jumpMultiplierPerYear,
+          interestRateModel.kink,
+          //blocksPerYear
+        ],
+        log: true,
+        autoMine: true,
+        skipIfAlreadyDeployed: true,
+      });
+    } else if (interestRateModel.model === "two-kinks") {
+      await deploy(rateModelName, {
+        contract: "TwoKinksInterestRateModel",
+        from: deployer,
+        args: [
+          interestRateModel.baseRatePerYear,
+          interestRateModel.multiplierPerYear,
+          interestRateModel.kink,
+          interestRateModel.multiplierPerYear2,
+          interestRateModel.baseRatePerYear2,
+          interestRateModel.kink2,
+          interestRateModel.jumpMultiplierPerYear,
+        ],
+        log: true,
+        autoMine: true,
+        skipIfAlreadyDeployed: true,
+      });
+    }
   }
 };
 
 func.tags = ["InterestRateModel"];
-func.skip = async hre =>
-  hre.network.name !== "hardhat" && hre.network.name !== "bscmainnet" && hre.network.name !== "bsctestnet";
+func.skip = skipRemoteNetworks();
 
 export default func;

package/deploy/007-deploy-mock-tokens.ts

@@ -1,14 +1,15 @@
 import { DeployFunction } from "hardhat-deploy/types";
 import { HardhatRuntimeEnvironment } from "hardhat/types";
 
-import { getConfig } from "../helpers/deploymentConfig";
+import { assertKnownChain } from "../helpers/chains";
+import { tokens } from "../helpers/tokens";
 
 const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
   const { deployments, getNamedAccounts }: any = hre;
   const { deploy } = deployments;
   const { deployer } = await getNamedAccounts();
-
-  const { tokensConfig } = await getConfig(hre.network.name);
+  const chain = assertKnownChain(hre.network.name);
+  const tokensConfig = Object.values(tokens[chain]);
 
   for (const token of tokensConfig) {
     if (token.isMock) {

package/deploy/011-deploy-markets.ts

@@ -1,15 +1,13 @@
-import { BigNumber, BigNumberish } from "ethers";
 import { parseUnits } from "ethers/lib/utils";
 import { ethers } from "hardhat";
 import { network } from "hardhat";
-import { DeployFunction, DeployResult } from "hardhat-deploy/types";
+import { DeployFunction } from "hardhat-deploy/types";
 import { HardhatRuntimeEnvironment } from "hardhat/types";
 
-import { InterestRateModels, getConfig, getTokenConfig, skipRemoteNetworks } from "../helpers/deploymentConfig";
-
-const mantissaToBps = (num: BigNumberish) => {
-  return BigNumber.from(num).div(parseUnits("1", 14)).toString();
-};
+import { assertBlockBasedChain, blocksPerYear as chainBlocksPerYear } from "../helpers/chains";
+import { skipRemoteNetworks } from "../helpers/deploymentConfig";
+import { markets } from "../helpers/markets";
+import { getRateModelName } from "../helpers/rateModelHelpers";
 
 const VTOKEN_DECIMALS = 8;
 const EMPTY_BYTES_ARRAY = "0x";
@@ -19,50 +17,36 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
   const { deploy } = deployments;
 
   const { deployer } = await getNamedAccounts();
-  const { tokensConfig, marketsConfig } = await getConfig(hre.network.name);
+  const chain = assertBlockBasedChain(hre.network.name);
+  const marketsConfig = markets[chain];
+  const blocksPerYear = chainBlocksPerYear[chain];
 
   const comptrollerDeployment = await deployments.get("Unitroller");
 
   console.log(`Got deployment of Unitroller with address: ${comptrollerDeployment.address}`);
 
   for (const market of marketsConfig) {
-    const { name, asset, symbol, rateModel, baseRatePerYear, multiplierPerYear, jumpMultiplierPerYear, kink_ } = market;
+    const { name, asset, symbol, interestRateModel } = market;
+
+    // Short-circuit to avoid extra requests to the node if vToken already exists
+    const deployment = await deployments.getOrNull(symbol);
+    if (deployment !== null && deployment !== undefined) {
+      console.log(`Skipping ${symbol} deployment: found at ${deployment.address}`);
+      continue;
+    }
 
-    const token = getTokenConfig(asset, tokensConfig);
     let tokenContract;
-    if (token.isMock) {
-      tokenContract = await ethers.getContract(`Mock${token.symbol}`);
+    if (asset.isMock) {
+      tokenContract = await ethers.getContract(`Mock${asset.symbol}`);
     } else {
       tokenContract = await ethers.getContractAt(
         "@openzeppelin/contracts/token/ERC20/ERC20.sol:ERC20",
-        token.tokenAddress,
+        asset.tokenAddress,
       );
     }
 
-    let rateModelAddress: string;
-    if (rateModel === InterestRateModels.JumpRate.toString()) {
-      const [b, m, j, k] = [baseRatePerYear, multiplierPerYear, jumpMultiplierPerYear, kink_].map(mantissaToBps);
-      const rateModelName = `JumpRateModel_base${b}bps_slope${m}bps_jump${j}bps_kink${k}bps`;
-      console.log(`Deploying interest rate model ${rateModelName}`);
-      const result: DeployResult = await deploy(rateModelName, {
-        from: deployer,
-        contract: "JumpRateModel",
-        args: [baseRatePerYear, multiplierPerYear, jumpMultiplierPerYear, kink_],
-        log: true,
-      });
-      rateModelAddress = result.address;
-    } else {
-      const [b, m] = [baseRatePerYear, multiplierPerYear].map(mantissaToBps);
-      const rateModelName = `WhitePaperInterestRateModel_base${b}bps_slope${m}bps`;
-      console.log(`Deploying interest rate model ${rateModelName}`);
-      const result: DeployResult = await deploy(rateModelName, {
-        from: deployer,
-        contract: "WhitePaperInterestRateModel",
-        args: [baseRatePerYear, multiplierPerYear],
-        log: true,
-      });
-      rateModelAddress = result.address;
-    }
+    const rateModelName = getRateModelName(interestRateModel, blocksPerYear);
+    const rateModelAddress = (await deployments.get(rateModelName)).address;
 
     const underlyingDecimals = Number(await tokenContract.decimals());
     const normalTimelock = await ethers.getContract("NormalTimelock");

package/deploy/999-checks/001-check-rate-models.ts

@@ -0,0 +1,183 @@
+import { BigNumber, Contract } from "ethers";
+import { ethers } from "hardhat";
+import { DeployFunction } from "hardhat-deploy/types";
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+
+import { assertBlockBasedChain, blocksPerYear as chainBlocksPerYear } from "../../helpers/chains";
+import { markets } from "../../helpers/markets";
+import {
+  JumpRateModelParams,
+  Parsed,
+  RateModelParams,
+  TwoKinksRateModelParams,
+  WpRateModelParams,
+} from "../../helpers/markets/types";
+import { getRateModelName } from "../../helpers/rateModelHelpers";
+
+const expectEqual = (msg: string, a: BigNumber, b: BigNumber) => {
+  if (!a.eq(b)) {
+    throw new Error(`Expected ${a.toString()} == ${b.toString()}\n${msg}`);
+  }
+};
+
+const checkBlocksPerYear = async (rateModel: Contract, name: string, expected: number) => {
+  try {
+    expectEqual(
+      `Checking blocksPerYear for ${name} at ${rateModel.address}`,
+      await rateModel.blocksPerYear(),
+      BigNumber.from(expected),
+    );
+  } catch (err) {
+    console.warn(`Could not get blocks per year for rate model at ${rateModel.address}, assuming ${expected}`);
+  }
+};
+
+const checkWpRateModel = async (rateModelAddress: string, params: Parsed<WpRateModelParams>, blocksPerYear: number) => {
+  const name = getRateModelName(params, blocksPerYear);
+  const rateModel = await ethers.getContractAt("WhitePaperInterestRateModel", rateModelAddress);
+  await checkBlocksPerYear(rateModel, name, blocksPerYear);
+  expectEqual(
+    `Checking baseRatePerBlock for ${name} at ${rateModelAddress}`,
+    await rateModel.baseRatePerBlock(),
+    params.baseRatePerYear.div(blocksPerYear),
+  );
+  expectEqual(
+    `Checking multiplierPerBlock for ${name} at ${rateModelAddress}`,
+    await rateModel.multiplierPerBlock(),
+    params.multiplierPerYear.div(blocksPerYear),
+  );
+};
+
+const checkJumpRateModel = async (
+  rateModelAddress: string,
+  params: Parsed<JumpRateModelParams>,
+  blocksPerYear: number,
+) => {
+  const name = getRateModelName(params, blocksPerYear);
+  const rateModel = await ethers.getContractAt("JumpRateModel", rateModelAddress);
+  await checkBlocksPerYear(rateModel, name, blocksPerYear);
+  expectEqual(
+    `Checking baseRatePerBlock for ${name} at ${rateModelAddress}`,
+    await rateModel.baseRatePerBlock(),
+    params.baseRatePerYear.div(blocksPerYear),
+  );
+  expectEqual(
+    `Checking multiplierPerBlock for ${name} at ${rateModelAddress}`,
+    await rateModel.multiplierPerBlock(),
+    params.multiplierPerYear.div(blocksPerYear),
+  );
+  expectEqual(
+    `Checking jumpMultiplierPerBlock for ${name} at ${rateModelAddress}`,
+    await rateModel.jumpMultiplierPerBlock(),
+    params.jumpMultiplierPerYear.div(blocksPerYear),
+  );
+  expectEqual(`Checking kink for ${name} at ${rateModelAddress}`, await rateModel.kink(), params.kink);
+};
+
+const checkTwoKinksRateModel = async (
+  rateModelAddress: string,
+  params: Parsed<TwoKinksRateModelParams>,
+  blocksPerYear: number,
+) => {
+  const name = getRateModelName(params, blocksPerYear);
+  const rateModel = await ethers.getContractAt("TwoKinksInterestRateModel", rateModelAddress);
+  try {
+    expectEqual(
+      `Checking blocksPerYear for ${name} at ${rateModel.address}`,
+      await rateModel.BLOCKS_PER_YEAR(),
+      BigNumber.from(blocksPerYear),
+    );
+  } catch (err) {
+    console.warn(`Could not get blocks per year for rate model at ${rateModel.address}, assuming ${blocksPerYear}`);
+  }
+  expectEqual(
+    `Checking BASE_RATE_PER_BLOCK for ${name} at ${rateModelAddress}`,
+    await rateModel.BASE_RATE_PER_BLOCK(),
+    params.baseRatePerYear.div(blocksPerYear),
+  );
+  expectEqual(
+    `Checking MULTIPLIER_PER_BLOCK for ${name} at ${rateModelAddress}`,
+    await rateModel.MULTIPLIER_PER_BLOCK(),
+    params.multiplierPerYear.div(blocksPerYear),
+  );
+  expectEqual(`${name}.KINK_1`, await rateModel.KINK_1(), params.kink);
+  expectEqual(
+    `Checking BASE_RATE_2_PER_BLOCK for ${name} at ${rateModelAddress}`,
+    await rateModel.BASE_RATE_2_PER_BLOCK(),
+    params.baseRatePerYear2.div(blocksPerYear),
+  );
+  expectEqual(
+    `Checking MULTIPLIER_2_PER_BLOCK for ${name} at ${rateModelAddress}`,
+    await rateModel.MULTIPLIER_2_PER_BLOCK(),
+    params.multiplierPerYear2.div(blocksPerYear),
+  );
+  expectEqual(`${name}.KINK_2`, await rateModel.KINK_2(), params.kink2);
+  expectEqual(
+    `Checking JUMP_MULTIPLIER_PER_BLOCK for ${name} at ${rateModelAddress}`,
+    await rateModel.JUMP_MULTIPLIER_PER_BLOCK(),
+    params.jumpMultiplierPerYear.div(blocksPerYear),
+  );
+};
+
+const checkRateModel = (
+  rateModelAddress: string,
+  params: Parsed<RateModelParams>,
+  blocksPerYear: number,
+): Promise<void> => {
+  switch (params.model) {
+    case "whitepaper":
+      return checkWpRateModel(rateModelAddress, params, blocksPerYear);
+    case "jump":
+      return checkJumpRateModel(rateModelAddress, params, blocksPerYear);
+    case "two-kinks":
+      return checkTwoKinksRateModel(rateModelAddress, params, blocksPerYear);
+  }
+};
+
+const test = async <T>(message: string, check: () => T | Promise<T>) => {
+  try {
+    await check();
+    console.log(`✅ ${message}`);
+  } catch (err) {
+    console.log(`❌ Failure: ${message}`);
+    console.error(err);
+  }
+};
+
+const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  const { deployments } = hre;
+  const chain = assertBlockBasedChain(hre.network.name);
+  const marketsConfig = markets[chain];
+  const blocksPerYear = chainBlocksPerYear[chain];
+
+  for (const vTokenConfig of marketsConfig) {
+    const { symbol, interestRateModel } = vTokenConfig;
+    console.log(`Checking interest rate model of ${symbol}`);
+    const vTokenAddress = (await deployments.get(`${symbol}`)).address;
+    const vToken = await ethers.getContractAt("VToken", vTokenAddress);
+    const rateModelAddress = await vToken.interestRateModel();
+    const name = getRateModelName(interestRateModel, blocksPerYear);
+    await test(`Rate model at ${rateModelAddress} should be ${name}`, () =>
+      checkRateModel(rateModelAddress, interestRateModel, blocksPerYear));
+    const deployment = await deployments.getOrNull(name);
+    await test(`Deployment for ${name} exists`, () => {
+      if (!deployment) throw new Error(`Deployment for ${name} not found`);
+    });
+    if (!deployment) {
+      continue;
+    }
+    if (deployment.address === rateModelAddress) {
+      console.log(`✅ Deployment address matches the rate model address`);
+    } else {
+      console.warn(`⚠️ Deployment at ${deployment.address} does not match ${rateModelAddress}`);
+      await test(`Rate model at ${deployment.address} should still be ${name}`, () =>
+        checkRateModel(deployment.address, interestRateModel, blocksPerYear));
+    }
+    console.log(`-----------------------------------------`);
+  }
+};
+
+func.tags = ["CheckIRMs"];
+func.skip = async (hre: HardhatRuntimeEnvironment) => !hre.network.live;
+
+export default func;