mirror of
https://github.com/Instadapp/dsa-connectors-2.0.git
synced 2024-07-29 21:57:39 +00:00
653 lines
16 KiB
TypeScript
653 lines
16 KiB
TypeScript
import { expect } from "chai";
|
|
import hre from "hardhat";
|
|
import { abis } from "../../../scripts/constant/abis";
|
|
import { addresses } from "../../../scripts/tests/mainnet/addresses";
|
|
import { deployAndEnableConnector } from "../../../scripts/tests/deployAndEnableConnector";
|
|
import { getMasterSigner } from "../../../scripts/tests/getMasterSigner";
|
|
import { buildDSAv2 } from "../../../scripts/tests/buildDSAv2";
|
|
import { ConnectV2FluidPolygon, ConnectV2FluidPolygon__factory } from "../../../typechain";
|
|
import { parseEther, parseUnits } from "@ethersproject/units";
|
|
import { encodeSpells } from "../../../scripts/tests/encodeSpells";
|
|
import { constants } from "../../../scripts/constant/constant";
|
|
import { network, ethers } from "hardhat";
|
|
import type { Signer, Contract } from "ethers";
|
|
|
|
describe("Fluid", function () {
|
|
const connectorName = "FLUID";
|
|
let connector: any;
|
|
|
|
let wallet0: Signer, wallet1: Signer, wethHolderSigner: Signer, usdcHolderSigner: Signer;
|
|
let dsaWallet0: any;
|
|
let instaConnectorsV2: any;
|
|
let masterSigner: Signer;
|
|
const setIdMaticUsdc = "83478237";
|
|
const setIdWethUsdc = "83478249";
|
|
const setId3 = "85478249";
|
|
|
|
const vaultMaticUsdc = "0x2226FFAE044B9fd4ED991aDf20CAACF8E8302510";
|
|
const vaultWethUsdc = "0x10D97a8236624222F681C12Eea4Ddac2BDD0471B";
|
|
const vaultWethMatic = "0x553437CB882E3aFbB67Abd135E067AFB0721fbf1";
|
|
|
|
const wethHolder = "0xdeD8C5159CA3673f543D0F72043E4c655b35b96A";
|
|
const usdcHolder = "0xEc4Db437ADEE0420A28Afa8B87c74D3901F56AC4";
|
|
|
|
const WETH = "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619";
|
|
const USDC = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
|
|
|
|
const erc20Abi = [
|
|
{
|
|
constant: false,
|
|
inputs: [
|
|
{
|
|
name: "_spender",
|
|
type: "address"
|
|
},
|
|
{
|
|
name: "_value",
|
|
type: "uint256"
|
|
}
|
|
],
|
|
name: "approve",
|
|
outputs: [
|
|
{
|
|
name: "",
|
|
type: "bool"
|
|
}
|
|
],
|
|
payable: false,
|
|
stateMutability: "nonpayable",
|
|
type: "function"
|
|
},
|
|
{
|
|
constant: true,
|
|
inputs: [],
|
|
name: "totalSupply",
|
|
outputs: [
|
|
{
|
|
name: "",
|
|
type: "uint256"
|
|
}
|
|
],
|
|
payable: false,
|
|
stateMutability: "view",
|
|
type: "function"
|
|
},
|
|
{
|
|
constant: true,
|
|
inputs: [
|
|
{
|
|
name: "_owner",
|
|
type: "address"
|
|
}
|
|
],
|
|
name: "balanceOf",
|
|
outputs: [
|
|
{
|
|
name: "balance",
|
|
type: "uint256"
|
|
}
|
|
],
|
|
payable: false,
|
|
stateMutability: "view",
|
|
type: "function"
|
|
},
|
|
{
|
|
constant: false,
|
|
inputs: [
|
|
{
|
|
name: "_to",
|
|
type: "address"
|
|
},
|
|
{
|
|
name: "_value",
|
|
type: "uint256"
|
|
}
|
|
],
|
|
name: "transfer",
|
|
outputs: [
|
|
{
|
|
name: "",
|
|
type: "bool"
|
|
}
|
|
],
|
|
payable: false,
|
|
stateMutability: "nonpayable",
|
|
type: "function"
|
|
}
|
|
];
|
|
|
|
const wethToken = new ethers.Contract(WETH, erc20Abi);
|
|
const usdcToken = new ethers.Contract(USDC, erc20Abi);
|
|
|
|
before(async () => {
|
|
await hre.network.provider.request({
|
|
method: "hardhat_reset",
|
|
params: [
|
|
{
|
|
forking: {
|
|
// @ts-ignore
|
|
jsonRpcUrl: hre.config.networks.hardhat.forking.url,
|
|
blockNumber: 12796965,
|
|
},
|
|
},
|
|
],
|
|
});
|
|
|
|
[wallet0, wallet1] = await ethers.getSigners();
|
|
masterSigner = await getMasterSigner();
|
|
instaConnectorsV2 = await ethers.getContractAt(
|
|
abis.core.connectorsV2,
|
|
addresses.core.connectorsV2,
|
|
masterSigner
|
|
);
|
|
connector = await deployAndEnableConnector({
|
|
connectorName,
|
|
contractArtifact: ConnectV2FluidPolygon__factory,
|
|
signer: masterSigner,
|
|
connectors: instaConnectorsV2,
|
|
});
|
|
console.log("Connector address", connector.address);
|
|
});
|
|
|
|
it("should have contracts deployed", async () => {
|
|
expect(!!instaConnectorsV2.address).to.be.true;
|
|
expect(!!connector.address).to.be.true;
|
|
expect(!!(await masterSigner.getAddress())).to.be.true;
|
|
});
|
|
|
|
describe("DSA wallet setup", function () {
|
|
it("Should build DSA v2", async function () {
|
|
dsaWallet0 = await buildDSAv2(wallet0.getAddress());
|
|
expect(!!dsaWallet0.address).to.be.true;
|
|
});
|
|
|
|
it("Deposit 2000 Matic into DSA wallet", async function () {
|
|
await wallet0.sendTransaction({
|
|
to: dsaWallet0.address,
|
|
value: parseEther("2000"),
|
|
});
|
|
|
|
expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.gte(ethers.utils.parseEther("2000"));
|
|
|
|
});
|
|
|
|
it("Deposit 20 Weth into DSA wallet", async function () {
|
|
await wallet0.sendTransaction({
|
|
to: wethHolder,
|
|
value: parseEther("200"),
|
|
});
|
|
|
|
await hre.network.provider.request({
|
|
method: "hardhat_impersonateAccount",
|
|
params: [wethHolder]
|
|
});
|
|
|
|
wethHolderSigner = await ethers.getSigner(wethHolder);
|
|
|
|
await wethToken.connect(wethHolderSigner).transfer(dsaWallet0.address, ethers.utils.parseEther("20"));
|
|
|
|
expect(await wethToken.balanceOf(dsaWallet0.address)).to.be.gte(ethers.utils.parseEther("20"));
|
|
|
|
});
|
|
|
|
it("Deposit 20 Usdc into DSA wallet", async function () {
|
|
await wallet0.sendTransaction({
|
|
to: usdcHolder,
|
|
value: parseEther("200"),
|
|
});
|
|
|
|
await hre.network.provider.request({
|
|
method: "hardhat_impersonateAccount",
|
|
params: [usdcHolder]
|
|
});
|
|
|
|
usdcHolderSigner = await ethers.getSigner(usdcHolder);
|
|
|
|
await usdcToken.connect(usdcHolderSigner).transfer(dsaWallet0.address, parseUnits("20", 6));
|
|
|
|
expect(await usdcToken.balanceOf(dsaWallet0.address)).to.be.gte(parseUnits("20", 6));
|
|
});
|
|
});
|
|
|
|
// 2000 matic, 20 weth, 20 usdc
|
|
|
|
describe("Main", function () {
|
|
it("should deposit 1000 Matic in Fluid", async function () {
|
|
const amtDeposit = parseEther("1000");
|
|
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operate",
|
|
args: [
|
|
vaultMaticUsdc,
|
|
0, // new nft
|
|
amtDeposit, // +1000 collateral
|
|
0, // 0 debt
|
|
dsaWallet0.address,
|
|
0,
|
|
setIdMaticUsdc
|
|
],
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
|
|
expect(await ethers.provider.getBalance(dsaWallet0.address)).to.gte(
|
|
parseEther("1000")
|
|
);
|
|
});
|
|
// 1000 matic
|
|
|
|
it("should deposit max Matic in Fluid", async function () {
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operate",
|
|
args: [
|
|
vaultMaticUsdc, // matic-usdc vault
|
|
0, // setIdMaticUsdc
|
|
ethers.constants.MaxUint256, // + max collateral
|
|
0, // 0 debt
|
|
dsaWallet0.address,
|
|
setIdMaticUsdc,
|
|
0
|
|
],
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
|
|
expect(await ethers.provider.getBalance(dsaWallet0.address)).to.lte(
|
|
parseEther("1")
|
|
);
|
|
});
|
|
|
|
// 0 matic
|
|
|
|
it("should deposit 10 Weth in Fluid", async function () {
|
|
const amtDeposit = parseEther("10");
|
|
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operate",
|
|
args: [
|
|
vaultWethUsdc,
|
|
0, // new nft
|
|
amtDeposit, // +10 collateral
|
|
0, // 0 debt
|
|
dsaWallet0.address,
|
|
0,
|
|
setIdWethUsdc
|
|
],
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
|
|
expect(await wethToken.balanceOf(dsaWallet0.address)).to.lte(
|
|
parseEther("10")
|
|
);
|
|
});
|
|
|
|
// 10 weth
|
|
|
|
it("should deposit max Weth in Fluid", async function () {
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operate",
|
|
args: [
|
|
vaultWethUsdc,
|
|
0, // get id nft
|
|
ethers.constants.MaxUint256, // + max collateral
|
|
0, // 0 debt
|
|
dsaWallet0.address,
|
|
setIdWethUsdc,
|
|
0
|
|
],
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
|
|
expect(await ethers.provider.getBalance(dsaWallet0.address)).to.lte(
|
|
parseEther("1")
|
|
);
|
|
});
|
|
|
|
// 0 weth
|
|
|
|
it("Should borrow USDC from Fluid", async function () {
|
|
const amtBorrow = parseUnits("100", 6); // 100 USDC
|
|
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operate",
|
|
args: [
|
|
vaultMaticUsdc,
|
|
0, // nft id from getID
|
|
0, // 0 collateral
|
|
amtBorrow, // +100 debt
|
|
dsaWallet0.address,
|
|
setIdMaticUsdc,
|
|
0
|
|
],
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
await tx.wait();
|
|
|
|
expect(await usdcToken.balanceOf(dsaWallet0.address)).to.be.gte(
|
|
parseUnits("120", 6)
|
|
);
|
|
});
|
|
|
|
// 120 usdc
|
|
|
|
it("Should deposit WETH and borrow MATIC from Fluid", async function () {
|
|
await hre.network.provider.request({
|
|
method: "hardhat_impersonateAccount",
|
|
params: [wethHolder]
|
|
});
|
|
|
|
wethHolderSigner = await ethers.getSigner(wethHolder);
|
|
|
|
await wethToken.connect(wethHolderSigner).transfer(dsaWallet0.address, ethers.utils.parseEther("11"));
|
|
|
|
const amtDeposit = parseEther("10"); // 10 Weth
|
|
const amtBorrow = parseEther("100"); // 100 Matic
|
|
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operate",
|
|
args: [
|
|
vaultWethMatic,
|
|
0, // new nft id
|
|
amtDeposit, // 10 collateral
|
|
amtBorrow, // +100 debt
|
|
dsaWallet0.address,
|
|
0,
|
|
setId3
|
|
],
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
await tx.wait();
|
|
|
|
expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.gte(
|
|
parseEther("100")
|
|
);
|
|
});
|
|
|
|
// 120 usdc, 100 matic
|
|
|
|
it("Should payback Matic in Fluid", async function () {
|
|
const amtPayback = ethers.BigNumber.from(parseEther("50")).mul(-1); // 50 Matic
|
|
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operate",
|
|
args: [
|
|
vaultWethMatic,
|
|
0, // nft id from setId3
|
|
0, // 0 collateral
|
|
amtPayback, // - 50 debt
|
|
dsaWallet0.address,
|
|
setId3,
|
|
0
|
|
],
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
await tx.wait();
|
|
|
|
expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.lte(
|
|
ethers.utils.parseEther("50")
|
|
);
|
|
});
|
|
|
|
// 120 usdc, 50 matic
|
|
|
|
it("Should payback max Matic in Fluid", async function () {
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operate",
|
|
args: [
|
|
vaultWethMatic,
|
|
0, // nft id from setId3
|
|
0, // 0 collateral
|
|
ethers.constants.MinInt256, // min Int
|
|
dsaWallet0.address,
|
|
setId3,
|
|
0
|
|
],
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
await tx.wait();
|
|
|
|
expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.lte(
|
|
ethers.utils.parseEther("1")
|
|
);
|
|
});
|
|
|
|
// 120 usdc, 0 matic
|
|
|
|
it("Should payback Usdc in Fluid", async function () {
|
|
const amtPayback = ethers.BigNumber.from(parseUnits("60", 6)).mul(-1); // 60 usdc
|
|
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operate",
|
|
args: [
|
|
vaultMaticUsdc,
|
|
0, // nft id from setIdWethUsdc
|
|
0, // 0 collateral
|
|
amtPayback, // - 60 debt
|
|
dsaWallet0.address,
|
|
setIdMaticUsdc,
|
|
0
|
|
],
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
await tx.wait();
|
|
|
|
expect(await usdcToken.balanceOf(dsaWallet0.address)).to.be.lte(parseUnits("60", 6));
|
|
});
|
|
|
|
// 60 usdc, 0 matic
|
|
|
|
it("Should payback max Matic in Fluid", async function () {
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operate",
|
|
args: [
|
|
vaultMaticUsdc,
|
|
0, // nft id from setIdWethUsdc
|
|
0, // 0 collateral
|
|
ethers.constants.MinInt256, // min Int
|
|
dsaWallet0.address,
|
|
setIdMaticUsdc,
|
|
0
|
|
],
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
await tx.wait();
|
|
|
|
expect(await usdcToken.balanceOf(dsaWallet0.address)).to.be.lte(parseUnits("1", 6));
|
|
});
|
|
|
|
// 0 usdc, 0 matic
|
|
|
|
it("Should withdraw Matic from Fluid", async function () {
|
|
const amt = ethers.BigNumber.from(parseEther("100")).mul(-1); // 100 Matic
|
|
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operate",
|
|
args: [
|
|
vaultMaticUsdc,
|
|
0, // nft id from setIdMaticUsdc
|
|
amt, // - 100 collateral
|
|
0, // 0 debt
|
|
dsaWallet0.address,
|
|
setIdMaticUsdc,
|
|
0
|
|
],
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
|
|
expect(await ethers.provider.getBalance(dsaWallet0.address)).to.eq(
|
|
parseEther("100")
|
|
);
|
|
});
|
|
|
|
// 0 usdc, 100 matic
|
|
|
|
it("Should withdraw max Matic from Fluid", async function () {
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operate",
|
|
args: [
|
|
vaultMaticUsdc,
|
|
0, // nft id from setIdMaticUsdc
|
|
ethers.constants.MinInt256, // min integer value
|
|
0, // 0 debt
|
|
dsaWallet0.address,
|
|
setIdMaticUsdc,
|
|
0
|
|
],
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
|
|
expect(await ethers.provider.getBalance(dsaWallet0.address)).to.eq(
|
|
parseEther("1000")
|
|
);
|
|
});
|
|
|
|
// 0 usdc, 1000 matic
|
|
|
|
it("Should withdraw WETH from Fluid", async function () {
|
|
const amt = ethers.BigNumber.from(parseEther("10")).mul(-1); // 10 Weth
|
|
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operate",
|
|
args: [
|
|
vaultWethUsdc,
|
|
0, // nft id from setIdWethUsdc
|
|
amt, // -10 collateral
|
|
0, // 0 debt
|
|
dsaWallet0.address,
|
|
setIdWethUsdc,
|
|
0
|
|
],
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
|
|
expect(await wethToken.balanceOf(dsaWallet0.address)).to.eq(
|
|
parseEther("10")
|
|
);
|
|
});
|
|
|
|
// 0 usdc, 1000 matic, 10 weth
|
|
|
|
it("Should withdraw max WETH from Fluid", async function () {
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operate",
|
|
args: [
|
|
vaultWethUsdc,
|
|
0, // nft id from setIdWethUsdc
|
|
ethers.constants.MinInt256, // min integer value
|
|
0, // 0 debt
|
|
dsaWallet0.address,
|
|
setIdWethUsdc,
|
|
0
|
|
],
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
|
|
expect(await ethers.provider.getBalance(dsaWallet0.address)).to.eq(
|
|
parseEther("29")
|
|
);
|
|
});
|
|
|
|
// 0 usdc, 1000 matic, 30 weth
|
|
|
|
// todo: add a (payback and withdraw case)
|
|
});
|
|
});
|