Instadapp/dsa-connectors
1
0
Fork 0
mirror of https://github.com/Instadapp/dsa-connectors.git synced 2024-07-29 22:37:00 +00:00
Code Issues Packages Projects Releases Wiki Activity
b7002335b7
dsa-connectors/test/mainnet/morpho/morpho-aave-v3.test.ts

515 lines
17 KiB
TypeScript
Raw Blame History

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 { ConnectV2MorphoAaveV3__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";
import morpho_ABI from './morpho-abi.json'
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: 17544460
}
}
]
});
[wallet0, wallet1] = await ethers.getSigners();
masterSigner = await getMasterSigner();
instaConnectorsV2 = await ethers.getContractAt(abis.core.connectorsV2, addresses.core.connectorsV2);
connector = await deployAndEnableConnector({
connectorName,
contractArtifact: ConnectV2MorphoAaveV3__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 collateral 2000 USDC", 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 collateral 2000 USDC on behalf with maxValue", async function () {
// const spells = [
// {
// connector: connectorName,
// method: "depositCollateralOnBehalf",
// args: [tokens.usdc.address, dsaMaxValue, user, "0", "0"], // ~3000 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('1', 6)
// );
// })
// it("Should withdraw 10 ETH", async function () {
// const spells = [
// {
// connector: connectorName,
// method: "withdraw",
// 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.gte(
// parseUnits('978', 18))
// );
// })
// it("Should withdraw on behalf of user with maxValue", async function () {
// let ethBala = await ethers.provider.getBalance(user)
// let wethBala = await token_weth.balanceOf(user)
// 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();
// ethBala = await ethers.provider.getBalance(user)
// wethBala = await token_weth.balanceOf(user)
// })
// 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", "0", "0"], // 0.5 WETH
// },
// ];
// const tx = await dsaWallet0
// .connect(wallet0)
// .cast(...encodeSpells(spells), wallet1.getAddress());
// await tx.wait();
// 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();
// 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, "20000000000000000", dsaWallet0.address, 10, "0", "0"], // 0.02 WETH
// },
// ];
// const tx = await dsaWallet0
// .connect(wallet0)
// .cast(...encodeSpells(spells), wallet1.getAddress());
// await tx.wait();
// expect((await token_weth.balanceOf(dsaWallet0.address)).sub(balance))
// .to.be.eq(parseUnits('2', 16));
// })
// it("Test withdrawCollateral ", 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(dsaWallet0.address, parseUnits('500', 6))
// await hre.network.provider.request({
// method: 'hardhat_stopImpersonatingAccount',
// params: [ACC_USDC],
// })
// expect(await token_usdc.connect(masterSigner).balanceOf(dsaWallet0.address)).to.be.gte(
// parseUnits('500', 6)
// );
// const balance = await token_usdc.balanceOf(dsaWallet0.address);
// console.log('balance: ', balance.toString());
// const spells = [
// {
// connector: connectorName,
// method: "depositCollateral",
// args: [tokens.usdc.address, "20000000", "0", "0"], // 20 USDC
// },
// {
// connector: connectorName,
// method: "withdrawCollateral",
// args: [tokens.usdc.address, "19000000", dsaWallet0.address, "0", "0"], // 19 USDC
// },
// ];
// const tx = await dsaWallet0
// .connect(wallet0)
// .cast(...encodeSpells(spells), wallet1.getAddress());
// await tx.wait();
// })
it("Test withdrawCollateralOnBehalf with maxValue", 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(dsaWallet0.address, parseUnits("500", 6));
await hre.network.provider.request({
method: "hardhat_stopImpersonatingAccount",
params: [ACC_USDC]
});
await hre.network.provider.request({
method: "hardhat_impersonateAccount",
params: [user]
});
const signer_user = await ethers.getSigner(user);
const mophor = new ethers.Contract(
"0x33333aea097c193e66081E930c33020272b33333",
morpho_ABI,
ethers.provider
);
await mophor.connect(signer_user).approveManager(dsaWallet0.address, true)
await hre.network.provider.request({
method: "hardhat_stopImpersonatingAccount",
params: [user]
});
expect(await token_usdc.connect(masterSigner).balanceOf(dsaWallet0.address)).to.be.gte(parseUnits("500", 6));
const balance = await token_usdc.balanceOf(dsaWallet0.address);
const spells = [
{
connector: connectorName,
method: "depositCollateralOnBehalf",
args: [tokens.usdc.address, "20000000", user, "0", "0"] // 20 USDC
},
// {
// connector: connectorName,
// method: "approveManager",
// args: [user, true] // 20 USDC
// },
{
connector: connectorName,
method: "withdrawCollateralOnBehalf",
args: [tokens.usdc.address, dsaMaxValue, user, user, "0", "0"] // 20 USDC
}
];
const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet1.getAddress());
await tx.wait();
expect(await token_usdc.connect(masterSigner).balanceOf(dsaWallet0.address)).to.be.gte(parseUnits("499", 6));
});
it("Test payback with maxValue", 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(dsaWallet0.address, parseUnits('500', 6))
await hre.network.provider.request({
method: 'hardhat_stopImpersonatingAccount',
params: [ACC_USDC],
})
expect(await token_usdc.connect(masterSigner).balanceOf(dsaWallet0.address)).to.be.gte(
parseUnits('500', 6)
);
const balance = await token_usdc.balanceOf(dsaWallet0.address);
const spells = [
{
connector: connectorName,
method: "depositCollateral",
args: [tokens.usdc.address, "200000000", "0", "0"], // 2 ETH
},
{
connector: connectorName,
method: "borrow",
args: [tokens.eth.address, "1000000000000000", "0", "0"], // 20 USDC
},
{
connector: connectorName,
method: "payback",
args: [tokens.eth.address, dsaMaxValue, "0", "0"], // 20 USDC
},
];
const tx = await dsaWallet0
.connect(wallet0)
.cast(...encodeSpells(spells), wallet1.getAddress());
await tx.wait();
expect(await token_usdc.connect(masterSigner).balanceOf(dsaWallet0.address)).to.be.gte(
parseUnits('499', 6)
);
})
// it("approve manger", async () => {
// const spells = [
// {
// connector: connectorName,
// method: "approveManager",
// args: [user, true],
// },
// ]
// const tx = await dsaWallet0
// .connect(wallet0)
// .cast(...encodeSpells(spells), wallet1.getAddress());
// await tx.wait();
// })
});
});
Reference in New Issue View Git Blame Copy Permalink