@venusprotocol/isolated-pools 1.0.0-dev.2 → 1.0.0-dev.3

package/dist/deploy/012-riskfund-protocolshare.js

@@ -0,0 +1,139 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ERC20 = __importStar(require("@openzeppelin/contracts/build/contracts/ERC20.json"));
+const hardhat_1 = require("hardhat");
+const deploymentConfig_1 = require("../helpers/deploymentConfig");
+const utils_1 = require("../helpers/utils");
+const MIN_AMOUNT_TO_CONVERT = (0, utils_1.convertToUnit)(10, 18);
+const MIN_POOL_BAD_DEBT = (0, utils_1.convertToUnit)(1000, 18);
+const maxLoopsLimit = 150;
+const getAllMarkets = async (poolRegistry) => {
+    const pools = await poolRegistry.getAllPools();
+    const markets = await Promise.all(pools.map(async ({ comptroller }) => {
+        const poolComptroller = await hardhat_1.ethers.getContractAt("Comptroller", comptroller);
+        const vTokenAddresses = await poolComptroller.getAllMarkets();
+        const vTokens = await Promise.all(vTokenAddresses.map((vTokenAddress) => hardhat_1.ethers.getContractAt("VToken", vTokenAddress)));
+        return vTokens;
+    }));
+    return markets.flat();
+};
+const configureVToken = async (vToken, shortfallAddress, protocolShareReserveAddress) => {
+    console.log("Setting shortfall contract for vToken: ", vToken.address);
+    const tx1 = await vToken.setShortfallContract(shortfallAddress);
+    await tx1.wait();
+    console.log("Setting protocol share reserve for vToken: ", vToken.address);
+    const tx2 = await vToken.setProtocolShareReserve(protocolShareReserveAddress);
+    await tx2.wait();
+    console.log("Finished configuring vToken: ", vToken.address);
+};
+const acmAddresses = {
+    bsctestnet: "0x45f8a08F534f34A97187626E05d4b6648Eeaa9AA",
+    bscmainnet: "0x4788629ABc6cFCA10F9f969efdEAa1cF70c23555",
+};
+const func = async function (hre) {
+    const { deployments, getNamedAccounts } = hre;
+    const { deploy } = deployments;
+    const { deployer } = await getNamedAccounts();
+    const { tokensConfig } = await (0, deploymentConfig_1.getConfig)(hre.network.name);
+    const busdConfig = (0, deploymentConfig_1.getTokenConfig)("BUSD", tokensConfig);
+    let BUSD;
+    if (busdConfig.isMock) {
+        BUSD = await hardhat_1.ethers.getContract("MockBUSD");
+    }
+    else {
+        BUSD = await hardhat_1.ethers.getContractAt(ERC20.abi, busdConfig.tokenAddress);
+    }
+    const poolRegistry = await hardhat_1.ethers.getContract("PoolRegistry");
+    const deployerSigner = hardhat_1.ethers.provider.getSigner(deployer);
+    const swapRouter = await hardhat_1.ethers.getContract("SwapRouter");
+    let accessControl;
+    if (hre.network.live) {
+        const networkName = hre.network.name === "bscmainnet" ? "bscmainnet" : "bsctestnet";
+        accessControl = await hardhat_1.ethers.getContractAt("AccessControlManager", acmAddresses[networkName]);
+    }
+    else {
+        accessControl = await hardhat_1.ethers.getContract("AccessControlManager");
+    }
+    const proxyAdmin = await hardhat_1.ethers.getContract("DefaultProxyAdmin");
+    const owner = await proxyAdmin.owner();
+    await deploy("RiskFund", {
+        from: deployer,
+        contract: "RiskFund",
+        proxy: {
+            owner: owner,
+            proxyContract: "OpenZeppelinTransparentProxy",
+            execute: {
+                methodName: "initialize",
+                args: [swapRouter.address, MIN_AMOUNT_TO_CONVERT, BUSD.address, accessControl.address, maxLoopsLimit],
+            },
+            upgradeIndex: 0,
+        },
+        autoMine: true,
+        log: true,
+    });
+    const riskFund = await hardhat_1.ethers.getContract("RiskFund");
+    const shortfallDeployment = await deploy("Shortfall", {
+        from: deployer,
+        contract: "Shortfall",
+        proxy: {
+            owner: owner,
+            proxyContract: "OpenZeppelinTransparentProxy",
+            execute: {
+                methodName: "initialize",
+                args: [BUSD.address, riskFund.address, MIN_POOL_BAD_DEBT, accessControl.address],
+            },
+            upgradeIndex: 0,
+        },
+        autoMine: true,
+        log: true,
+    });
+    const shortfall = await hardhat_1.ethers.getContract("Shortfall");
+    const tx1 = await shortfall.connect(deployerSigner).updatePoolRegistry(poolRegistry.address);
+    await tx1.wait();
+    const tx2 = await riskFund.setShortfallContractAddress(shortfallDeployment.address);
+    await tx2.wait(1);
+    const protocolShareReserveDeployment = await deploy("ProtocolShareReserve", {
+        from: deployer,
+        contract: "ProtocolShareReserve",
+        proxy: {
+            owner: owner,
+            proxyContract: "OpenZeppelinTransparentProxy",
+            execute: {
+                methodName: "initialize",
+                args: [deployer, riskFund.address],
+            },
+            upgradeIndex: 0,
+        },
+        autoMine: true,
+        log: true,
+    });
+    const allMarkets = await getAllMarkets(poolRegistry);
+    for (const market of allMarkets) {
+        await configureVToken(market, shortfallDeployment.address, protocolShareReserveDeployment.address);
+    }
+};
+func.tags = ["RiskFund", "il"];
+exports.default = func;

