mirror of
https://github.com/Instadapp/Gelato-automations.git
synced 2024-07-29 22:28:07 +00:00
725 lines
21 KiB
JavaScript
725 lines
21 KiB
JavaScript
const { expect } = require("chai");
|
|
const hre = require("hardhat");
|
|
const { deployments, ethers } = hre;
|
|
|
|
// #region Contracts ABI
|
|
|
|
const ConnectMaker = require("../../../pre-compiles/ConnectMaker.json");
|
|
const GetCdps = require("../../../pre-compiles/GetCdps.json");
|
|
const DssCdpManager = require("../../../pre-compiles/DssCdpManager.json");
|
|
const InstaList = require("../../../pre-compiles/InstaList.json");
|
|
const InstaAccount = require("../../../pre-compiles/InstaAccount.json");
|
|
const InstaIndex = require("../../../pre-compiles/InstaIndex.json");
|
|
const Vat = require("../../../artifacts/contracts/interfaces/dapps/Maker/IVat.sol/IVat.json");
|
|
const IERC20 = require("../../../pre-compiles/IERC20.json");
|
|
|
|
// #endregion
|
|
|
|
describe("ConditionDestVaultWillBeSafe Unit Test", function () {
|
|
this.timeout(0);
|
|
if (hre.network.name !== "hardhat") {
|
|
console.error("Test Suite is meant to be run on hardhat only");
|
|
process.exit(1);
|
|
}
|
|
|
|
let userWallet;
|
|
let userAddress;
|
|
|
|
let getCdps;
|
|
let dssCdpManager;
|
|
let instaList;
|
|
let instaIndex;
|
|
let DAI;
|
|
let vat;
|
|
|
|
let conditionDestVaultWillBeSafe;
|
|
|
|
let dsa;
|
|
let cdpAId;
|
|
let cdpBId;
|
|
let ilkA;
|
|
let ilkB;
|
|
let ethAIlk;
|
|
let ethBIlk;
|
|
let amountToBorrow;
|
|
|
|
beforeEach(async function () {
|
|
// Deploy contract dependencies
|
|
await deployments.fixture();
|
|
|
|
// Get Test Wallet for local testnet
|
|
[userWallet] = await ethers.getSigners();
|
|
userAddress = await userWallet.getAddress();
|
|
|
|
// Hardhat default accounts prefilled with 100 ETH
|
|
expect(await userWallet.getBalance()).to.be.gt(
|
|
ethers.utils.parseEther("10")
|
|
);
|
|
|
|
instaIndex = await ethers.getContractAt(
|
|
InstaIndex.abi,
|
|
hre.network.config.InstaIndex
|
|
);
|
|
instaList = await ethers.getContractAt(
|
|
InstaList.abi,
|
|
hre.network.config.InstaList
|
|
);
|
|
getCdps = await ethers.getContractAt(
|
|
GetCdps.abi,
|
|
hre.network.config.GetCdps
|
|
);
|
|
dssCdpManager = await ethers.getContractAt(
|
|
DssCdpManager.abi,
|
|
hre.network.config.DssCdpManager
|
|
);
|
|
vat = new ethers.Contract(await dssCdpManager.vat(), Vat.abi, userWallet);
|
|
DAI = await ethers.getContractAt(IERC20.abi, hre.network.config.DAI);
|
|
|
|
// ========== Test Setup ============
|
|
conditionDestVaultWillBeSafe = await ethers.getContract(
|
|
"ConditionDestVaultWillBeSafe"
|
|
);
|
|
|
|
// Create DeFi Smart Account
|
|
|
|
const dsaAccountCount = await instaList.accounts();
|
|
|
|
await expect(instaIndex.build(userAddress, 1, userAddress)).to.emit(
|
|
instaIndex,
|
|
"LogAccountCreated"
|
|
);
|
|
const dsaID = dsaAccountCount.add(1);
|
|
await expect(await instaList.accounts()).to.be.equal(dsaID);
|
|
|
|
// Instantiate the DSA
|
|
dsa = await ethers.getContractAt(
|
|
InstaAccount.abi,
|
|
await instaList.accountAddr(dsaID)
|
|
);
|
|
|
|
// Create/Deposit/Borrow a Vault for ETH-A
|
|
let openVault = await hre.run("abi-encode-withselector", {
|
|
abi: ConnectMaker.abi,
|
|
functionname: "open",
|
|
inputs: ["ETH-A"],
|
|
});
|
|
|
|
await dsa.cast([hre.network.config.ConnectMaker], [openVault], userAddress);
|
|
|
|
let cdps = await getCdps.getCdpsAsc(dssCdpManager.address, dsa.address);
|
|
cdpAId = String(cdps.ids[0]);
|
|
|
|
expect(cdps.ids[0].isZero()).to.be.false;
|
|
|
|
// Create/Deposit/Borrow a Vault for ETH-B
|
|
openVault = await hre.run("abi-encode-withselector", {
|
|
abi: ConnectMaker.abi,
|
|
functionname: "open",
|
|
inputs: ["ETH-B"],
|
|
});
|
|
|
|
await dsa.cast([hre.network.config.ConnectMaker], [openVault], userAddress);
|
|
|
|
cdps = await getCdps.getCdpsAsc(dssCdpManager.address, dsa.address);
|
|
cdpBId = String(cdps.ids[1]);
|
|
|
|
expect(cdps.ids[1].isZero()).to.be.false;
|
|
|
|
ethAIlk = ethers.utils.formatBytes32String("ETH-A");
|
|
ilkA = await vat.ilks(ethAIlk);
|
|
|
|
ethBIlk = ethers.utils.formatBytes32String("ETH-B");
|
|
ilkB = await vat.ilks(ethBIlk);
|
|
|
|
amountToBorrow = ethers.utils.parseUnits("500", 18);
|
|
});
|
|
|
|
it("#1: ok should return Ok when the gas fees didn't exceed a user define amount with vault creation", async function () {
|
|
// Steps :
|
|
// 1 - Deposit
|
|
// 2 - Borrow
|
|
// 3 - Test if vault ETH-B will be safe after debt bridge action
|
|
const amountToDeposit = amountToBorrow
|
|
.mul(ethers.utils.parseUnits("1", 27))
|
|
.div(ilkA[2]) // ilk[2] represent the liquidation ratio of ilk
|
|
.add(ethers.utils.parseUnits("4", 17)); // to be just above the liquidation ratio.
|
|
|
|
//#region Deposit
|
|
|
|
await dsa.cast(
|
|
[hre.network.config.ConnectMaker],
|
|
[
|
|
await hre.run("abi-encode-withselector", {
|
|
abi: ConnectMaker.abi,
|
|
functionname: "deposit",
|
|
inputs: [cdpAId, amountToDeposit, 0, 0],
|
|
}),
|
|
],
|
|
userAddress,
|
|
{
|
|
value: amountToDeposit,
|
|
}
|
|
);
|
|
|
|
//#endregion Deposit
|
|
|
|
//#region Borrow
|
|
|
|
await dsa.cast(
|
|
[hre.network.config.ConnectMaker],
|
|
[
|
|
await hre.run("abi-encode-withselector", {
|
|
abi: ConnectMaker.abi,
|
|
functionname: "borrow",
|
|
inputs: [cdpAId, amountToBorrow, 0, 0],
|
|
}),
|
|
],
|
|
userAddress
|
|
);
|
|
|
|
expect(await DAI.balanceOf(dsa.address)).to.be.equal(amountToBorrow);
|
|
|
|
//#endregion Borrow
|
|
|
|
const conditionData = await conditionDestVaultWillBeSafe.getConditionData(
|
|
dsa.address,
|
|
cdpAId,
|
|
0,
|
|
"ETH-B"
|
|
);
|
|
expect(
|
|
await conditionDestVaultWillBeSafe.ok(0, conditionData, 0)
|
|
).to.be.equal("OK");
|
|
});
|
|
|
|
// it("#2: ok should return DestVaultWillNotBeSafe when the gas fees exceeded a user define amount with vault creation", async function () {
|
|
// // Steps :
|
|
// // 1 - Deposit
|
|
// // 2 - Borrow
|
|
// // 3 - Test if vault ETH-B will be safe after debt bridge action
|
|
// const amountToDeposit = amountToBorrow
|
|
// .mul(ethers.utils.parseUnits("1", 27))
|
|
// .div(ilkA[2]) // ilk[2] represent the liquidation ratio of ilk
|
|
// .add(ethers.utils.parseUnits("1", 16)); // to be just below the liquidation ratio.
|
|
|
|
// //#region Deposit
|
|
|
|
// await dsa.cast(
|
|
// [hre.network.config.ConnectMaker],
|
|
// [
|
|
// await hre.run("abi-encode-withselector", {
|
|
// abi: ConnectMaker.abi,
|
|
// functionname: "deposit",
|
|
// inputs: [cdpAId, amountToDeposit, 0, 0],
|
|
// }),
|
|
// ],
|
|
// userAddress,
|
|
// {
|
|
// value: amountToDeposit,
|
|
// }
|
|
// );
|
|
|
|
// //#endregion Deposit
|
|
|
|
// //#region Borrow
|
|
|
|
// await dsa.cast(
|
|
// [hre.network.config.ConnectMaker],
|
|
// [
|
|
// await hre.run("abi-encode-withselector", {
|
|
// abi: ConnectMaker.abi,
|
|
// functionname: "borrow",
|
|
// inputs: [cdpAId, amountToBorrow, 0, 0],
|
|
// }),
|
|
// ],
|
|
// userAddress
|
|
// );
|
|
|
|
// expect(await DAI.balanceOf(dsa.address)).to.be.equal(amountToBorrow);
|
|
|
|
// //#endregion Borrow
|
|
|
|
// const conditionData = await conditionDestVaultWillBeSafe.getConditionData(
|
|
// dsa.address,
|
|
// cdpAId,
|
|
// 0,
|
|
// "ETH-B"
|
|
// );
|
|
// expect(
|
|
// await conditionDestVaultWillBeSafe.ok(0, conditionData, 0)
|
|
// ).to.be.equal("DestVaultWillNotBeSafe");
|
|
// });
|
|
|
|
// it("#3: ok should return DestVaultWillNotBeSafe when the gas fees exceeded a user define amount", async function () {
|
|
// // Steps :
|
|
// // 1 - Deposit
|
|
// // 2 - Borrow
|
|
// // 3 - Test if vault ETH-B will be safe after debt bridge action
|
|
// const amountToDeposit = amountToBorrow
|
|
// .mul(ethers.utils.parseUnits("1", 27))
|
|
// .div(ilkA[2]) // ilk[2] represent the liquidation ratio of ilk
|
|
// .add(ethers.utils.parseUnits("1", 16)); // to be just below the liquidation ratio.
|
|
|
|
// //#region Deposit
|
|
|
|
// await dsa.cast(
|
|
// [hre.network.config.ConnectMaker],
|
|
// [
|
|
// await hre.run("abi-encode-withselector", {
|
|
// abi: ConnectMaker.abi,
|
|
// functionname: "deposit",
|
|
// inputs: [cdpAId, amountToDeposit, 0, 0],
|
|
// }),
|
|
// ],
|
|
// userAddress,
|
|
// {
|
|
// value: amountToDeposit,
|
|
// }
|
|
// );
|
|
|
|
// //#endregion Deposit
|
|
|
|
// //#region Borrow
|
|
|
|
// await dsa.cast(
|
|
// [hre.network.config.ConnectMaker],
|
|
// [
|
|
// await hre.run("abi-encode-withselector", {
|
|
// abi: ConnectMaker.abi,
|
|
// functionname: "borrow",
|
|
// inputs: [cdpAId, amountToBorrow, 0, 0],
|
|
// }),
|
|
// ],
|
|
// userAddress
|
|
// );
|
|
|
|
// expect(await DAI.balanceOf(dsa.address)).to.be.equal(amountToBorrow);
|
|
|
|
// //#endregion Borrow
|
|
|
|
// const conditionData = await conditionDestVaultWillBeSafe.getConditionData(
|
|
// dsa.address,
|
|
// cdpAId,
|
|
// cdpBId,
|
|
// "ETH-B"
|
|
// );
|
|
// expect(
|
|
// await conditionDestVaultWillBeSafe.ok(0, conditionData, 0)
|
|
// ).to.be.equal("DestVaultWillNotBeSafe");
|
|
// });
|
|
|
|
it("#4: ok should return Ok when the gas fees didn't exceed a user define amount", async function () {
|
|
// Steps :
|
|
// 1 - Deposit
|
|
// 2 - Borrow
|
|
// 3 - Test if vault ETH-B will be safe after debt bridge action
|
|
const amountToDeposit = amountToBorrow
|
|
.mul(ethers.utils.parseUnits("1", 27))
|
|
.div(ilkA[2]) // ilk[2] represent the liquidation ratio of ilk
|
|
.add(ethers.utils.parseUnits("4", 17)); // to be just above the liquidation ratio.
|
|
|
|
//#region Deposit
|
|
|
|
await dsa.cast(
|
|
[hre.network.config.ConnectMaker],
|
|
[
|
|
await hre.run("abi-encode-withselector", {
|
|
abi: ConnectMaker.abi,
|
|
functionname: "deposit",
|
|
inputs: [cdpAId, amountToDeposit, 0, 0],
|
|
}),
|
|
],
|
|
userAddress,
|
|
{
|
|
value: amountToDeposit,
|
|
}
|
|
);
|
|
|
|
//#endregion Deposit
|
|
|
|
//#region Borrow
|
|
await dsa.cast(
|
|
[hre.network.config.ConnectMaker],
|
|
[
|
|
await hre.run("abi-encode-withselector", {
|
|
abi: ConnectMaker.abi,
|
|
functionname: "borrow",
|
|
inputs: [cdpAId, amountToBorrow, 0, 0],
|
|
}),
|
|
],
|
|
userAddress
|
|
);
|
|
|
|
expect(await DAI.balanceOf(dsa.address)).to.be.equal(amountToBorrow);
|
|
//#endregion Borrow
|
|
|
|
const conditionData = await conditionDestVaultWillBeSafe.getConditionData(
|
|
dsa.address,
|
|
cdpAId,
|
|
cdpBId,
|
|
"ETH-B"
|
|
);
|
|
expect(
|
|
await conditionDestVaultWillBeSafe.ok(0, conditionData, 0)
|
|
).to.be.equal("OK");
|
|
});
|
|
|
|
it("#5: ok should return Ok when the gas fees didn't exceed a user define amount with deposit on vaultB", async function () {
|
|
// Steps :
|
|
// 1 - Deposit in Vault ETH-A
|
|
// 2 - Deposit in Vault ETH-B just the minimum needed to make the all position of the user safe after debt bridge
|
|
// 3 - Borrow
|
|
// 4 - Test if vault ETH-B will be safe after debt bridge action
|
|
const amountToDeposit = amountToBorrow
|
|
.mul(ethers.utils.parseUnits("1", 27))
|
|
.div(ilkA[2]) // ilk[2] represent the liquidation ratio of ilk
|
|
.add(ethers.utils.parseUnits("1", 17)); // to be just above the liquidation ratio.
|
|
|
|
//#region Deposit on Vault ETH-A
|
|
|
|
await dsa.cast(
|
|
[hre.network.config.ConnectMaker],
|
|
[
|
|
await hre.run("abi-encode-withselector", {
|
|
abi: ConnectMaker.abi,
|
|
functionname: "deposit",
|
|
inputs: [cdpAId, amountToDeposit, 0, 0],
|
|
}),
|
|
],
|
|
userAddress,
|
|
{
|
|
value: amountToDeposit,
|
|
}
|
|
);
|
|
|
|
//#endregion Deposit
|
|
|
|
//#region Deposit on Vault ETH-B
|
|
|
|
await dsa.cast(
|
|
[hre.network.config.ConnectMaker],
|
|
[
|
|
await hre.run("abi-encode-withselector", {
|
|
abi: ConnectMaker.abi,
|
|
functionname: "deposit",
|
|
inputs: [cdpBId, ethers.utils.parseUnits("3", 17), 0, 0],
|
|
}),
|
|
],
|
|
userAddress,
|
|
{
|
|
value: amountToDeposit,
|
|
}
|
|
);
|
|
|
|
//#endregion Deposit on Vault ETH-B
|
|
|
|
//#region Borrow
|
|
|
|
await dsa.cast(
|
|
[hre.network.config.ConnectMaker],
|
|
[
|
|
await hre.run("abi-encode-withselector", {
|
|
abi: ConnectMaker.abi,
|
|
functionname: "borrow",
|
|
inputs: [cdpAId, amountToBorrow, 0, 0],
|
|
}),
|
|
],
|
|
userAddress
|
|
);
|
|
|
|
expect(await DAI.balanceOf(dsa.address)).to.be.equal(amountToBorrow);
|
|
|
|
//#endregion Borrow
|
|
|
|
const conditionData = await conditionDestVaultWillBeSafe.getConditionData(
|
|
dsa.address,
|
|
cdpAId,
|
|
cdpBId,
|
|
"ETH-B"
|
|
);
|
|
expect(
|
|
await conditionDestVaultWillBeSafe.ok(0, conditionData, 0)
|
|
).to.be.equal("OK");
|
|
});
|
|
|
|
// it("#6: ok should return DestVaultWillNotBeSafe when the gas fees exceed a user define amount with closing the vaultB", async function () {
|
|
// // Steps :
|
|
// // 1 - Deposit in Vault ETH-A
|
|
// // 4 - Close Vault ETH-B
|
|
// // 5 - Test if vault ETH-B will be safe after debt bridge action
|
|
// const amountToDeposit = amountToBorrow
|
|
// .mul(ethers.utils.parseUnits("1", 27))
|
|
// .div(ilkA[2]) // ilk[2] represent the liquidation ratio of ilk
|
|
// .add(ethers.utils.parseUnits("1", 17)); // to be just above the liquidation ratio.
|
|
|
|
// //#region Deposit on Vault ETH-B
|
|
|
|
// await dsa.cast(
|
|
// [hre.network.config.ConnectMaker],
|
|
// [
|
|
// await hre.run("abi-encode-withselector", {
|
|
// abi: ConnectMaker.abi,
|
|
// functionname: "close",
|
|
// inputs: [cdpBId],
|
|
// }),
|
|
// ],
|
|
// userAddress,
|
|
// {
|
|
// value: amountToDeposit,
|
|
// }
|
|
// );
|
|
|
|
// //#endregion Deposit on Vault ETH-B
|
|
|
|
// //#region Deposit on Vault ETH-A
|
|
|
|
// await dsa.cast(
|
|
// [hre.network.config.ConnectMaker],
|
|
// [
|
|
// await hre.run("abi-encode-withselector", {
|
|
// abi: ConnectMaker.abi,
|
|
// functionname: "deposit",
|
|
// inputs: [cdpAId, amountToDeposit, 0, 0],
|
|
// }),
|
|
// ],
|
|
// userAddress,
|
|
// {
|
|
// value: amountToDeposit,
|
|
// }
|
|
// );
|
|
|
|
// //#endregion Deposit
|
|
|
|
// //#region Borrow
|
|
|
|
// await dsa.cast(
|
|
// [hre.network.config.ConnectMaker],
|
|
// [
|
|
// await hre.run("abi-encode-withselector", {
|
|
// abi: ConnectMaker.abi,
|
|
// functionname: "borrow",
|
|
// inputs: [cdpAId, amountToBorrow, 0, 0],
|
|
// }),
|
|
// ],
|
|
// userAddress
|
|
// );
|
|
|
|
// expect(await DAI.balanceOf(dsa.address)).to.be.equal(amountToBorrow);
|
|
|
|
// //#endregion Borrow
|
|
|
|
// const conditionData = await conditionDestVaultWillBeSafe.getConditionData(
|
|
// dsa.address,
|
|
// cdpAId,
|
|
// cdpBId,
|
|
// "ETH-B"
|
|
// );
|
|
// expect(
|
|
// await conditionDestVaultWillBeSafe.ok(0, conditionData, 0)
|
|
// ).to.be.equal("DestVaultWillNotBeSafe");
|
|
// });
|
|
|
|
it("#7: ok should return Ok when the gas fees didn't exceed a user define amount with closing the vaultB", async function () {
|
|
// Steps :
|
|
// 1 - Deposit in Vault ETH-A
|
|
// 4 - Close Vault ETH-B
|
|
// 5 - Test if vault ETH-B will be safe after debt bridge action
|
|
const amountToDeposit = amountToBorrow
|
|
.mul(ethers.utils.parseUnits("1", 27))
|
|
.div(ilkA[2]) // ilk[2] represent the liquidation ratio of ilk
|
|
.add(ethers.utils.parseUnits("4", 17)); // to be just above the liquidation ratio.
|
|
|
|
//#region Deposit on Vault ETH-B
|
|
|
|
await dsa.cast(
|
|
[hre.network.config.ConnectMaker],
|
|
[
|
|
await hre.run("abi-encode-withselector", {
|
|
abi: ConnectMaker.abi,
|
|
functionname: "close",
|
|
inputs: [cdpBId],
|
|
}),
|
|
],
|
|
userAddress,
|
|
{
|
|
value: amountToDeposit,
|
|
}
|
|
);
|
|
|
|
//#endregion Deposit on Vault ETH-B
|
|
|
|
//#region Deposit on Vault ETH-A
|
|
|
|
await dsa.cast(
|
|
[hre.network.config.ConnectMaker],
|
|
[
|
|
await hre.run("abi-encode-withselector", {
|
|
abi: ConnectMaker.abi,
|
|
functionname: "deposit",
|
|
inputs: [cdpAId, amountToDeposit, 0, 0],
|
|
}),
|
|
],
|
|
userAddress,
|
|
{
|
|
value: amountToDeposit,
|
|
}
|
|
);
|
|
|
|
//#endregion Deposit
|
|
|
|
//#region Borrow
|
|
|
|
await dsa.cast(
|
|
[hre.network.config.ConnectMaker],
|
|
[
|
|
await hre.run("abi-encode-withselector", {
|
|
abi: ConnectMaker.abi,
|
|
functionname: "borrow",
|
|
inputs: [cdpAId, amountToBorrow, 0, 0],
|
|
}),
|
|
],
|
|
userAddress
|
|
);
|
|
|
|
expect(await DAI.balanceOf(dsa.address)).to.be.equal(amountToBorrow);
|
|
|
|
//#endregion Borrow
|
|
|
|
const conditionData = await conditionDestVaultWillBeSafe.getConditionData(
|
|
dsa.address,
|
|
cdpAId,
|
|
cdpBId,
|
|
"ETH-B"
|
|
);
|
|
expect(
|
|
await conditionDestVaultWillBeSafe.ok(0, conditionData, 0)
|
|
).to.be.equal("OK");
|
|
});
|
|
|
|
it("#8: New Vault Case : destVaultWillBeSafeExplicit should return false when col is lower than borrow amount / spot", async function () {
|
|
let amountOfColToDepo = amountToBorrow
|
|
.mul(ilkB[1]) // ilk[1] represent accumulated rates
|
|
.div(ethers.utils.parseUnits("1", 27));
|
|
amountOfColToDepo = amountOfColToDepo
|
|
.sub(amountOfColToDepo.div(ethers.utils.parseUnits("10", 0)))
|
|
.mul(ethers.utils.parseUnits("1", 27))
|
|
.div(ilkB[2]); // ilk[2] represent the liquidation ratio of ilk
|
|
|
|
expect(
|
|
await conditionDestVaultWillBeSafe.destVaultWillBeSafeExplicit(
|
|
0,
|
|
amountToBorrow,
|
|
amountOfColToDepo,
|
|
"ETH-B"
|
|
)
|
|
).to.be.false;
|
|
});
|
|
|
|
it("#9: New Vault Case : destVaultWillBeSafeExplicit should return true when col is greater than borrow amount / spot", async function () {
|
|
let amountOfColToDepo = amountToBorrow
|
|
.mul(ilkB[1]) // ilk[1] represent accumulated rates
|
|
.div(ethers.utils.parseUnits("1", 27));
|
|
amountOfColToDepo = amountOfColToDepo
|
|
.add(amountOfColToDepo.div(ethers.utils.parseUnits("10", 0)))
|
|
.mul(ethers.utils.parseUnits("1", 27))
|
|
.div(ilkB[2]); // ilk[2] represent the liquidation ratio of ilk
|
|
|
|
expect(
|
|
await conditionDestVaultWillBeSafe.destVaultWillBeSafeExplicit(
|
|
0,
|
|
amountToBorrow,
|
|
amountOfColToDepo,
|
|
"ETH-B"
|
|
)
|
|
).to.be.true;
|
|
});
|
|
|
|
it("#10: Old Vault Case : destVaultWillBeSafeExplicit should return false when col is lower than borrow amount / spot", async function () {
|
|
const openVault = await hre.run("abi-encode-withselector", {
|
|
abi: ConnectMaker.abi,
|
|
functionname: "open",
|
|
inputs: ["ETH-B"],
|
|
});
|
|
|
|
await dsa.cast([hre.network.config.ConnectMaker], [openVault], userAddress);
|
|
|
|
const cdpIdB = String(
|
|
(await getCdps.getCdpsAsc(dssCdpManager.address, dsa.address)).ids[1]
|
|
);
|
|
|
|
let amountOfColToDepo = amountToBorrow
|
|
.mul(ilkB[1]) // ilk[1] represent accumulated rates
|
|
.div(ethers.utils.parseUnits("1", 27));
|
|
amountOfColToDepo = amountOfColToDepo
|
|
.sub(amountOfColToDepo.div(ethers.utils.parseUnits("10", 0)))
|
|
.mul(ethers.utils.parseUnits("1", 27))
|
|
.div(ilkB[2]); // ilk[2] represent the liquidation ratio of ilk
|
|
|
|
expect(
|
|
await conditionDestVaultWillBeSafe.destVaultWillBeSafeExplicit(
|
|
cdpIdB,
|
|
amountToBorrow,
|
|
amountOfColToDepo,
|
|
"ETH-B"
|
|
)
|
|
).to.be.false;
|
|
});
|
|
|
|
it("#11: Old Vault Case : destVaultWillBeSafeExplicit should return true when col is lower than borrow amount / spot", async function () {
|
|
let amountOfColToDepo = amountToBorrow
|
|
.mul(ilkB[1]) // ilk[1] represent accumulated rates
|
|
.div(ethers.utils.parseUnits("1", 27));
|
|
amountOfColToDepo = amountOfColToDepo
|
|
.add(amountOfColToDepo.div(ethers.utils.parseUnits("10", 0)))
|
|
.mul(ethers.utils.parseUnits("1", 27))
|
|
.div(ilkB[2]); // ilk[2] represent the liquidation ratio of ilk
|
|
|
|
expect(
|
|
await conditionDestVaultWillBeSafe.destVaultWillBeSafeExplicit(
|
|
cdpBId,
|
|
amountToBorrow,
|
|
amountOfColToDepo,
|
|
"ETH-B"
|
|
)
|
|
).to.be.true;
|
|
});
|
|
|
|
it("#12: Old Vault Case with existing deposit : destVaultWillBeSafeExplicit should return true when col is lower than borrow amount / spot due to initial deposit on Vault B", async function () {
|
|
let amountOfColToDepo = amountToBorrow
|
|
.mul(ilkB[1]) // ilk[1] represent accumulated rates
|
|
.div(ethers.utils.parseUnits("1", 27));
|
|
const tenPercentOfAmountOfColToDepo = amountOfColToDepo.div(
|
|
ethers.utils.parseUnits("10", 0)
|
|
);
|
|
amountOfColToDepo = amountOfColToDepo
|
|
.sub(tenPercentOfAmountOfColToDepo)
|
|
.mul(ethers.utils.parseUnits("1", 27))
|
|
.div(ilkB[2]); // ilk[2] represent the liquidation ratio of ilk
|
|
|
|
// Deposit For ETH-B Vault
|
|
await dsa.cast(
|
|
[hre.network.config.ConnectMaker],
|
|
[
|
|
await hre.run("abi-encode-withselector", {
|
|
abi: ConnectMaker.abi,
|
|
functionname: "deposit",
|
|
inputs: [cdpBId, tenPercentOfAmountOfColToDepo, 0, 0],
|
|
}),
|
|
],
|
|
userAddress,
|
|
{
|
|
value: tenPercentOfAmountOfColToDepo,
|
|
}
|
|
);
|
|
|
|
expect(
|
|
await conditionDestVaultWillBeSafe.destVaultWillBeSafeExplicit(
|
|
cdpBId,
|
|
amountToBorrow,
|
|
amountOfColToDepo,
|
|
"ETH-B"
|
|
)
|
|
).to.be.true;
|
|
});
|
|
});
|