@venusprotocol/isolated-pools 4.2.0-dev.5 → 4.2.0-dev.6

package/dist/hardhat.config.js

@@ -373,6 +373,7 @@ const config = {
             url: process.env.ARCHIVE_NODE_unichainsepolia || "https://sepolia.unichain.org",
             chainId: 1301,
             live: true,
+            tags: ["testnet"],
             accounts: DEPLOYER_PRIVATE_KEY ? [`0x${DEPLOYER_PRIVATE_KEY}`] : [],
         },
         unichainmainnet: {

package/dist/helpers/deploymentConfig.js

@@ -7015,6 +7015,13 @@ exports.globalConfig = {
                 decimals: 18,
                 tokenAddress: "0xC0e51E865bc9Fed0a32Cc0B2A65449567Bc5c741",
             },
+            {
+                isMock: true,
+                name: "Uniswap",
+                symbol: "UNI",
+                decimals: 18,
+                tokenAddress: hardhat_1.ethers.constants.AddressZero,
+            },
         ],
         poolConfig: [
             {
@@ -7096,6 +7103,24 @@ exports.globalConfig = {
                         reduceReservesBlockDelta: REDUCE_RESERVES_BLOCK_DELTA_UNICHAIN_SEPOLIA,
                         vTokenReceiver: exports.preconfiguredAddresses.unichainsepolia.VTreasury,
                     },
+                    {
+                        name: "Venus UNI (Core)",
+                        asset: "UNI",
+                        symbol: "vUNI_Core",
+                        rateModel: InterestRateModels.JumpRate.toString(),
+                        baseRatePerYear: "0",
+                        multiplierPerYear: (0, utils_1.convertToUnit)("0.15", 18),
+                        jumpMultiplierPerYear: (0, utils_1.convertToUnit)("3", 18),
+                        kink_: (0, utils_1.convertToUnit)("0.3", 18),
+                        collateralFactor: (0, utils_1.convertToUnit)("0", 18),
+                        liquidationThreshold: (0, utils_1.convertToUnit)("0", 18),
+                        reserveFactor: (0, utils_1.convertToUnit)("0.25", 18),
+                        initialSupply: (0, utils_1.convertToUnit)("529.463427983309919376", 18),
+                        supplyCap: (0, utils_1.convertToUnit)("20000", 18),
+                        borrowCap: (0, utils_1.convertToUnit)("0", 18),
+                        reduceReservesBlockDelta: REDUCE_RESERVES_BLOCK_DELTA_UNICHAIN_SEPOLIA,
+                        vTokenReceiver: exports.preconfiguredAddresses.unichainsepolia.VTreasury,
+                    },
                 ],
                 rewards: [
                     // XVS Rewards Over 3600 days (311040000 seconds)
@@ -7147,6 +7172,13 @@ exports.globalConfig = {
                 decimals: 18,
                 tokenAddress: "0x81908BBaad3f6fC74093540Ab2E9B749BB62aA0d",
             },
+            {
+                isMock: false,
+                name: "Uniswap",
+                symbol: "UNI",
+                decimals: 18,
+                tokenAddress: "0x8f187aa05619a017077f5308904739877ce9ea21",
+            },
         ],
         poolConfig: [
             {
@@ -7192,6 +7224,24 @@ exports.globalConfig = {
                         reduceReservesBlockDelta: REDUCE_RESERVES_BLOCK_DELTA_UNICHAIN_MAINNET,
                         vTokenReceiver: exports.preconfiguredAddresses.unichainmainnet.VTreasury,
                     },
+                    {
+                        name: "Venus UNI (Core)",
+                        asset: "UNI",
+                        symbol: "vUNI_Core",
+                        rateModel: InterestRateModels.JumpRate.toString(),
+                        baseRatePerYear: "0",
+                        multiplierPerYear: (0, utils_1.convertToUnit)("0.15", 18),
+                        jumpMultiplierPerYear: (0, utils_1.convertToUnit)("3", 18),
+                        kink_: (0, utils_1.convertToUnit)("0.3", 18),
+                        collateralFactor: (0, utils_1.convertToUnit)("0", 18),
+                        liquidationThreshold: (0, utils_1.convertToUnit)("0", 18),
+                        reserveFactor: (0, utils_1.convertToUnit)("0.25", 18),
+                        initialSupply: (0, utils_1.convertToUnit)("529.463427983309919376", 18),
+                        supplyCap: (0, utils_1.convertToUnit)("20000", 18),
+                        borrowCap: (0, utils_1.convertToUnit)("0", 18),
+                        reduceReservesBlockDelta: REDUCE_RESERVES_BLOCK_DELTA_UNICHAIN_MAINNET,
+                        vTokenReceiver: exports.preconfiguredAddresses.unichainmainnet.VTreasury,
+                    },
                 ],
                 rewards: [
                     // XVS Rewards Over 30 days (2592000 seconds)

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": "4.2.0-dev.5",
+  "version": "4.2.0-dev.6",
   "description": "",
   "files": [
     "artifacts",

package/typechain/IVToken.d.ts

@@ -11,6 +11,7 @@ import {
   PopulatedTransaction,
   BaseContract,
   ContractTransaction,
+  Overrides,
   CallOverrides,
 } from "ethers";
 import { BytesLike } from "@ethersproject/bytes";
@@ -20,14 +21,89 @@ import type { TypedEventFilter, TypedEvent, TypedListener } from "./common";
 
 interface IVTokenInterface extends ethers.utils.Interface {
   functions: {
+    "borrowBalanceCurrent(address)": FunctionFragment;
+    "borrowBehalf(address,uint256)": FunctionFragment;
+    "exchangeRateCurrent()": FunctionFragment;
+    "mintBehalf(address,uint256)": FunctionFragment;
+    "redeem(uint256)": FunctionFragment;
+    "redeemBehalf(address,uint256)": FunctionFragment;
+    "redeemUnderlyingBehalf(address,uint256)": FunctionFragment;
+    "repayBorrowBehalf(address,uint256)": FunctionFragment;
+    "transferFrom(address,address,uint256)": FunctionFragment;
     "underlying()": FunctionFragment;
   };
 
+  encodeFunctionData(
+    functionFragment: "borrowBalanceCurrent",
+    values: [string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "borrowBehalf",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "exchangeRateCurrent",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "mintBehalf",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "redeem",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "redeemBehalf",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "redeemUnderlyingBehalf",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "repayBorrowBehalf",
+    values: [string, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "transferFrom",
+    values: [string, string, BigNumberish]
+  ): string;
   encodeFunctionData(
     functionFragment: "underlying",
     values?: undefined
   ): string;
 
+  decodeFunctionResult(
+    functionFragment: "borrowBalanceCurrent",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "borrowBehalf",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "exchangeRateCurrent",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "mintBehalf", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "redeem", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "redeemBehalf",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "redeemUnderlyingBehalf",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "repayBorrowBehalf",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "transferFrom",
+    data: BytesLike
+  ): Result;
   decodeFunctionResult(functionFragment: "underlying", data: BytesLike): Result;
 
   events: {};
@@ -77,22 +153,283 @@ export class IVToken extends BaseContract {
   interface: IVTokenInterface;
 
   functions: {
-    underlying(overrides?: CallOverrides): Promise<[string]>;
+    borrowBalanceCurrent(
+      account: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    borrowBehalf(
+      borrower: string,
+      borrowAmount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    exchangeRateCurrent(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    mintBehalf(
+      receiver: string,
+      mintAmount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    redeem(
+      redeemTokens: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    redeemBehalf(
+      redeemer: string,
+      redeemTokens: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    redeemUnderlyingBehalf(
+      redeemer: string,
+      redeemAmount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    repayBorrowBehalf(
+      borrower: string,
+      repayAmount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    transferFrom(
+      from: string,
+      to: string,
+      amount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    underlying(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
   };
 
-  underlying(overrides?: CallOverrides): Promise<string>;
+  borrowBalanceCurrent(
+    account: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  borrowBehalf(
+    borrower: string,
+    borrowAmount: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  exchangeRateCurrent(
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  mintBehalf(
+    receiver: string,
+    mintAmount: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  redeem(
+    redeemTokens: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  redeemBehalf(
+    redeemer: string,
+    redeemTokens: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  redeemUnderlyingBehalf(
+    redeemer: string,
+    redeemAmount: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  repayBorrowBehalf(
+    borrower: string,
+    repayAmount: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  transferFrom(
+    from: string,
+    to: string,
+    amount: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  underlying(
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
 
   callStatic: {
+    borrowBalanceCurrent(
+      account: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    borrowBehalf(
+      borrower: string,
+      borrowAmount: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    exchangeRateCurrent(overrides?: CallOverrides): Promise<BigNumber>;
+
+    mintBehalf(
+      receiver: string,
+      mintAmount: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    redeem(
+      redeemTokens: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    redeemBehalf(
+      redeemer: string,
+      redeemTokens: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    redeemUnderlyingBehalf(
+      redeemer: string,
+      redeemAmount: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    repayBorrowBehalf(
+      borrower: string,
+      repayAmount: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    transferFrom(
+      from: string,
+      to: string,
+      amount: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
     underlying(overrides?: CallOverrides): Promise<string>;
   };
 
   filters: {};
 
   estimateGas: {
-    underlying(overrides?: CallOverrides): Promise<BigNumber>;
+    borrowBalanceCurrent(
+      account: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    borrowBehalf(
+      borrower: string,
+      borrowAmount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    exchangeRateCurrent(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    mintBehalf(
+      receiver: string,
+      mintAmount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    redeem(
+      redeemTokens: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    redeemBehalf(
+      redeemer: string,
+      redeemTokens: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    redeemUnderlyingBehalf(
+      redeemer: string,
+      redeemAmount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    repayBorrowBehalf(
+      borrower: string,
+      repayAmount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    transferFrom(
+      from: string,
+      to: string,
+      amount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    underlying(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
   };
 
   populateTransaction: {
-    underlying(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    borrowBalanceCurrent(
+      account: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    borrowBehalf(
+      borrower: string,
+      borrowAmount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    exchangeRateCurrent(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    mintBehalf(
+      receiver: string,
+      mintAmount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    redeem(
+      redeemTokens: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    redeemBehalf(
+      redeemer: string,
+      redeemTokens: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    redeemUnderlyingBehalf(
+      redeemer: string,
+      redeemAmount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    repayBorrowBehalf(
+      borrower: string,
+      repayAmount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    transferFrom(
+      from: string,
+      to: string,
+      amount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    underlying(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
   };
 }