package/dist/deploy/013-transfer-funds-ownership.d.ts

@@ -0,0 +1,3 @@
+import { DeployFunction } from "hardhat-deploy/types";
+declare const func: DeployFunction;
+export default func;

package/dist/deploy/013-transfer-funds-ownership.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hardhat_1 = require("hardhat");
+const targetOwners = {
+    hardhat: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
+    bsctestnet: "0xFA747c4a62c4D168276329F822d004026A1c05E9",
+    mainnet: "0x939bD8d64c0A9583A7Dcea9933f7b21697ab6396", // NORMAL VIP Timelock
+};
+const contracts = ["RiskFund", "Shortfall", "ProtocolShareReserve"];
+const func = async function (hre) {
+    await transfer2StepOwnerships(contracts, hre.network.name);
+    // Transfer ownership to the already added pools
+    const poolRegistry = await hardhat_1.ethers.getContract("PoolRegistry");
+    const pools = await poolRegistry.callStatic.getAllPools();
+    for (const pool of pools) {
+        const comptrollerProxy = await hardhat_1.ethers.getContractAt("Comptroller", pool.comptroller);
+        const owner = await comptrollerProxy.owner();
+        if (owner !== targetOwners[hre.network.name]) {
+            const tx = await comptrollerProxy.transferOwnership(targetOwners[hre.network.name]);
+            await tx.wait(1);
+            const pendingOwner = await comptrollerProxy.pendingOwner();
+            console.log(`Comptroller ${comptrollerProxy.address} owner ${owner} sucessfully changed to ${pendingOwner}. Please accept the ownership.`);
+        }
+        else {
+            console.error(`Comptroller ${comptrollerProxy} owner ${owner} is equal to target ownership address ${targetOwners[hre.network.name]}`);
+        }
+    }
+};
+const transfer2StepOwnerships = async (contractNames, networkName) => {
+    for (const contractName of contractNames) {
+        const contract = await hardhat_1.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"];
+exports.default = func;

package/dist/hardhat.config.d.ts

@@ -0,0 +1,14 @@
+import "module-alias/register";
+import "@nomicfoundation/hardhat-chai-matchers";
+import "@nomicfoundation/hardhat-toolbox";
+import "@nomiclabs/hardhat-ethers";
+import "@nomiclabs/hardhat-etherscan";
+import "@openzeppelin/hardhat-upgrades";
+import "@typechain/hardhat";
+import "hardhat-deploy";
+import "hardhat-gas-reporter";
+import { HardhatUserConfig } from "hardhat/config";
+import "solidity-coverage";
+import "solidity-docgen";
+declare const config: HardhatUserConfig;
+export default config;

package/dist/hardhat.config.js

@@ -0,0 +1,237 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("module-alias/register");
+require("@nomicfoundation/hardhat-chai-matchers");
+require("@nomicfoundation/hardhat-toolbox");
+require("@nomiclabs/hardhat-ethers");
+require("@nomiclabs/hardhat-etherscan");
+require("@openzeppelin/hardhat-upgrades");
+require("@typechain/hardhat");
+const dotenv = __importStar(require("dotenv"));
+require("hardhat-deploy");
+require("hardhat-gas-reporter");
+const config_1 = require("hardhat/config");
+require("solidity-coverage");
+require("solidity-docgen");
+const utils_1 = require("./helpers/utils");
+dotenv.config();
+// This is a sample Hardhat task. To learn how to create your own go to
+// https://hardhat.org/guides/create-task.html
+(0, config_1.task)("accounts", "Prints the list of accounts", async (taskArgs, hre) => {
+    const accounts = await hre.ethers.getSigners();
+    for (const account of accounts) {
+        console.log(account.address);
+    }
+});
+(0, config_1.task)("addMarket", "Add a market to an existing pool")
+    .addParam("proxyAdmin", "Admin of vToken proxy")
+    .addParam("poolid", "ID of pool to add a market", 1, config_1.types.int)
+    .addParam("asset", "asset (ERC20) address", "0x0000000000000000000000000000000000000000", config_1.types.string)
+    .addParam("decimals", "asset decimal places", 8, config_1.types.int)
+    .addParam("name", "name of the market", undefined, config_1.types.string)
+    .addParam("symbol", "symbol of market", undefined, config_1.types.string)
+    .addParam("rateModel", "0 - WhitePaper ; 1- JumpRate", 0, config_1.types.int)
+    .addParam("baseRate", "base rate per year", 0, config_1.types.int)
+    .addParam("multiplier", "multiplier per year", "40000000000000000", config_1.types.string)
+    .addParam("jumpMul", "jump multiplier per yer", 0, config_1.types.int)
+    .addParam("kink", "kink rate", 0, config_1.types.int)
+    .addParam("collFactor", "collateral factor is exonented to 18 decimals (e.g input = input*10**18)", 0.7, config_1.types.float)
+    .setAction(async (taskArgs, hre) => {
+    const VBep20Immutable = await hre.ethers.getContractFactory("VBep20Immutable");
+    const tokenImplementation = await VBep20Immutable.deploy();
+    await tokenImplementation.deployed();
+    const poolRegistry = await hre.ethers.getContract("PoolRegistry");
+    const accessControl = await hre.ethers.getContract("AccessControlManager");
+    await poolRegistry.addMarket({
+        comptroller: taskArgs.comptroller,
+        asset: taskArgs.asset,
+        decimals: taskArgs.decimals,
+        name: taskArgs.name,
+        symbol: taskArgs.symbol,
+        rateModel: taskArgs.rateModel,
+        baseRatePerYear: taskArgs.baseRate,
+        multiplierPerYear: taskArgs.multiplier,
+        jumpMultiplierPerYear: taskArgs.jumpMul,
+        kink_: taskArgs.kink,
+        collateralFactor: (0, utils_1.convertToUnit)(taskArgs.collFactor, 18),
+        accessControlManager: accessControl.address,
+        vTokenProxyAdmin: taskArgs.proxyAdmin,
+        tokenImplementation_: tokenImplementation.address,
+    });
+    console.log("Market " + taskArgs.name + " added successfully to pool " + taskArgs.comptroller);
+});
+(0, config_1.task)("deployComptroller", "Deploys a Comptroller Implementation")
+    .addParam("contractName", "Contract name, later we can load contracts by name")
+    .addParam("poolRegistry", "Address of PoolRegistry Contract")
+    .addParam("accessControl", "Address of AccessControlManager contract")
+    .setAction(async (taskArgs, hre) => {
+    const { deployer } = await hre.getNamedAccounts();
+    const Comptroller = await hre.deployments.deploy(taskArgs.contractName, {
+        contract: "Comptroller",
+        from: deployer,
+        args: [taskArgs.poolRegistry, taskArgs.accessControl],
+        log: true,
+    });
+    console.log("Comptroller implementation deployed with address: " + Comptroller.address);
+});
+(0, config_1.task)("createPool", "Creates a pool via PoolRegistry")
+    .addParam("poolName", "Name of the pool")
+    .addParam("comptroller", "Address of comptroller implementation")
+    .addParam("oracle", "Contract name, later we can load contracts by name")
+    .addParam("closeFactor", "Close factor for pool")
+    .addParam("liquidationIncentive", "Liquidation incentive for pool")
+    .setAction(async (taskArgs, hre) => {
+    const poolRegistry = await hre.ethers.getContract("PoolRegistry");
+    await poolRegistry.createRegistryPool(taskArgs.poolName, taskArgs.comptroller, taskArgs.closeFactor, taskArgs.liquidationIncentive, taskArgs.minLiquidatableCollateral, taskArgs.oracle);
+    const pools = await poolRegistry.callStatic.getAllPools();
+    await hre.ethers.getContractAt("Comptroller", pools[0].comptroller);
+    const unitroller = await hre.ethers.getContractAt("Unitroller", pools[0].comptroller);
+    await unitroller._acceptAdmin();
+    console.log("Pool " + taskArgs.poolName + " has been sucessfully created");
+});
+// You need to export an object to set up your config
+// Go to https://hardhat.org/config/ to learn more
+const config = {
+    solidity: {
+        compilers: [
+            {
+                version: "0.8.13",
+                settings: {
+                    optimizer: {
+                        enabled: true,
+                        details: {
+                            yul: !process.env.CI,
+                        },
+                    },
+                    outputSelection: {
+                        "*": {
+                            "*": ["storageLayout"],
+                        },
+                    },
+                },
+            },
+            {
+                version: "0.6.6",
+                settings: {
+                    optimizer: {
+                        enabled: true,
+                        details: {
+                            yul: !process.env.CI,
+                        },
+                    },
+                    outputSelection: {
+                        "*": {
+                            "*": ["storageLayout"],
+                        },
+                    },
+                },
+            },
+        ],
+    },
+    networks: {
+        hardhat: isFork(),
+        development: {
+            url: "http://127.0.0.1:8545/",
+            chainId: 31337,
+            live: false,
+        },
+        bsctestnet: {
+            url: "https://bsc-testnet.public.blastapi.io",
+            chainId: 97,
+            live: true,
+            gasPrice: 20000000000,
+            accounts: {
+                mnemonic: process.env.MNEMONIC || "",
+            },
+        },
+    },
+    gasReporter: {
+        enabled: process.env.REPORT_GAS !== undefined,
+        currency: "USD",
+    },
+    etherscan: {
+        customChains: [
+            {
+                network: "testnet",
+                chainId: 97,
+                urls: {
+                    apiURL: "https://api-testnet.bscscan.com/api",
+                    browserURL: "https://testnet.bscscan.com",
+                },
+            },
+        ],
+    },
+    paths: {
+        tests: "./tests",
+    },
+    // Hardhat deploy
+    namedAccounts: {
+        deployer: 0,
+        acc1: 1,
+        acc2: 2,
+        proxyAdmin: 3,
+        acc3: 4,
+    },
+    docgen: {
+        outputDir: "./docs",
+        pages: "files",
+        templates: "./docgen-templates",
+    },
+    external: {
+        contracts: [
+            {
+                artifacts: "node_modules/@venusprotocol/oracle/artifacts",
+            },
+            {
+                artifacts: "node_modules/@venusprotocol/venus-protocol/artifacts",
+            },
+        ],
+        deployments: {
+            bsctestnet: ["node_modules/@venusprotocol/oracle/deployments/bsctestnet"],
+        },
+    },
+};
+function isFork() {
+    return process.env.FORK_MAINNET === "true"
+        ? {
+            allowUnlimitedContractSize: false,
+            loggingEnabled: false,
+            forking: {
+                url: `https://white-ultra-silence.bsc.discover.quiknode.pro/${process.env.QUICK_NODE_KEY}/`,
+                blockNumber: 21068448,
+            },
+            accounts: {
+                accountsBalance: "1000000000000000000",
+            },
+            live: false,
+        }
+        : {
+            allowUnlimitedContractSize: true,
+            loggingEnabled: false,
+            live: false,
+        };
+}
+exports.default = config;

package/dist/helpers/deploymentConfig.d.ts

@@ -0,0 +1,59 @@
+import { DeploymentsExtension } from "hardhat-deploy/types";
+export type NetworkConfig = {
+    hardhat: DeploymentConfig;
+    bsctestnet: DeploymentConfig;
+    bscmainnet: DeploymentConfig;
+};
+export type DeploymentConfig = {
+    tokensConfig: TokenConfig[];
+    poolConfig: PoolConfig[];
+};
+export type TokenConfig = {
+    isMock: boolean;
+    name?: string;
+    symbol: string;
+    decimals?: number;
+    tokenAddress: string;
+};
+export type PoolConfig = {
+    name: string;
+    closeFactor: string;
+    liquidationIncentive: string;
+    minLiquidatableCollateral: string;
+    vtokens: VTokenConfig[];
+    rewards?: RewardConfig[];
+};
+export type RewardConfig = {
+    asset: string;
+    markets: string[];
+    supplySpeeds: string[];
+    borrowSpeeds: string[];
+};
+export type SpeedConfig = {
+    borrowSpeed: string;
+    supplySpeed: string;
+};
+export type VTokenConfig = {
+    name: string;
+    symbol: string;
+    asset: string;
+    rateModel: string;
+    baseRatePerYear: string;
+    multiplierPerYear: string;
+    jumpMultiplierPerYear: string;
+    kink_: string;
+    collateralFactor: string;
+    liquidationThreshold: string;
+    reserveFactor: string;
+    initialSupply: string;
+    supplyCap: string;
+    borrowCap: string;
+};
+export declare enum InterestRateModels {
+    WhitePaper = 0,
+    JumpRate = 1
+}
+export declare const globalConfig: NetworkConfig;
+export declare function getConfig(networkName: string): Promise<DeploymentConfig>;
+export declare function getTokenConfig(tokenSymbol: string, tokens: TokenConfig[]): TokenConfig;
+export declare function getTokenAddress(tokenConfig: TokenConfig, deployments: DeploymentsExtension): Promise<string>;