@venusprotocol/isolated-pools 1.0.0-dev.1 → 1.0.0-dev.11

package/dist/deploy/006-deploy-factories.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hardhat_1 = require("hardhat");
+const acmAddresses = {
+    bsctestnet: "0x45f8a08F534f34A97187626E05d4b6648Eeaa9AA",
+    bscmainnet: "0x4788629ABc6cFCA10F9f969efdEAa1cF70c23555",
+};
+const func = async function (hre) {
+    const { deployments, getNamedAccounts } = hre;
+    const { deploy } = deployments;
+    const { deployer } = await getNamedAccounts();
+    let accessControlManager;
+    if (hre.network.live) {
+        const networkName = hre.network.name === "bscmainnet" ? "bscmainnet" : "bsctestnet";
+        accessControlManager = await hardhat_1.ethers.getContractAt("AccessControlManager", acmAddresses[networkName]);
+    }
+    else {
+        accessControlManager = await hardhat_1.ethers.getContract("AccessControlManager");
+    }
+    await deploy("PoolRegistry", {
+        from: deployer,
+        contract: "PoolRegistry",
+        proxy: {
+            owner: deployer,
+            proxyContract: "OpenZeppelinTransparentProxy",
+            execute: {
+                methodName: "initialize",
+                args: [accessControlManager.address],
+            },
+            upgradeIndex: 0,
+        },
+        autoMine: true,
+        log: true,
+    });
+};
+func.tags = ["Factories", "il"];
+exports.default = func;

package/dist/deploy/007-access-control-configure.d.ts

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

