@venusprotocol/isolated-pools 3.7.0 → 3.8.0-dev.1

package/dist/hardhat.config.js

@@ -40,54 +40,90 @@ require("solidity-docgen");
 const utils_1 = require("./helpers/utils");
 dotenv.config();
 const DEPLOYER_PRIVATE_KEY = process.env.DEPLOYER_PRIVATE_KEY;
+const getRpcUrl = (networkName) => {
+    let uri;
+    if (networkName) {
+        uri = process.env[`ARCHIVE_NODE_${networkName}`];
+    }
+    if (!uri) {
+        throw new Error(`invalid uri or network not supported by node provider : ${uri}`);
+    }
+    return uri;
+};
+(0, config_1.extendEnvironment)(hre => {
+    hre.getNetworkName = () => process.env.HARDHAT_FORK_NETWORK || hre.network.name;
+});
 (0, config_1.extendConfig)((config) => {
     if (process.env.EXPORT !== "true") {
         config.external = {
             ...config.external,
             deployments: {
+                hardhat: [],
                 bsctestnet: [
                     "node_modules/@venusprotocol/oracle/deployments/bsctestnet",
                     "node_modules/@venusprotocol/venus-protocol/deployments/bsctestnet",
                     "node_modules/@venusprotocol/protocol-reserve/deployments/bsctestnet",
+                    "node_modules/@venusprotocol/governance-contracts/deployments/bsctestnet",
                 ],
                 sepolia: [
                     "node_modules/@venusprotocol/oracle/deployments/sepolia",
                     "node_modules/@venusprotocol/venus-protocol/deployments/sepolia",
                     "node_modules/@venusprotocol/protocol-reserve/deployments/sepolia",
+                    "node_modules/@venusprotocol/governance-contracts/deployments/sepolia",
                 ],
                 ethereum: [
                     "node_modules/@venusprotocol/oracle/deployments/ethereum",
                     "node_modules/@venusprotocol/venus-protocol/deployments/ethereum",
                     "node_modules/@venusprotocol/protocol-reserve/deployments/ethereum",
+                    "node_modules/@venusprotocol/governance-contracts/deployments/ethereum",
                 ],
                 bscmainnet: [
                     "node_modules/@venusprotocol/oracle/deployments/bscmainnet",
                     "node_modules/@venusprotocol/venus-protocol/deployments/bscmainnet",
                     "node_modules/@venusprotocol/protocol-reserve/deployments/bscmainnet",
+                    "node_modules/@venusprotocol/governance-contracts/deployments/bscmainnet",
                 ],
                 opbnbmainnet: [
                     "node_modules/@venusprotocol/oracle/deployments/opbnbmainnet",
                     "node_modules/@venusprotocol/protocol-reserve/deployments/opbnbmainnet",
+                    "node_modules/@venusprotocol/governance-contracts/deployments/opbnbmainnet",
                 ],
                 opbnbtestnet: [
                     "node_modules/@venusprotocol/oracle/deployments/opbnbtestnet",
                     "node_modules/@venusprotocol/protocol-reserve/deployments/opbnbtestnet",
+                    "node_modules/@venusprotocol/governance-contracts/deployments/opbnbtestnet",
                 ],
                 arbitrumsepolia: [
                     "node_modules/@venusprotocol/oracle/deployments/arbitrumsepolia",
                     "node_modules/@venusprotocol/protocol-reserve/deployments/arbitrumsepolia",
+                    "node_modules/@venusprotocol/governance-contracts/deployments/arbitrumsepolia",
+                ],
+                arbitrumone: [
+                    "node_modules/@venusprotocol/oracle/deployments/arbitrumone",
+                    "node_modules/@venusprotocol/protocol-reserve/deployments/arbitrumone",
+                    "node_modules/@venusprotocol/governance-contracts/deployments/arbitrumsepolia",
                 ],
-                arbitrumone: ["node_modules/@venusprotocol/protocol-reserve/deployments/arbitrumone"],
                 basesepolia: [
                     "node_modules/@venusprotocol/oracle/deployments/basesepolia",
                     "node_modules/@venusprotocol/protocol-reserve/deployments/basesepolia",
+                    "node_modules/@venusprotocol/governance-contracts/deployments/basesepolia",
                 ],
                 basemainnet: [
                     "node_modules/@venusprotocol/oracle/deployments/basemainnet",
                     "node_modules/@venusprotocol/protocol-reserve/deployments/basemainnet",
+                    "node_modules/@venusprotocol/governance-contracts/deployments/basemainnet",
                 ],
             },
         };
+        if (process.env.HARDHAT_FORK_NETWORK) {
+            config.external.deployments.hardhat = [
+                `./deployments/${process.env.HARDHAT_FORK_NETWORK}`,
+                `node_modules/@venusprotocol/oracle/deployments/${process.env.HARDHAT_FORK_NETWORK}`,
+                `node_modules/@venusprotocol/venus-protocol/deployments/${process.env.HARDHAT_FORK_NETWORK}`,
+                `node_modules/@venusprotocol/protocol-reserve/deployments/${process.env.HARDHAT_FORK_NETWORK}`,
+                `node_modules/@venusprotocol/governance-contracts/deployments/${process.env.HARDHAT_FORK_NETWORK}`,
+            ];
+        }
     }
 });
 // This is a sample Hardhat task. To learn how to create your own go to
