From c89f153822907a15e9c29159119090ab1efa1794 Mon Sep 17 00:00:00 2001 From: q1q0 Date: Mon, 27 Feb 2023 03:45:06 -0500 Subject: [PATCH] add morpho aave v3 --- test/mainnet/morpho/morpho-aave-v3.test.ts | 505 +++++++++++++++++++++ 1 file changed, 505 insertions(+) create mode 100644 test/mainnet/morpho/morpho-aave-v3.test.ts diff --git a/test/mainnet/morpho/morpho-aave-v3.test.ts b/test/mainnet/morpho/morpho-aave-v3.test.ts new file mode 100644 index 00000000..7ee1edbf --- /dev/null +++ b/test/mainnet/morpho/morpho-aave-v3.test.ts @@ -0,0 +1,505 @@ +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('500', 6) + +const DAI = '0x6b175474e89094c44da98b954eedeac495271d0f' +const ACC_DAI = '0xcd6Eb888e76450eF584E8B51bB73c76ffBa21FF2' +const Dai = parseUnits('1', 18) + +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, +) + +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 500 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('500', 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 10 USDC", async function () { + const spells = [ + { + connector: connectorName, + method: "deposit", + args: [tokens.usdc.address, "10000000", "0", "0"], // 10 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('490', 6) + ); + }) + + it("Should deposit 100 USDC with MaxIteration", async function () { + const spells = [ + { + connector: connectorName, + method: "depositWithMaxIterations", + args: [tokens.usdc.address, "100000000", 5, "0", "0"], // 100 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('390', 6) + ); + }) + + it("Should deposit 100 USDC on behalf", async function () { + const spells = [ + { + connector: connectorName, + method: "depositOnBehalf", + args: [tokens.usdc.address, "100000000", user, "0", "0"], // 100 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('290', 6) + ); + }) + + it("Should deposit 100 USDC on behalf with MaxIteration", async function () { + const spells = [ + { + connector: connectorName, + method: "depositOnBehalfWithMaxIterations", + args: [tokens.usdc.address, "100000000", user, 5, "0", "0"], // 100 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('190', 6) + ); + }) + + it("Should deposit 100 USDC as collateral", async function () { + const spells = [ + { + connector: connectorName, + method: "depositCollateral", + args: [tokens.usdc.address, "50000000", "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('140', 6) + ); + }) + + it("Should deposit 100 USDC as collateral on behalf", async function () { + const spells = [ + { + connector: connectorName, + method: "depositCollateralOnBehalf", + args: [tokens.usdc.address, "50000000", 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('90', 6) + ); + }) + + it("Should borrow DAI into DSA", async function () { + const spells = [ + { + connector: connectorName, + method: "borrow", + args: [tokens.dai.address, "10000000000000000000", 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('11', 18)); + }) + + 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 ETH max", async function () { + const spells = [ + { + connector: connectorName, + method: "withdraw", + args: [tokens.eth.address, dsaMaxValue, dsaWallet0.address, "0", "0"], // Max 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('134', 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)) + // ); + }) + }); +});