package/dist/deploy/007-access-control-configure.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hardhat_1 = require("hardhat");
+const ADDRESSES = {
+    bsctestnet: "0x45f8a08F534f34A97187626E05d4b6648Eeaa9AA",
+    bscmainnet: "0x4788629ABc6cFCA10F9f969efdEAa1cF70c23555",
+};
+const func = async function (hre) {
+    const { deployments, getNamedAccounts } = hre;
+    const { deploy } = deployments;
+    const { deployer } = await getNamedAccounts();
+    const poolRegistry = await hardhat_1.ethers.getContract("PoolRegistry");
+    let accessControlManager;
+    if (hre.network.live) {
+        const networkName = hre.network.name === "bscmainnet" ? "bscmainnet" : "bsctestnet";
+        accessControlManager = await hardhat_1.ethers.getContractAt("AccessControlManager", ADDRESSES[networkName]);
+    }
+    else {
+        await deploy("AccessControlManager", {
+            from: deployer,
+            args: [],
+            log: true,
+            autoMine: true,
+        });
+        accessControlManager = await hardhat_1.ethers.getContract("AccessControlManager");
+    }
+    console.log("==================================================");
+    console.log("Access Control Initial Configuration: ");
+    console.log("==================================================");
+    console.log("     Role     |      Contract      | Function Sig");
+    console.log("--------------------------------------------------");
+    let tx = await accessControlManager.giveCallPermission(hardhat_1.ethers.constants.AddressZero, "setCollateralFactor(address,uint256,uint256)", poolRegistry.address);
+    await tx.wait();
+    console.log("DEFAULT_ADMIN | PoolRegistry       | setCollateralFactor(address,uint256,uint256)");
+    tx = await accessControlManager.giveCallPermission(hardhat_1.ethers.constants.AddressZero, "setMarketSupplyCaps(address[],uint256[])", poolRegistry.address);
+    await tx.wait();
+    console.log("DEFAULT_ADMIN | PoolRegistry       | setMarketSupplyCaps(address[],uint256[])");
+    tx = await accessControlManager.giveCallPermission(hardhat_1.ethers.constants.AddressZero, "setMarketBorrowCaps(address[],uint256[])", poolRegistry.address);
+    await tx.wait();
+    console.log("DEFAULT_ADMIN | PoolRegistry       | setMarketBorrowCaps(address[],uint256[])");
+    tx = await accessControlManager.giveCallPermission(hardhat_1.ethers.constants.AddressZero, "setLiquidationIncentive(uint256)", poolRegistry.address);
+    await tx.wait();
+    console.log("DEFAULT_ADMIN | PoolRegistry       | setLiquidationIncentive(uint256)");
+    tx = await accessControlManager.giveCallPermission(hardhat_1.ethers.constants.AddressZero, "setCloseFactor(uint256)", poolRegistry.address);
+    await tx.wait();
+    console.log("DEFAULT_ADMIN | PoolRegistry       | setCloseFactor(uint256)");
+    tx = await accessControlManager.giveCallPermission(hardhat_1.ethers.constants.AddressZero, "setMinLiquidatableCollateral(uint256)", poolRegistry.address);
+    await tx.wait();
+    console.log("DEFAULT_ADMIN | PoolRegistry       | setMinLiquidatableCollateral(uint256)");
+    tx = await accessControlManager.giveCallPermission(hardhat_1.ethers.constants.AddressZero, "supportMarket(address)", poolRegistry.address);
+    await tx.wait();
+    console.log("DEFAULT_ADMIN | PoolRegistry       | supportMarket(address)");
+    tx = await accessControlManager.giveCallPermission(hardhat_1.ethers.constants.AddressZero, "swapPoolsAssets(address[],uint256[],address[][])", deployer);
+    await tx.wait();
+    console.log("DEFAULT_ADMIN | Deployer           | swapPoolsAssets(address[],uint256[])");
+    tx = await accessControlManager.giveCallPermission(poolRegistry.address, "addPool(string,address,uint256,uint256,uint256)", deployer);
+    await tx.wait();
+    console.log("PoolRegistry  | Deployer           | addPool(string,address,uint256,uint256,uint256)");
+    tx = await accessControlManager.giveCallPermission(poolRegistry.address, "addMarket(AddMarketInput)", deployer);
+    await tx.wait();
+    console.log("PoolRegistry  | Deployer           | addMarket(AddMarketInput)");
+    tx = await accessControlManager.giveCallPermission(hardhat_1.ethers.constants.AddressZero, "setRewardTokenSpeeds(address[],uint256[],uint256[])", deployer);
+    await tx.wait();
+    console.log("DEFAULT_ADMIN | Deployer           | setRewardTokenSpeeds(address[],uint256[],uint256[])");
+    console.log("--------------------------------------------------");
+    console.log("Access Control setup ended successfully");
+};
+func.tags = ["AccessControlConfig", "il"];
+exports.default = func;

package/dist/deploy/008-deploy-pool-lens.d.ts

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

package/dist/deploy/008-deploy-pool-lens.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const func = async function (hre) {
+    const { deployments, getNamedAccounts } = hre;
+    const { deploy } = deployments;
+    const { deployer } = await getNamedAccounts();
+    await deploy("PoolLens", {
+        from: deployer,
+        args: [],
+        log: true,
+        autoMine: true,
+    });
+};
+func.tags = ["PoolLens", "il"];
+exports.default = func;

package/dist/deploy/009-deploy-pools.d.ts

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