@@ -223,7 +259,13 @@ const config = {
         hardhat: {
             allowUnlimitedContractSize: true,
             loggingEnabled: false,
-            live: false,
+            live: !!process.env.HARDHAT_FORK_NETWORK,
+            forking: process.env.HARDHAT_FORK_NETWORK
+                ? {
+                    url: getRpcUrl(process.env.HARDHAT_FORK_NETWORK),
+                    blockNumber: process.env.HARDHAT_FORK_NUMBER ? parseInt(process.env.HARDHAT_FORK_NUMBER) : undefined,
+                }
+                : undefined,
         },
         development: {
             url: "http://127.0.0.1:8545/",

package/dist/helpers/deploymentConfig.js

@@ -3910,7 +3910,7 @@ exports.globalConfig = {
                     //          3600 XVS for Borrowers
                     {
                         asset: "XVS",
-                        markets: ["vCRV", "crvUSD"],
+                        markets: ["CRV", "crvUSD"],
                         supplySpeeds: ["925925925925925", "3703703703703703"],
                         borrowSpeeds: ["1388888888888888", "5555555555555555"],
                     },
@@ -3922,7 +3922,7 @@ exports.globalConfig = {
                     },
                     {
                         asset: "XVS",
-                        markets: ["vCRV", "crvUSD"],
+                        markets: ["CRV", "crvUSD"],
                         supplySpeeds: ["694444444444444", "694444444444444"],
                         borrowSpeeds: ["1041666666666666", "1041666666666666"],
                     },

package/dist/helpers/deploymentUtils.d.ts

@@ -1,10 +1,9 @@
-import { HardhatRuntimeEnvironment } from "hardhat/types";
 import { ERC20, MockToken } from "../typechain";
 import { DeploymentInfo, PoolConfig, TokenConfig } from "./deploymentConfig";
-export declare const toAddress: (addressOrAlias: string, hre: HardhatRuntimeEnvironment) => Promise<string>;
+export declare const toAddress: (addressOrAlias: string) => Promise<string>;
 export declare const getUnderlyingMock: (assetSymbol: string) => Promise<MockToken>;
 export declare const getUnderlyingToken: (assetSymbol: string, tokensConfig: TokenConfig[]) => Promise<ERC20>;
-export declare const getUnregisteredPools: (poolConfig: PoolConfig[], hre: HardhatRuntimeEnvironment) => Promise<PoolConfig[]>;
-export declare const getUnregisteredVTokens: (poolConfig: PoolConfig[], hre: HardhatRuntimeEnvironment) => Promise<PoolConfig[]>;
-export declare const getUnregisteredRewardsDistributors: (poolConfig: PoolConfig[], hre: HardhatRuntimeEnvironment) => Promise<PoolConfig[]>;
+export declare const getUnregisteredPools: (poolConfig: PoolConfig[]) => Promise<PoolConfig[]>;
+export declare const getUnregisteredVTokens: (poolConfig: PoolConfig[]) => Promise<PoolConfig[]>;
+export declare const getUnregisteredRewardsDistributors: (poolConfig: PoolConfig[]) => Promise<PoolConfig[]>;
 export declare const getBlockOrTimestampBasedDeploymentInfo: (network: string) => DeploymentInfo;

package/dist/helpers/deploymentUtils.js

@@ -3,17 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getBlockOrTimestampBasedDeploymentInfo = exports.getUnregisteredRewardsDistributors = exports.getUnregisteredVTokens = exports.getUnregisteredPools = exports.getUnderlyingToken = exports.getUnderlyingMock = exports.toAddress = void 0;
 const hardhat_1 = require("hardhat");
 const deploymentConfig_1 = require("./deploymentConfig");
-const toAddress = async (addressOrAlias, hre) => {
-    const { getNamedAccounts } = hre;
-    const { deployments } = hre;
+const toAddress = async (addressOrAlias) => {
     if (addressOrAlias.startsWith("0x")) {
         return addressOrAlias;
     }
     if (addressOrAlias.startsWith("account:")) {
-        const namedAccounts = await getNamedAccounts();
+        const namedAccounts = await (0, hardhat_1.getNamedAccounts)();
         return namedAccounts[addressOrAlias.slice("account:".length)];
     }
-    const deployment = await deployments.get(addressOrAlias);
+    const deployment = await hardhat_1.deployments.get(addressOrAlias);
     return deployment.address;
 };
 exports.toAddress = toAddress;
@@ -30,12 +28,11 @@ const getUnderlyingToken = async (assetSymbol, tokensConfig) => {
     return hardhat_1.ethers.getContractAt("@openzeppelin/contracts/token/ERC20/ERC20.sol:ERC20", underlyingAddress);
 };
 exports.getUnderlyingToken = getUnderlyingToken;
-const getUnregisteredPools = async (poolConfig, hre) => {
-    const { deployments } = hre;
+const getUnregisteredPools = async (poolConfig) => {
     const registry = await hardhat_1.ethers.getContract("PoolRegistry");
     const registeredPools = (await registry.getAllPools()).map((p) => p.comptroller);
     const isRegistered = await Promise.all(poolConfig.map(async (pool) => {
-        const comptroller = await deployments.getOrNull(`Comptroller_${pool.name}`);
+        const comptroller = await hardhat_1.deployments.getOrNull(`Comptroller_${pool.name}`);
         if (!comptroller) {
             // If the Comptroller deployment doesn't exist, it's not registered
             return false;
@@ -45,8 +42,7 @@ const getUnregisteredPools = async (poolConfig, hre) => {
     return poolConfig.filter((_, idx) => !isRegistered[idx]);
 };
 exports.getUnregisteredPools = getUnregisteredPools;
-const getUnregisteredVTokens = async (poolConfig, hre) => {
-    const { deployments } = hre;
+const getUnregisteredVTokens = async (poolConfig) => {
     const registry = await hardhat_1.ethers.getContract("PoolRegistry");
     const registeredPools = await registry.getAllPools();
     const comptrollers = await Promise.all(registeredPools.map(async (p) => {
@@ -57,7 +53,7 @@ const getUnregisteredVTokens = async (poolConfig, hre) => {
     }))).flat();
     return Promise.all(poolConfig.map(async (pool) => {
         const isRegistered = await Promise.all(pool.vtokens.map(async (vTokenConfig) => {
-            const vToken = await deployments.getOrNull(`VToken_${vTokenConfig.name}`);
+            const vToken = await hardhat_1.deployments.getOrNull(`VToken_${vTokenConfig.name}`);
             if (!vToken) {
                 // If the VToken deployment doesn't exist, it's not registered
                 return false;
@@ -68,8 +64,7 @@ const getUnregisteredVTokens = async (poolConfig, hre) => {
     }));
 };
 exports.getUnregisteredVTokens = getUnregisteredVTokens;
-const getUnregisteredRewardsDistributors = async (poolConfig, hre) => {
-    const { deployments } = hre;
+const getUnregisteredRewardsDistributors = async (poolConfig) => {
     const registry = await hardhat_1.ethers.getContract("PoolRegistry");
     const registeredPools = await registry.getAllPools();
     const comptrollers = await Promise.all(registeredPools.map(async (p) => {
@@ -81,7 +76,7 @@ const getUnregisteredRewardsDistributors = async (poolConfig, hre) => {
     return Promise.all(poolConfig.map(async (pool) => {
         const rewards = pool.rewards || [];
         const isRegistered = await Promise.all(rewards.map(async (reward) => {
-            const rewardsDistributor = await deployments.getOrNull(`RewardsDistributor_${reward.asset}_${pool.name}`);
+            const rewardsDistributor = await hardhat_1.deployments.getOrNull(`RewardsDistributor_${reward.asset}_${pool.name}`);
             if (!rewardsDistributor) {
                 // If the RewardsDistributor deployment doesn't exist, it's not registered
                 return false;

package/dist/type-extensions.d.ts

@@ -0,0 +1,6 @@
+import "hardhat/types/runtime";
+declare module "hardhat/types/runtime" {
+    interface HardhatRuntimeEnvironment {
+        getNetworkName: () => string;
+    }
+}

package/dist/type-extensions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("hardhat/types/runtime");

package/dist/typechain/factories/IVToken__factory.d.ts

@@ -3,7 +3,11 @@ import { Provider } from "@ethersproject/providers";
 import type { IVToken, IVTokenInterface } from "../IVToken";
 export declare class IVToken__factory {
     static readonly abi: {
-        inputs: never[];
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
         name: string;
         outputs: {
             internalType: string;

package/dist/typechain/factories/IVToken__factory.js

@@ -6,6 +6,206 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IVToken__factory = void 0;
 const ethers_1 = require("ethers");
 const _abi = [
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "account",
+                type: "address",
+            },
+        ],
+        name: "borrowBalanceCurrent",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "borrower",
+                type: "address",
+            },
+            {
+                internalType: "uint256",
+                name: "borrowAmount",
+                type: "uint256",
+            },
+        ],
+        name: "borrowBehalf",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "exchangeRateCurrent",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "receiver",
+                type: "address",
+            },
+            {
+                internalType: "uint256",
+                name: "mintAmount",
+                type: "uint256",
+            },
+        ],
+        name: "mintBehalf",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "uint256",
+                name: "redeemTokens",
+                type: "uint256",
+            },
+        ],
+        name: "redeem",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "redeemer",
+                type: "address",
+            },
+            {
+                internalType: "uint256",
+                name: "redeemTokens",
+                type: "uint256",
+            },
+        ],
+        name: "redeemBehalf",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "redeemer",
+                type: "address",
+            },
+            {
+                internalType: "uint256",
+                name: "redeemAmount",
+                type: "uint256",
+            },
+        ],
+        name: "redeemUnderlyingBehalf",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "borrower",
+                type: "address",
+            },
+            {
+                internalType: "uint256",
+                name: "repayAmount",
+                type: "uint256",
+            },
+        ],
+        name: "repayBorrowBehalf",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "from",
+                type: "address",
+            },
+            {
+                internalType: "address",
+                name: "to",
+                type: "address",
+            },
+            {
+                internalType: "uint256",
+                name: "amount",
+                type: "uint256",
+            },
+        ],
+        name: "transferFrom",
+        outputs: [
+            {
+                internalType: "bool",
+                name: "",
+                type: "bool",
+            },
+        ],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
     {
         inputs: [],
         name: "underlying",
@@ -16,7 +216,7 @@ const _abi = [
                 type: "address",
             },
         ],
-        stateMutability: "view",
+        stateMutability: "nonpayable",
         type: "function",
     },
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@venusprotocol/isolated-pools",
-  "version": "3.7.0",
+  "version": "3.8.0-dev.1",
   "description": "",
   "files": [
     "artifacts",
@@ -48,7 +48,7 @@
     "@openzeppelin/contracts-upgradeable": "^4.8.3",
     "@openzeppelin/hardhat-upgrades": "^1.21.0",
     "@solidity-parser/parser": "^0.13.2",
-    "@venusprotocol/solidity-utilities": "^2.0.0",
+    "@venusprotocol/solidity-utilities": "2.0.3",
     "ethers": "^5.7.0",
     "hardhat-deploy": "^0.11.14",
     "module-alias": "^2.2.2"
@@ -79,7 +79,7 @@
     "@typescript-eslint/parser": "^5.27.1",
     "@venusprotocol/governance-contracts": "2.6.0",
     "@venusprotocol/oracle": "2.7.0",
-    "@venusprotocol/protocol-reserve": "2.4.0",
+    "@venusprotocol/protocol-reserve": "3.0.1",
     "@venusprotocol/venus-protocol": "9.4.0",
     "bignumber.js": "9.0.0",
     "chai": "^4.3.6",
@@ -113,7 +113,8 @@
     "ganache-core": "github:compound-finance/ganache-core.git#jflatow/unbreak-fork",
     "solidity-parser-antlr": "https://github.com/solidity-parser/parser#0.8.2",
     "@defi-wonderland/smock": "2.3.5",
-    "hardhat": "2.19.4"
+    "hardhat": "2.19.4",
+    "@venusprotocol/solidity-utilities": "2.0.3"
   },
   "publishConfig": {
     "access": "public",