[VEN-1830]: Refactor constants and deployment scripts for the sepolia deployment

.env.example

@@ -1,4 +1,22 @@
-MNEMONIC=
-ETHERSCAN_API_KEY=ABC123ABC123ABC123ABC123ABC123ABC1
-FORK_MAINNET=false
-QUICK_NODE_KEY=ABC123ABC123ABC123ABC123ABC123ABC1
+# true or false
+FORK=false
+FORKED_NETWORK=bscmainnet
+
+# Replace with your deployer's private key
+DEPLOYER_PRIVATE_KEY=
+
+## Archive nodes - Replace <YOUR_KEY_HERE> with your actual keys and uncomment the line you need
+## ARCHIVE_NODE_bsctestnet=https://bsc-testnet.nodereal.io/v1/<YOUR_KEY_HERE>
+## ARCHIVE_NODE_bscmainnet=https://bsc-mainnet.nodereal.io/v1/<YOUR_KEY_HERE>
+## ARCHIVE_NODE_sepolia=https://ethereum-sepolia.blockpi.network/v1/rpc/public
+## ARCHIVE_NODE_ethereum=https://eth-mainnet.nodereal.io/v1/<YOUR_KEY_HERE>
+
+# Uncomment the lines below if you want to deploy on mainnet using Frame Wallet
+#ARCHIVE_NODE_ethereum=http://127.0.0.1:1248
+#ARCHIVE_NODE_bscmainnet=http://127.0.0.1:1248
+
+# Replace with your Etherscan API key
+ETHERSCAN_API_KEY=
+
+# Set to true or false to control gas reporting
+REPORT_GAS=

contracts/BaseJumpRateModelV2.sol

@@ -4,7 +4,7 @@ pragma solidity 0.8.13;
 import { IAccessControlManagerV8 } from "@venusprotocol/governance-contracts/contracts/Governance/IAccessControlManagerV8.sol";
 
 import { InterestRateModel } from "./InterestRateModel.sol";