package/dist/deploy/009-deploy-pools.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const utils_1 = require("ethers/lib/utils");
+const hardhat_1 = require("hardhat");
+const deploymentConfig_1 = require("../helpers/deploymentConfig");
+const deploymentConfig_2 = require("../helpers/deploymentConfig");
+const ADDRESS_ONE = "0x0000000000000000000000000000000000000001";
+const treasuryAddresses = {
+    hardhat: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
+    bsctestnet: "0xFEA1c651A47FE29dB9b1bf3cC1f224d8D9CFF68C",
+    bscmainnet: "0xF322942f644A996A617BD29c16bd7d231d9F35E9", // Venus Treasury
+};
+const acmAddresses = {
+    bsctestnet: "0x45f8a08F534f34A97187626E05d4b6648Eeaa9AA",
+    bscmainnet: "0x4788629ABc6cFCA10F9f969efdEAa1cF70c23555",
+};
+const mantissaToBps = (num) => {
+    return ethers_1.BigNumber.from(num).div((0, utils_1.parseUnits)("1", 14)).toString();
+};
+const func = async function (hre) {
+    const { deployments, getNamedAccounts } = hre;
+    const { deploy } = deployments;
+    const { deployer } = await getNamedAccounts();
+    let tx;
+    const priceOracle = await hardhat_1.ethers.getContract("ResilientOracle");
+    const poolRegistry = await hardhat_1.ethers.getContract("PoolRegistry");
+    let accessControlManager;
+    if (hre.network.live) {
+        const networkName = hre.network.name === "bscmainnet" ? "bscmainnet" : "bsctestnet";
+        accessControlManager = await hardhat_1.ethers.getContractAt("AccessControlManager", acmAddresses[networkName]);
+    }
+    else {
+        accessControlManager = await hardhat_1.ethers.getContract("AccessControlManager");
+    }
+    const maxLoopsLimit = 150;
+    // Comptroller Beacon
+    const comptrollerImpl = await deploy("ComptrollerImpl", {
+        contract: "Comptroller",
+        from: deployer,
+        args: [poolRegistry.address],
+        log: true,
+        autoMine: true,
+    });
+    const comptrollerBeacon = await deploy("ComptrollerBeacon", {
+        contract: "UpgradeableBeacon",
+        from: deployer,
+        args: [comptrollerImpl.address],
+        log: true,
+        autoMine: true,
+    });
+    // VToken Beacon
+    const vTokenImpl = await deploy("VTokenImpl", {
+        contract: "VToken",
+        from: deployer,
+        args: [],
+        log: true,
+        autoMine: true,
+    });
+    const vTokenBeacon = await deploy("VTokenBeacon", {
+        contract: "UpgradeableBeacon",
+        from: deployer,
+        args: [vTokenImpl.address],
+        log: true,
+        autoMine: true,
+    });
+    const { tokensConfig, poolConfig } = await (0, deploymentConfig_1.getConfig)(hre.network.name);
+    const pools = await poolRegistry.callStatic.getAllPools();
+    for (let i = 0; i < poolConfig.length; i++) {
+        const pool = poolConfig[i];
+        let comptrollerProxy;
+        if (i >= pools.length) {
+            // Deploying a proxy for Comptroller
+            console.log("Deploying a proxy for Comptroller");
+            const Comptroller = await hardhat_1.ethers.getContractFactory("Comptroller");
+            comptrollerProxy = await deploy(`Comptroller_${pool.name}`, {
+                from: deployer,
+                contract: "BeaconProxy",
+                args: [
+                    comptrollerBeacon.address,
+                    Comptroller.interface.encodeFunctionData("initialize", [maxLoopsLimit, accessControlManager.address]),
+                ],
+                log: true,
+                autoMine: true,
+            });
+            // Deploying a proxy for Comptroller
+            console.log("Setting price oracle for Comptroller");
+            const comptroller = await hardhat_1.ethers.getContractAt("Comptroller", comptrollerProxy.address);
+            tx = await comptroller.setPriceOracle(priceOracle.address);
+            await tx.wait();
+            // Create pool
+            console.log("Registering new pool with name " + pool.name);
+            tx = await poolRegistry.addPool(pool.name, comptroller.address, pool.closeFactor, pool.liquidationIncentive, pool.minLiquidatableCollateral);
+            await tx.wait();
+            console.log("New Pool Registered");
+        }
+        else {
+            comptrollerProxy = await hardhat_1.ethers.getContractAt("Comptroller", pools[i].comptroller);
+        }
+        // Add Markets
+        for (const vtoken of pool.vtokens) {
+            const { name, asset, symbol, rateModel, baseRatePerYear, multiplierPerYear, jumpMultiplierPerYear, kink_, collateralFactor, liquidationThreshold, reserveFactor, initialSupply, supplyCap, borrowCap, } = vtoken;
+            const token = (0, deploymentConfig_1.getTokenConfig)(asset, tokensConfig);
+            let tokenContract;
+            if (token.isMock) {
+                tokenContract = await hardhat_1.ethers.getContract(`Mock${token.symbol}`);
+                console.log("Minting " + initialSupply + " mock tokens to owner");
+                tx = await tokenContract.faucet(initialSupply);
+                await tx.wait(1);
+            }
+            else {
+                tokenContract = await hardhat_1.ethers.getContractAt("@openzeppelin/contracts/token/ERC20/ERC20.sol:ERC20", token.tokenAddress);
+                // Make sure that deployer has at least `initialSupply` balance of the token
+            }
+            let rateModelAddress;
+            if (rateModel === deploymentConfig_2.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 = await deploy(rateModelName, {
+                    from: deployer,
+                    contract: "JumpRateModelV2",
+                    args: [baseRatePerYear, multiplierPerYear, jumpMultiplierPerYear, kink_, accessControlManager.address],
+                    log: true,
+                    autoMine: 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 = await deploy(rateModelName, {
+                    from: deployer,
+                    contract: "WhitePaperInterestRateModel",
+                    args: [baseRatePerYear, multiplierPerYear],
+                    log: true,
+                    autoMine: true,
+                });
+                rateModelAddress = result.address;
+            }
+            console.log(`Deploying VToken proxy for ${symbol}`);
+            const VToken = await hardhat_1.ethers.getContractFactory("VToken");
+            const underlyingDecimals = Number(await tokenContract.decimals());
+            const vTokenDecimals = 8;
+            const args = [
+                tokenContract.address,
+                comptrollerProxy.address,
+                rateModelAddress,
+                (0, utils_1.parseUnits)("1", underlyingDecimals + 18 - vTokenDecimals),
+                name,
+                symbol,
+                vTokenDecimals,
+                deployer,
+                accessControlManager.address,
+                [treasuryAddresses[hre.network.name], ADDRESS_ONE],
+                reserveFactor,
+            ];
+            const vToken = await deploy(`VToken_${name}`, {
+                from: deployer,
+                contract: "BeaconProxy",
+                args: [vTokenBeacon.address, VToken.interface.encodeFunctionData("initialize", args)],
+                log: true,
+                autoMine: true,
+            });
+            console.log("Approving PoolRegistry for: " + initialSupply);
+            tx = await tokenContract.approve(poolRegistry.address, initialSupply);
+            await tx.wait(1);
+            console.log("Adding market " + name + " to pool " + pool.name);
+            tx = await poolRegistry.addMarket({
+                vToken: vToken.address,
+                collateralFactor: collateralFactor,
+                liquidationThreshold: liquidationThreshold,
+                initialSupply: initialSupply,
+                vTokenReceiver: hre.network.name === "hardhat" ? deployer : treasuryAddresses[hre.network.name],
+                supplyCap: supplyCap,
+                borrowCap: borrowCap,
+            });
+            await tx.wait();
+            console.log(`Market ${name} added to pool ${pool.name}`);
+            console.log(`-----------------------------------------`);
+        }
+    }
+};
+func.tags = ["Pools", "il"];
+exports.default = func;

package/dist/deploy/010-rewards.d.ts

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

package/dist/deploy/010-rewards.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hardhat_1 = require("hardhat");
+const deploymentConfig_1 = require("../helpers/deploymentConfig");
+const acmAddresses = {
+    bsctestnet: "0x45f8a08F534f34A97187626E05d4b6648Eeaa9AA",
+    bscmainnet: "0x4788629ABc6cFCA10F9f969efdEAa1cF70c23555",
+};
+const func = async function (hre) {
+    const { deployments, getNamedAccounts } = hre;
+    const { deploy } = deployments;
+    const { deployer } = await getNamedAccounts();
+    const maxLoopsLimit = 150;
+    const poolRegistry = await hardhat_1.ethers.getContract("PoolRegistry");
+    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 { tokensConfig, poolConfig } = await (0, deploymentConfig_1.getConfig)(hre.network.name);
+    const pools = await poolRegistry.callStatic.getAllPools();
+    for (let i = 0; i < poolConfig.length; i++) {
+        const rewards = poolConfig[i].rewards;
+        if (!rewards)
+            continue;
+        for (const reward of rewards) {
+            const comptrollerAddress = pools[i].comptroller;
+            // Get reward token address
+            const tokenConfig = (0, deploymentConfig_1.getTokenConfig)(reward.asset, tokensConfig);
+            const rewardTokenAddress = await (0, deploymentConfig_1.getTokenAddress)(tokenConfig, deployments);
+            // Custom contract name so we can obtain the proxy after that easily
+            const contractName = "Rewards" + reward.asset + poolConfig[i].name;
+            await deploy(contractName, {
+                from: deployer,
+                contract: "RewardsDistributor",
+                proxy: {
+                    owner: deployer,
+                    proxyContract: "OpenZeppelinTransparentProxy",
+                    execute: {
+                        methodName: "initialize",
+                        args: [comptrollerAddress, rewardTokenAddress, maxLoopsLimit, accessControl.address],
+                    },
+                    upgradeIndex: 0,
+                },
+                autoMine: true,
+                log: true,
+            });
+            const rewardsDistributor = await hardhat_1.ethers.getContract(contractName);
+            const vTokens = [];
+            for (const marketUnderlying of reward.markets) {
+                const assetConfig = (0, deploymentConfig_1.getTokenConfig)(marketUnderlying, tokensConfig);
+                const tokenAddress = await (0, deploymentConfig_1.getTokenAddress)(assetConfig, deployments);
+                const marketAddress = await poolRegistry.getVTokenForAsset(comptrollerAddress, tokenAddress);
+                vTokens.push(marketAddress);
+            }
+            let tx = await rewardsDistributor.setRewardTokenSpeeds(vTokens, reward.supplySpeeds, reward.borrowSpeeds);
+            await tx.wait(1);
+            const comptrollerProxy = await hardhat_1.ethers.getContractAt("Comptroller", pools[i].comptroller);
+            try {
+                console.log("Adding reward distributor to comptroller " + comptrollerAddress);
+                tx = await comptrollerProxy.addRewardsDistributor(rewardsDistributor.address);
+                await tx.wait(1);
+                console.log("Added rewards distributor sucessfully");
+            }
+            catch (e) {
+                console.log("Rewards distributor already added.");
+                continue;
+            }
+        }
+    }
+};
+func.tags = ["Rewards", "il"];
+exports.default = func;

package/dist/deploy/011-transfer-pools-ownership.d.ts

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

package/dist/deploy/011-transfer-pools-ownership.js

@@ -0,0 +1,75 @@
+"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 = {
+    singleStepOwnership: ["ComptrollerBeacon", "VTokenBeacon", "DefaultProxyAdmin"],
+    twoStepOwnership: [
+        "PoolRegistry",
+        "RewardsBNXPool 1",
+        "RewardsXVSPool 1",
+        "RewardsANKRPool 2",
+        "RewardsXVSPool 2",
+        "RewardsMBOXPool 2",
+        "RewardsNFTPool 2",
+        "RewardsRACAPool 2",
+    ],
+};
+const func = async function (hre) {
+    await transferSingleStepOwnerships(contracts.singleStepOwnership, hre.network.name);
+    await transfer2StepOwnerships(contracts.twoStepOwnership, 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]}`);
+        }
+    }
+};
+const transferSingleStepOwnerships = 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 newOwner = await contract.owner();
+            console.log(`${contractName} owner ${owner} sucessfully changed to ${newOwner}.`);
+        }
+        else {
+            console.error(`${contractName} owner ${owner} is equal to target ownership address ${targetOwners[networkName]}`);
+        }
+    }
+};
+func.tags = ["TransferPoolsOwnership"];
+exports.default = func;

package/dist/deploy/012-riskfund-protocolshare.d.ts

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

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;