Remove USDF from VIP

Author: Exef

simulations/vip-515/bsctestnet-addendum.ts

@@ -10,18 +10,13 @@ import { checkInterestRate } from "src/vip-framework/checks/interestRateModel";
 
 import {
   Actions,
-  CONVERSION_INCENTIVE,
   PROTOCOL_SHARE_RESERVE,
-  USDFMarketSpec,
   asBNBMarketSpec,
   convertAmountToVTokens,
-  converterBaseAssets,
-  vip515,
-} from "../../vips/vip-515/bscmainnet";
+  vip520,
+} from "../../vips/vip-520/bscmainnet";
 import VTOKEN_ABI from "./abi/LegacyPoolVToken.json";
-import MOCKTOKEN_ABI from "./abi/MockToken.json";
 import RESILIENT_ORACLE_ABI from "./abi/ResilientOracle.json";
-import SINGLE_TOKEN_CONVERTER_ABI from "./abi/SingleTokenConverter.json";
 import ASBNB_ABI from "./abi/asBNB.json";
 import COMPTROLLER_ABI from "./abi/comptroller.json";
 
@@ -37,17 +32,13 @@ forking(51547465, async () => {
   let resilientOracle: Contract;
   let asBNB: Contract;
   let vasBNB: Contract;
-  let usdf: Contract;
-  let vUSDF: Contract;
 
   const provider = ethers.provider;
 
   before(async () => {
     comptroller = new ethers.Contract(asBNBMarketSpec.vToken.comptroller, COMPTROLLER_ABI, provider);
     asBNB = new ethers.Contract(asBNBMarketSpec.vToken.underlying.address, ASBNB_ABI, provider);
     vasBNB = new ethers.Contract(asBNBMarketSpec.vToken.address, VTOKEN_ABI, provider);
-    usdf = new ethers.Contract(USDFMarketSpec.vToken.underlying.address, MOCKTOKEN_ABI, provider);
-    vUSDF = new ethers.Contract(USDFMarketSpec.vToken.address, VTOKEN_ABI, provider);
     resilientOracle = new ethers.Contract(bscmainnet.RESILIENT_ORACLE, RESILIENT_ORACLE_ABI, ethers.provider);
 
     await setMaxStalePeriodInChainlinkOracle(
@@ -73,46 +64,18 @@ forking(51547465, async () => {
       );
       expect(borrowPaused).to.equal(false);
     });
-
-    it("check USDF market not listed", async () => {
-      const market = await comptroller.markets(USDFMarketSpec.vToken.underlying.address);
-      expect(market.isListed).to.equal(false);
-    });
-
-    it("check USDF market not paused", async () => {
-      const borrowPaused = await comptroller.actionPaused(
-        USDFMarketSpec.vToken.underlying.address,
-        Actions.ENTER_MARKET,
-      );
-      expect(borrowPaused).to.equal(false);
-    });
   });
 
-  testVip(
-    "VIP-515",
-    await vip515({
-      maxStalePeriod: 30 * 24 * 60 * 60, // 30 days in seconds
-    }),
-    {
-      callbackAfterExecution: async txResponse => {
-        const numberOfNewMarkets = 2;
-
-        await expectEvents(
-          txResponse,
-          [COMPTROLLER_ABI, VTOKEN_ABI],
-          ["MarketListed", "NewSupplyCap", "NewCollateralFactor", "NewReserveFactor", "NewProtocolShareReserve"],
-          [
-            numberOfNewMarkets,
-            numberOfNewMarkets,
-            numberOfNewMarkets,
-            numberOfNewMarkets,
-            numberOfNewMarkets,
-            numberOfNewMarkets,
-          ],
-        );
-      },
+  testVip("vip-520", await vip520(), {
+    callbackAfterExecution: async txResponse => {
+      await expectEvents(
+        txResponse,
+        [COMPTROLLER_ABI, VTOKEN_ABI],
+        ["MarketListed", "NewSupplyCap", "NewCollateralFactor", "NewReserveFactor", "NewProtocolShareReserve"],
+        [1, 1, 1, 1, 1, 1],
+      );
     },
-  );
+  });
 
   describe("Post-VIP behavior", async () => {
     checkInterestRate(RATE_MODEL, "asBNB", {
@@ -122,13 +85,6 @@ forking(51547465, async () => {
       kink: asBNBMarketSpec.interestRateModel.kink,
     });
 
-    checkInterestRate(RATE_MODEL, "vUSDF", {
-      base: USDFMarketSpec.interestRateModel.baseRatePerYear,
-      multiplier: USDFMarketSpec.interestRateModel.multiplierPerYear,
-      jump: USDFMarketSpec.interestRateModel.jumpMultiplierPerYear,
-      kink: USDFMarketSpec.interestRateModel.kink,
-    });
-
     checkVToken(asBNBMarketSpec.vToken.address, {
       name: "Venus asBNB",
       symbol: "vasBNB",
@@ -137,84 +93,44 @@ forking(51547465, async () => {
       exchangeRate: asBNBMarketSpec.vToken.exchangeRate,
       comptroller: asBNBMarketSpec.vToken.comptroller,
     });
-
-    checkVToken(USDFMarketSpec.vToken.address, {
-      name: "Venus USDF",
-      symbol: "vUSDF",
-      decimals: 8,
-      underlying: USDFMarketSpec.vToken.underlying.address,
-      exchangeRate: USDFMarketSpec.vToken.exchangeRate,
-      comptroller: USDFMarketSpec.vToken.comptroller,
-    });
-
     checkRiskParameters(asBNBMarketSpec.vToken.address, asBNBMarketSpec.vToken, asBNBMarketSpec.riskParameters);
-    checkRiskParameters(USDFMarketSpec.vToken.address, USDFMarketSpec.vToken, USDFMarketSpec.riskParameters);
 
-    it("check price USDF", async () => {
-      const expectedPrice = "1000174500000000000"; // 1.0001745 USD
-      expect(await resilientOracle.getPrice(USDFMarketSpec.vToken.underlying.address)).to.equal(expectedPrice);
-      expect(await resilientOracle.getUnderlyingPrice(USDFMarketSpec.vToken.address)).to.equal(expectedPrice);
-    });
-
-    it("markets have correct owner", async () => {
+    it("market have correct owner", async () => {
       expect(await vasBNB.admin()).to.equal(bscmainnet.NORMAL_TIMELOCK);
-      expect(await vUSDF.admin()).to.equal(bscmainnet.NORMAL_TIMELOCK);
     });
 
     it("markets have correct ACM", async () => {
       expect(await vasBNB.accessControlManager()).to.equal(bscmainnet.ACCESS_CONTROL_MANAGER);
-      expect(await vUSDF.accessControlManager()).to.equal(bscmainnet.ACCESS_CONTROL_MANAGER);
     });
 
     it("markets should have correct protocol share reserve", async () => {
       expect(await vasBNB.protocolShareReserve()).to.equal(PROTOCOL_SHARE_RESERVE);
-      expect(await vUSDF.protocolShareReserve()).to.equal(PROTOCOL_SHARE_RESERVE);
     });
 
     it("markets should have correct total supply", async () => {
       const vasBNBSupply = await vasBNB.totalSupply();
-      const vUSDFSupply = await vUSDF.totalSupply();
 
       expect(vasBNBSupply).to.equal(
         convertAmountToVTokens(asBNBMarketSpec.initialSupply.amount, asBNBMarketSpec.vToken.exchangeRate),
       );
-      expect(vUSDFSupply).to.equal(
-        convertAmountToVTokens(USDFMarketSpec.initialSupply.amount, USDFMarketSpec.vToken.exchangeRate),
-      );
     });
 
     it("markets should have balance of underlying", async () => {
       const asBNBBalance = await asBNB.balanceOf(vasBNB.address);
-      const usdfBalance = await usdf.balanceOf(vUSDF.address);
 
       expect(asBNBBalance).to.equal(asBNBMarketSpec.initialSupply.amount);
-      expect(usdfBalance).to.equal(USDFMarketSpec.initialSupply.amount);
     });
 
     it("should burn vTokens", async () => {
       const vasBNBBalanceBurned = await vasBNB.balanceOf(ethers.constants.AddressZero);
-      const vUSDFBalanceBurned = await vUSDF.balanceOf(ethers.constants.AddressZero);
 
       expect(vasBNBBalanceBurned).to.equal(asBNBMarketSpec.initialSupply.vTokensToBurn);
-      expect(vUSDFBalanceBurned).to.equal(USDFMarketSpec.initialSupply.vTokensToBurn);
-    });
-
-    it("should transfer vTokens to receiver", async () => {
-      const vUSDFReceiverBalance = await vUSDF.balanceOf(USDFMarketSpec.initialSupply.vTokenReceiver);
-
-      expect(vUSDFReceiverBalance).to.equal(
-        convertAmountToVTokens(USDFMarketSpec.initialSupply.amount, USDFMarketSpec.vToken.exchangeRate).sub(
-          USDFMarketSpec.initialSupply.vTokensToBurn,
-        ),
-      );
     });
 
     it("should not leave any vTokens in the timelock", async () => {
       const vasBNBTimelockBalance = await vasBNB.balanceOf(bscmainnet.NORMAL_TIMELOCK);
-      const vUSDFTimelockBalance = await vUSDF.balanceOf(bscmainnet.NORMAL_TIMELOCK);
 
       expect(vasBNBTimelockBalance).to.equal(0);
-      expect(vUSDFTimelockBalance).to.equal(0);
     });
   });
 
@@ -223,18 +139,4 @@ forking(51547465, async () => {
       expect(await comptroller.actionPaused(asBNBMarketSpec.vToken.address, Actions.BORROW)).to.equal(true);
     });
   });
-
-  describe("Converters", () => {
-    for (const [converterAddress, baseAsset] of Object.entries(converterBaseAssets)) {
-      const converterContract = new ethers.Contract(converterAddress, SINGLE_TOKEN_CONVERTER_ABI, ethers.provider);
-
-      it(`should set ${CONVERSION_INCENTIVE} as incentive in converter ${converterAddress}, for asset USDF`, async () => {
-        const result = await converterContract.conversionConfigurations(
-          baseAsset,
-          USDFMarketSpec.vToken.underlying.address,
-        );
-        expect(result.incentive).to.equal(CONVERSION_INCENTIVE);
-      });
-    }
-  });
 });