-import { BLOCKS_PER_YEAR, EXP_SCALE, MANTISSA_ONE } from "./lib/constants.sol";
+import { EXP_SCALE, MANTISSA_ONE } from "./lib/constants.sol";
 
 /**
  * @title Logic for Compound's JumpRateModel Contract V2.
@@ -13,6 +13,10 @@ import { BLOCKS_PER_YEAR, EXP_SCALE, MANTISSA_ONE } from "./lib/constants.sol";
  * The parameters of this interest rate model can be adjusted by the owner. Version 2 modifies Version 1 by enabling updateable parameters.
  */
 abstract contract BaseJumpRateModelV2 is InterestRateModel {
+    /**
+     * @notice The approximate number of blocks per year that is assumed by the interest rate model
+     */
+    uint256 public immutable blocksPerYear;
     /**
      * @notice The address of the AccessControlManager contract
      */
@@ -52,22 +56,25 @@ abstract contract BaseJumpRateModelV2 is InterestRateModel {
 
     /**
      * @notice Construct an interest rate model
+     * @param blocksPerYear_  The approximate number of blocks per year that is assumed by the interest rate model.
      * @param baseRatePerYear The approximate target base APR, as a mantissa (scaled by EXP_SCALE)
      * @param multiplierPerYear The rate of increase in interest rate wrt utilization (scaled by EXP_SCALE)
      * @param jumpMultiplierPerYear The multiplierPerBlock after hitting a specified utilization point
      * @param kink_ The utilization point at which the jump multiplier is applied
      * @param accessControlManager_ The address of the AccessControlManager contract
      */
     constructor(
+        uint256 blocksPerYear_,
         uint256 baseRatePerYear,
         uint256 multiplierPerYear,
         uint256 jumpMultiplierPerYear,
         uint256 kink_,
         IAccessControlManagerV8 accessControlManager_
     ) {
         require(address(accessControlManager_) != address(0), "invalid ACM address");
-
+        require(blocksPerYear_ != 0, "Invalid blocks per year");
         accessControlManager = accessControlManager_;
+        blocksPerYear = blocksPerYear_;
 
         _updateJumpRateModel(baseRatePerYear, multiplierPerYear, jumpMultiplierPerYear, kink_);
     }
@@ -162,9 +169,9 @@ abstract contract BaseJumpRateModelV2 is InterestRateModel {
         uint256 jumpMultiplierPerYear,
         uint256 kink_
     ) internal {
-        baseRatePerBlock = baseRatePerYear / BLOCKS_PER_YEAR;
-        multiplierPerBlock = multiplierPerYear / BLOCKS_PER_YEAR;
-        jumpMultiplierPerBlock = jumpMultiplierPerYear / BLOCKS_PER_YEAR;
+        baseRatePerBlock = baseRatePerYear / blocksPerYear;
+        multiplierPerBlock = multiplierPerYear / blocksPerYear;
+        jumpMultiplierPerBlock = jumpMultiplierPerYear / blocksPerYear;
         kink = kink_;
 
         emit NewInterestParams(baseRatePerBlock, multiplierPerBlock, jumpMultiplierPerBlock, kink);

contracts/JumpRateModelV2.sol

@@ -12,13 +12,21 @@ import { BaseJumpRateModelV2 } from "./BaseJumpRateModelV2.sol";
  */
 contract JumpRateModelV2 is BaseJumpRateModelV2 {
     constructor(
+        uint256 blocksPerYear_,
         uint256 baseRatePerYear,
         uint256 multiplierPerYear,
         uint256 jumpMultiplierPerYear,
         uint256 kink_,
         IAccessControlManagerV8 accessControlManager_
     )
-        BaseJumpRateModelV2(baseRatePerYear, multiplierPerYear, jumpMultiplierPerYear, kink_, accessControlManager_)
+        BaseJumpRateModelV2(
+            blocksPerYear_,
+            baseRatePerYear,
+            multiplierPerYear,
+            jumpMultiplierPerYear,
+            kink_,
+            accessControlManager_
+        )
     /* solhint-disable-next-line no-empty-blocks */
     {
 

contracts/WhitePaperInterestRateModel.sol

@@ -2,14 +2,18 @@
 pragma solidity 0.8.13;
 
 import { InterestRateModel } from "./InterestRateModel.sol";
-import { BLOCKS_PER_YEAR, EXP_SCALE, MANTISSA_ONE } from "./lib/constants.sol";
+import { EXP_SCALE, MANTISSA_ONE } from "./lib/constants.sol";
 
 /**
  * @title Compound's WhitePaperInterestRateModel Contract
  * @author Compound
  * @notice The parameterized model described in section 2.4 of the original Compound Protocol whitepaper
  */
 contract WhitePaperInterestRateModel is InterestRateModel {
+    /**
+     * @notice The approximate number of blocks per year that is assumed by the interest rate model
+     */
+    uint256 public immutable blocksPerYear;
     /**
      * @notice The multiplier of utilization rate that gives the slope of the interest rate
      */
@@ -27,9 +31,11 @@ contract WhitePaperInterestRateModel is InterestRateModel {
      * @param baseRatePerYear The approximate target base APR, as a mantissa (scaled by EXP_SCALE)
      * @param multiplierPerYear The rate of increase in interest rate wrt utilization (scaled by EXP_SCALE)
      */
-    constructor(uint256 baseRatePerYear, uint256 multiplierPerYear) {
-        baseRatePerBlock = baseRatePerYear / BLOCKS_PER_YEAR;
-        multiplierPerBlock = multiplierPerYear / BLOCKS_PER_YEAR;
+    constructor(uint256 blocksPerYear_, uint256 baseRatePerYear, uint256 multiplierPerYear) {
+        require(blocksPerYear_ != 0, "Invalid blocks per year");
+        baseRatePerBlock = baseRatePerYear / blocksPerYear_;
+        multiplierPerBlock = multiplierPerYear / blocksPerYear_;
+        blocksPerYear = blocksPerYear_;
 
         emit NewInterestParams(baseRatePerBlock, multiplierPerBlock);
     }

contracts/lib/constants.sol

@@ -1,9 +1,6 @@
 // SPDX-License-Identifier: BSD-3-Clause
 pragma solidity 0.8.13;
 
-/// @dev The approximate number of blocks per year that is assumed by the interest rate model
-uint256 constant BLOCKS_PER_YEAR = 10_512_000;
-
 /// @dev Base unit for computations, usually used in scaling (multiplications, divisions)
 uint256 constant EXP_SCALE = 1e18;
 

deploy/003-price-oracle-configure-feeds.ts

@@ -1,4 +1,4 @@
-import configureOracleFeeds from "@venusprotocol/oracle/dist/deploy/2-configure-feeds";
+import configureOracleFeeds from "@venusprotocol/oracle/dist/deploy/3-configure-feeds";
 import { HardhatRuntimeEnvironment } from "hardhat/types";
 
 configureOracleFeeds.tags = ["Oracle"];

deploy/009-deploy-vtokens.ts

@@ -5,11 +5,10 @@ import { DeployResult } from "hardhat-deploy/dist/types";
 import { DeployFunction } from "hardhat-deploy/types";
 import { HardhatRuntimeEnvironment } from "hardhat/types";
 
-import { getConfig, getTokenConfig } from "../helpers/deploymentConfig";
+import { blocksPerYear, getConfig, getTokenConfig } from "../helpers/deploymentConfig";
 import { InterestRateModels } from "../helpers/deploymentConfig";
 import { getUnregisteredVTokens, toAddress } from "../helpers/deploymentUtils";
-
-const ADDRESS_ONE = "0x0000000000000000000000000000000000000001";
+import { AddressOne } from "../helpers/utils";
 
 const mantissaToBps = (num: BigNumberish) => {
   return BigNumber.from(num).div(parseUnits("1", 14)).toString();
@@ -20,7 +19,6 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
   const { deploy } = deployments;
   const { deployer } = await getNamedAccounts();
   const { tokensConfig, poolConfig, preconfiguredAddresses } = await getConfig(hre.network.name);
-  const protocolShareReserve = await deployments.getOrNull("ProtocolShareReserve");
 
   const accessControlManagerAddress = await toAddress(
     preconfiguredAddresses.AccessControlManager || "AccessControlManager",
@@ -74,14 +72,22 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
       }
 
       let rateModelAddress: string;
+      const BLOCKS_PER_YEAR: number = blocksPerYear[hre.network.name];
       if (rateModel === InterestRateModels.JumpRate.toString()) {
         const [b, m, j, k] = [baseRatePerYear, multiplierPerYear, jumpMultiplierPerYear, kink_].map(mantissaToBps);
         const rateModelName = `JumpRateModelV2_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: "JumpRateModelV2",
-          args: [baseRatePerYear, multiplierPerYear, jumpMultiplierPerYear, kink_, accessControlManagerAddress],
+          args: [
+            BLOCKS_PER_YEAR,
+            baseRatePerYear,
+            multiplierPerYear,
+            jumpMultiplierPerYear,
+            kink_,
+            accessControlManagerAddress,
+          ],
           log: true,
           autoMine: true,
         });
@@ -93,7 +99,7 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
         const result: DeployResult = await deploy(rateModelName, {
           from: deployer,
           contract: "WhitePaperInterestRateModel",
-          args: [baseRatePerYear, multiplierPerYear],
+          args: [BLOCKS_PER_YEAR, baseRatePerYear, multiplierPerYear],
           log: true,
           autoMine: true,
         });
@@ -115,10 +121,7 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
         vTokenDecimals,
         preconfiguredAddresses.NormalTimelock || deployer, // admin
         accessControlManagerAddress,
-        [
-          preconfiguredAddresses.Shortfall || ADDRESS_ONE,
-          protocolShareReserve ? protocolShareReserve.address : treasuryAddress,
-        ],
+        [AddressOne, treasuryAddress],
         reserveFactor,
       ];
       await deploy(`VToken_${symbol}`, {

deploy/011-initial-liquidity.ts

@@ -10,7 +10,7 @@ import {
   getConfig,
   getTokenConfig,
 } from "../helpers/deploymentConfig";
-import { getUnderlyingMock, getUnderlyingToken, getUnregisteredVTokens } from "../helpers/deploymentUtils";
+import { getUnderlyingMock, getUnderlyingToken, getUnregisteredVTokens, toAddress } from "../helpers/deploymentUtils";
 
 const sumAmounts = async (tokens: { symbol: string; amount: BigNumber }[]) => {
   const amounts: { [symbol: string]: BigNumber } = {};
@@ -44,8 +44,8 @@ const faucetTokens = async (deploymentConfig: DeploymentConfig, hre: HardhatRunt
   }
 };
 
-const approveTimelock = async (deploymentConfig: DeploymentConfig, hre: HardhatRuntimeEnvironment) => {
-  if (hre.network.name !== "bsctestnet") {
+const sendInitialLiquidityToTreasury = async (deploymentConfig: DeploymentConfig, hre: HardhatRuntimeEnvironment) => {
+  if (hre.network.name == "bscmainnet" || hre.network.name == "ethereum") {
     return;
   }
   const { poolConfig, tokensConfig, preconfiguredAddresses } = deploymentConfig;
@@ -59,16 +59,21 @@ const approveTimelock = async (deploymentConfig: DeploymentConfig, hre: HardhatR
   const totalAmounts = await sumAmounts(amounts);
   for (const [symbol, amount] of Object.entries(totalAmounts)) {
     const tokenContract = await getUnderlyingToken(symbol, tokensConfig);
-    console.log(`Approving ${amount} ${symbol} to Timelock`);
-    const tx = await tokenContract.approve(preconfiguredAddresses.NormalTimelock, amount, { gasLimit: 5000000 });
+    console.log(`Sending ${amount} ${symbol} to VTreasury`);
+    console.log(`Token Contract: ${tokenContract.address}`);
+    console.log(`Token Contract: ${amount.toString()}`);
+    const treasuryAddress = await toAddress(preconfiguredAddresses.VTreasury || "VTreasury", hre);
+    console.log(`Token Contract: ${treasuryAddress}`);
+
+    const tx = await tokenContract.transfer(treasuryAddress, amount, { gasLimit: 5000000 });
     await tx.wait(1);
   }
 };
 
 const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
   const deploymentConfig = await getConfig(hre.network.name);
   await faucetTokens(deploymentConfig, hre);
-  await approveTimelock(deploymentConfig, hre);
+  await sendInitialLiquidityToTreasury(deploymentConfig, hre);
 };
 
 func.tags = ["InitialLiquidity", "il"];

deploy/013-vip-based-config.ts

@@ -26,7 +26,7 @@
   contract: string;
   signature: string;
   argTypes: string[];
   parameters: any[];
   value: BigNumberish;
 }
 
@@ -177,36 +177,23 @@
   deploymentConfig: DeploymentConfig,
   hre: HardhatRuntimeEnvironment,
 ): Promise<GovernanceCommand[]> => {
-  const { deployer } = await hre.getNamedAccounts();
+  if (!hre.network.live) {
+    return [];
+  }
   const { preconfiguredAddresses, tokensConfig } = deploymentConfig;
   const { asset, initialSupply } = vTokenConfig;
   const token = getTokenConfig(asset, tokensConfig);
   const tokenContract = await getUnderlyingToken(token.symbol, tokensConfig);
-
-  if (hre.network.name === "bsctestnet") {
-    console.log(`Adding a command to transfer ${initialSupply} ${token.symbol} to Timelock`);
-    return [
-      {
-        contract: tokenContract.address,
-        signature: "transferFrom(address,address,uint256)",
-        argTypes: ["address", "address", "uint256"],
-        parameters: [deployer, preconfiguredAddresses.NormalTimelock, initialSupply],
-        value: 0,
-      },
-    ];
-  } else if (hre.network.name === "bscmainnet") {
-    console.log(`Adding a command to withdraw ${initialSupply} ${token.symbol} to Timelock`);
-    return [
-      {
-        contract: preconfiguredAddresses.VTreasury,
-        signature: "withdrawTreasuryBEP20(address,uint256,address)",
-        argTypes: ["address", "uint256", "address"],
-        parameters: [tokenContract.address, initialSupply, preconfiguredAddresses.NormalTimelock],
-        value: 0,
-      },
-    ];
-  }
-  return [];
+  console.log(`Adding a command to withdraw ${initialSupply} ${token.symbol} to Timelock from Treasury`);
+  return [
+    {
+      contract: preconfiguredAddresses.VTreasury,
+      signature: "withdrawTreasuryToken(address,uint256,address)",
+      argTypes: ["address", "uint256", "address"],
+      parameters: [tokenContract.address, initialSupply, preconfiguredAddresses.NormalTimelock],
+      value: 0,
+    },
+  ];
 };
 
 const approvePoolRegistry = async (
@@ -318,7 +305,7 @@
   caller: string,
   hre: HardhatRuntimeEnvironment,
 ): Promise<boolean> => {
-  const role = makeRole(hre.network.name === "bscmainnet", targetContract, method);
+  const role = makeRole(hre.network.live, targetContract, method);
   return accessControl.hasRole(role, caller);
 };
 
@@ -360,7 +347,7 @@
 const logCommand = (prefix: string, command: GovernanceCommand) => {
   const valueStr = command.value == 0 ? "" : "{ value: " + parseEther(command.value.toString()) + " }";
   console.log(`${prefix} ${command.contract}.${command.signature}${valueStr} (`);
   command.parameters.forEach((param: any) => console.log(`  ${param},`));
   console.log(")");
 };
 

deploy/015-transfer-funds-ownership.ts

@@ -0,0 +1,47 @@
+import { ethers } from "hardhat";
+import { DeployFunction } from "hardhat-deploy/types";
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+
+import { ETHEREUM_MULTISIG, SEPOLIA_MULTISIG } from "../helpers/deploymentConfig";
+
+interface Config {
+  [key: string]: string;
+}
+
+const TESTNET_MNEMONIC_SIGNER = "0xFA747c4a62c4D168276329F822d004026A1c05E9"; // signer[1] from testnet mnemonic
+
+const targetOwners: Config = {
+  hardhat: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8", // signer[1] from hardhat mnemonic
+  bsctestnet: TESTNET_MNEMONIC_SIGNER,
+  bscmainnet: "0x939bD8d64c0A9583A7Dcea9933f7b21697ab6396", // NORMAL VIP Timelock
+  sepolia: SEPOLIA_MULTISIG,
+  ethereum: ETHEREUM_MULTISIG,
+};
+
+const contracts = ["RiskFund", "Shortfall", "ProtocolShareReserve"];
+
+const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  await transfer2StepOwnerships(contracts, hre.network.name);
+};
+
+const transfer2StepOwnerships = async (contractNames: string[], networkName: string) => {
+  for (const contractName of contractNames) {
+    const contract = await ethers.getContract(contractName);
+    const owner = await contract.owner();
+
+    let tx;
+    if (owner !== targetOwners[networkName]) {
+      tx = await contract.transferOwnership(targetOwners[networkName]);
+      await tx.wait(1);
+      const pendingOwner = await contract.pendingOwner();
+      console.log(
+        `${contractName} owner ${owner} sucessfully changed to ${pendingOwner}. Please accept the ownership.`,
+      );
+    } else {
+      console.error(`${contractName} owner ${owner} is equal to target ownership address ${targetOwners[networkName]}`);
+    }
+  }
+};
+
+func.tags = ["TransferFundsOwnership"];
+export default func;