mirror of
https://github.com/Instadapp/dsa-connectors.git
synced 2024-07-29 22:37:00 +00:00
555 lines
18 KiB
TypeScript
555 lines
18 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 { ConnectV3MorphoAaveV3__factory, IERC20Minimal__factory } from "../../../typechain";
|
|
import { parseEther, parseUnits } from "@ethersproject/units";
|
|
import { encodeSpells } from "../../../scripts/tests/encodeSpells";
|
|
import { dsaMaxValue, tokens } from "../../../scripts/tests/mainnet/tokens";
|
|
const { ethers } = hre;
|
|
import type { Signer, Contract } from "ethers";
|
|
|
|
const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'
|
|
const ACC_USDC = '0xe78388b4ce79068e89bf8aa7f218ef6b9ab0e9d0'
|
|
const Usdc = parseUnits('5000', 6)
|
|
|
|
const DAI = '0x6b175474e89094c44da98b954eedeac495271d0f'
|
|
const ACC_DAI = '0xcd6Eb888e76450eF584E8B51bB73c76ffBa21FF2'
|
|
const Dai = parseUnits('1', 18)
|
|
|
|
const WETH = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'
|
|
|
|
const user = "0x41bc7d0687e6cea57fa26da78379dfdc5627c56d"
|
|
|
|
const token_usdc = new ethers.Contract(
|
|
USDC,
|
|
IERC20Minimal__factory.abi,
|
|
ethers.provider,
|
|
)
|
|
|
|
const token_dai = new ethers.Contract(
|
|
DAI,
|
|
IERC20Minimal__factory.abi,
|
|
ethers.provider,
|
|
)
|
|
|
|
const token_weth = new ethers.Contract(
|
|
WETH,
|
|
IERC20Minimal__factory.abi,
|
|
ethers.provider,
|
|
)
|
|
|
|
describe("Morpho-Aave-v3", function () {
|
|
const connectorName = "MORPHO-AAVE-V3-TEST-A";
|
|
let connector: any;
|
|
|
|
let wallet0: Signer, wallet1:Signer;
|
|
let dsaWallet0: any;
|
|
let instaConnectorsV2: Contract;
|
|
let masterSigner: Signer;
|
|
|
|
before(async () => {
|
|
await hre.network.provider.request({
|
|
method: "hardhat_reset",
|
|
params: [
|
|
{
|
|
forking: {
|
|
// @ts-ignore
|
|
jsonRpcUrl: hre.config.networks.hardhat.forking.url,
|
|
// blockNumber: 15714501,
|
|
},
|
|
},
|
|
],
|
|
});
|
|
[wallet0, wallet1] = await ethers.getSigners();
|
|
masterSigner = await getMasterSigner();
|
|
instaConnectorsV2 = await ethers.getContractAt(
|
|
abis.core.connectorsV2,
|
|
addresses.core.connectorsV2
|
|
);
|
|
connector = await deployAndEnableConnector({
|
|
connectorName,
|
|
contractArtifact: ConnectV3MorphoAaveV3__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 1000 ETH into DSA wallet", async function () {
|
|
await wallet0.sendTransaction({
|
|
to: dsaWallet0.address,
|
|
value: parseEther("1000"),
|
|
});
|
|
expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.gte(
|
|
parseEther("1000")
|
|
);
|
|
});
|
|
|
|
it("Deposit 5000 USDC into DSA wallet", async function () {
|
|
|
|
await hre.network.provider.request({
|
|
method: 'hardhat_impersonateAccount',
|
|
params: [ACC_USDC],
|
|
})
|
|
|
|
const signer_usdc = await ethers.getSigner(ACC_USDC)
|
|
await token_usdc.connect(signer_usdc).transfer(wallet0.getAddress(), Usdc)
|
|
|
|
await hre.network.provider.request({
|
|
method: 'hardhat_stopImpersonatingAccount',
|
|
params: [ACC_USDC],
|
|
})
|
|
|
|
await token_usdc.connect(wallet0).transfer(dsaWallet0.address, Usdc);
|
|
|
|
expect(await token_usdc.connect(masterSigner).balanceOf(dsaWallet0.address)).to.be.gte(
|
|
parseUnits('5000', 6)
|
|
);
|
|
});
|
|
|
|
// it("Deposit 1 DAI into DSA wallet", async function () {
|
|
|
|
// await hre.network.provider.request({
|
|
// method: 'hardhat_impersonateAccount',
|
|
// params: [ACC_DAI],
|
|
// })
|
|
|
|
// const signer_dai = await ethers.getSigner(ACC_DAI)
|
|
// await token_dai.connect(signer_dai).transfer(wallet0.getAddress(), Dai)
|
|
|
|
// await hre.network.provider.request({
|
|
// method: 'hardhat_stopImpersonatingAccount',
|
|
// params: [ACC_DAI],
|
|
// })
|
|
|
|
// await token_dai.connect(wallet0).transfer(dsaWallet0.address, Dai);
|
|
|
|
// expect(await token_dai.connect(masterSigner).balanceOf(dsaWallet0.address)).to.be.gte(
|
|
// parseUnits('1', 18)
|
|
// );
|
|
// });
|
|
});
|
|
|
|
describe("Main", function () {
|
|
|
|
it("Should deposit 10 ETH", async function () {
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "deposit",
|
|
args: [tokens.eth.address, "10000000000000000000", "0", "0"], // 10 ETH
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
expect(expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.lte(
|
|
parseUnits('990', 18))
|
|
);
|
|
})
|
|
|
|
it("Should deposit 1 ETH with MaxIteration", async function () {
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "depositWithMaxIterations",
|
|
args: [tokens.eth.address, "1000000000000000000", 5, "0", "0"], // 1 ETH
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
expect(expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.lte(
|
|
parseUnits('989', 18))
|
|
);
|
|
})
|
|
|
|
it("Should deposit 10 ETH on behalf", async function () {
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "depositOnBehalf",
|
|
args: [tokens.eth.address, "10000000000000000000", user, "0", "0"], // 1 ETH
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
expect(expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.lte(
|
|
parseUnits('979', 18))
|
|
);
|
|
})
|
|
|
|
it("Should deposit 1 ETH on behalf with MaxIteration", async function () {
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "depositOnBehalfWithMaxIterations",
|
|
args: [tokens.eth.address, "1000000000000000000", user, 5, "0", "0"], // 1 ETH
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
expect(expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.lte(
|
|
parseUnits('978', 18))
|
|
);
|
|
})
|
|
|
|
it("Should deposit 2000 USDC as collateral", async function () {
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "depositCollateral",
|
|
args: [tokens.usdc.address, "2000000000", "0", "0"], // 50 USDC
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
expect(await token_usdc.connect(wallet0).balanceOf(dsaWallet0.address)).to.be.lte(
|
|
parseUnits('3000', 6)
|
|
);
|
|
})
|
|
|
|
it("Should deposit 2000 USDC as collateral on behalf", async function () {
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "depositCollateralOnBehalf",
|
|
args: [tokens.usdc.address, "2000000000", user, "0", "0"], // 50 USDC
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
expect(await token_usdc.connect(wallet0).balanceOf(dsaWallet0.address)).to.be.lte(
|
|
parseUnits('1000', 6)
|
|
);
|
|
})
|
|
|
|
it("Should withdraw 10 ETH", async function () {
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "withdraw",
|
|
args: [tokens.eth.address, "10000000000000000000", dsaWallet0.address, "0", "0"], // 10 ETH
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
expect(expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.gte(
|
|
parseUnits('978', 18))
|
|
);
|
|
})
|
|
|
|
it("Should withdraw ETH max on behalf", async function () {
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "withdrawOnBehalf",
|
|
args: [tokens.eth.address, dsaMaxValue, dsaWallet0.address, user, "0", "0"], // Max ETH
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
console.log("------------user balance----------",(await token_weth.balanceOf(user)).toString())
|
|
expect(await token_weth.balanceOf(user)).to.be.gte(parseUnits('1', 18))
|
|
})
|
|
|
|
it("Should borrow WETH into DSA", async function () {
|
|
const balance = await token_weth.balanceOf(dsaWallet0.address);
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "borrow",
|
|
args: [tokens.weth.address, "500000000000000000", dsaWallet0.address, "0", "0"], // 0.7 WETH
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
console.log("====================", balance.toString(), (await token_weth.balanceOf(dsaWallet0.address)).toString())
|
|
expect((await token_weth.balanceOf(dsaWallet0.address)).sub(balance))
|
|
.to.be.eq(parseUnits('5', 17));
|
|
})
|
|
|
|
it("Should borrow WETH into user", async function () {
|
|
const balance = await token_weth.balanceOf(user);
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "borrowOnBehalf",
|
|
args: [tokens.weth.address, "200000000000000000", dsaWallet0.address, user, "0", "0"], // 0.7 WETH
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
console.log("====================", balance.toString(), (await token_weth.balanceOf(user)).toString())
|
|
expect((await token_weth.balanceOf(user)).sub(balance))
|
|
.to.be.eq(parseUnits('2', 17));
|
|
})
|
|
|
|
it("Should borrow WETH into wallet1 using iteration", async function () {
|
|
const balance = await token_weth.balanceOf(dsaWallet0.address);
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "borrowWithMaxIterations",
|
|
args: [tokens.weth.address, "200000000000000000", dsaWallet0.address, 10, "0", "0"], // 0.7 WETH
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
console.log("====================", balance.toString(), (await token_weth.balanceOf(dsaWallet0.address)).toString())
|
|
expect((await token_weth.balanceOf(dsaWallet0.address)).sub(balance))
|
|
.to.be.eq(parseUnits('2', 17));
|
|
})
|
|
|
|
// it("Should borrow DAI into DSA on behalf", async function () {
|
|
// const spells = [
|
|
// {
|
|
// connector: connectorName,
|
|
// method: "borrowOnBehalf",
|
|
// args: [tokens.dai.address, "10000000000000000000", user, dsaWallet0.address, "0", "0"], // 10 DAI
|
|
// },
|
|
// ];
|
|
|
|
// const tx = await dsaWallet0
|
|
// .connect(wallet0)
|
|
// .cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
// await tx.wait();
|
|
// expect(await token_dai.connect(masterSigner).balanceOf(dsaWallet0.address))
|
|
// .to.be.gte(parseUnits('21', 18));
|
|
// })
|
|
|
|
// it("Should borrow DAI into DSA with MaxIteration", async function () {
|
|
// const spells = [
|
|
// {
|
|
// connector: connectorName,
|
|
// method: "borrowWithMaxIterations",
|
|
// args: [tokens.dai.address, "10000000000000000000", dsaWallet0.address, 5, "0", "0"], // 10 DAI
|
|
// },
|
|
// ];
|
|
|
|
// const tx = await dsaWallet0
|
|
// .connect(wallet0)
|
|
// .cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
// await tx.wait();
|
|
// expect(await token_dai.connect(masterSigner).balanceOf(dsaWallet0.address))
|
|
// .to.be.gte(parseUnits('31', 18));
|
|
// })
|
|
|
|
// it("Should borrow DAI into DSA on behalf with MaxIteration", async function () {
|
|
// const spells = [
|
|
// {
|
|
// connector: connectorName,
|
|
// method: "borrowOnBehalfWithMaxIterations",
|
|
// args: [tokens.dai.address, "10000000000000000000", user, dsaWallet0.address, 5, "0", "0"], // 10 DAI
|
|
// },
|
|
// ];
|
|
|
|
// const tx = await dsaWallet0
|
|
// .connect(wallet0)
|
|
// .cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
// await tx.wait();
|
|
// expect(await token_dai.connect(masterSigner).balanceOf(dsaWallet0.address))
|
|
// .to.be.gte(parseUnits('41', 18));
|
|
// })
|
|
|
|
// it("Should payback DAI MAX", async function () {
|
|
// const spells = [
|
|
// {
|
|
// connector: connectorName,
|
|
// method: "payback",
|
|
// args: [tokens.dai.address, dsaMaxValue, "0", "0"], // Max DAI
|
|
// },
|
|
// ];
|
|
|
|
// const tx = await dsaWallet0
|
|
// .connect(wallet0)
|
|
// .cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
// await tx.wait();
|
|
// expect(await token_dai.connect(masterSigner).balanceOf(dsaWallet0.address)).to.be.lte(
|
|
// parseUnits('1', 18)
|
|
// );
|
|
// })
|
|
|
|
// it("Should payback ETH on behalf", async function () {
|
|
// const spells = [
|
|
// {
|
|
// connector: connectorName,
|
|
// method: "paybackOnBehalf",
|
|
// args: [tokens.eth.address, user, dsaMaxValue, "0", "0"], // Max ETH
|
|
// },
|
|
// ];
|
|
|
|
// const tx = await dsaWallet0
|
|
// .connect(wallet0)
|
|
// .cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
// await tx.wait();
|
|
// expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.lte(
|
|
// parseUnits('125', 18)
|
|
// );
|
|
// })
|
|
|
|
// it("Should withdraw 8 USDC on behalf", async function () {
|
|
// const spells = [
|
|
// {
|
|
// connector: connectorName,
|
|
// method: "withdrawOnBehalf",
|
|
// args: [tokens.usdc.address, "8000000", user, dsaWallet0.address, "0", "0"], // 8 USDC
|
|
// },
|
|
// ];
|
|
|
|
// const tx = await dsaWallet0
|
|
// .connect(wallet0)
|
|
// .cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
// await tx.wait();
|
|
// console.log("----balance of USDC----", (await token_usdc.connect(wallet0).balanceOf(dsaWallet0.address)).toString())
|
|
// // expect(expect(await token_usdc.connect(wallet0).balanceOf(dsaWallet0.address)).to.be.gte(
|
|
// // parseUnits('398', 6))
|
|
// // );
|
|
// })
|
|
|
|
// it("Should withdraw 8 USDC on behalf", async function () {
|
|
// const spells = [
|
|
// {
|
|
// connector: connectorName,
|
|
// method: "withdrawOnBehalf",
|
|
// args: [tokens.usdc.address, "8000000", user, dsaWallet0.address, "0", "0"], // 8 USDC
|
|
// },
|
|
// ];
|
|
|
|
// const tx = await dsaWallet0
|
|
// .connect(wallet0)
|
|
// .cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
// await tx.wait();
|
|
// console.log("----balance of USDC----", (await token_usdc.connect(wallet0).balanceOf(dsaWallet0.address)).toString())
|
|
// // expect(expect(await token_usdc.connect(wallet0).balanceOf(dsaWallet0.address)).to.be.gte(
|
|
// // parseUnits('398', 6))
|
|
// // );
|
|
// })
|
|
|
|
// it("Should withdraw 8 USDC on behalf with MaxIteration", async function () {
|
|
// const spells = [
|
|
// {
|
|
// connector: connectorName,
|
|
// method: "withdrawWithMaxIterations",
|
|
// args: [tokens.usdc.address, "8000000", user, dsaWallet0.address, 5, "0", "0"], // 8 USDC
|
|
// },
|
|
// ];
|
|
|
|
// const tx = await dsaWallet0
|
|
// .connect(wallet0)
|
|
// .cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
// await tx.wait();
|
|
// console.log("----balance of USDC----", (await token_usdc.connect(wallet0).balanceOf(dsaWallet0.address)).toString())
|
|
// // expect(expect(await token_usdc.connect(wallet0).balanceOf(dsaWallet0.address)).to.be.gte(
|
|
// // parseUnits('398', 6))
|
|
// // );
|
|
// })
|
|
|
|
// it("Should withdraw 8 USDC as collateral", async function () {
|
|
// const spells = [
|
|
// {
|
|
// connector: connectorName,
|
|
// method: "withdrawCollateral",
|
|
// args: [tokens.usdc.address, "8000000", dsaWallet0.address, 5, "0", "0"], // 8 USDC
|
|
// },
|
|
// ];
|
|
|
|
// const tx = await dsaWallet0
|
|
// .connect(wallet0)
|
|
// .cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
// await tx.wait();
|
|
// console.log("----balance of USDC----", (await token_usdc.connect(wallet0).balanceOf(dsaWallet0.address)).toString())
|
|
// // expect(expect(await token_usdc.connect(wallet0).balanceOf(dsaWallet0.address)).to.be.gte(
|
|
// // parseUnits('398', 6))
|
|
// // );
|
|
// })
|
|
|
|
// it("Should withdraw 8 USDC as collateral on behalf", async function () {
|
|
// const spells = [
|
|
// {
|
|
// connector: connectorName,
|
|
// method: "withdrawCollateralOnBehalf",
|
|
// args: [tokens.usdc.address, "8000000",user, dsaWallet0.address, 5, "0", "0"], // 8 USDC
|
|
// },
|
|
// ];
|
|
|
|
// const tx = await dsaWallet0
|
|
// .connect(wallet0)
|
|
// .cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
// await tx.wait();
|
|
// console.log("----balance of USDC----", (await token_usdc.connect(wallet0).balanceOf(dsaWallet0.address)).toString())
|
|
// // expect(expect(await token_usdc.connect(wallet0).balanceOf(dsaWallet0.address)).to.be.gte(
|
|
// // parseUnits('398', 6))
|
|
// // );
|
|
// })
|
|
});
|
|
});
|