mirror of
https://github.com/Instadapp/dsa-connectors-2.0.git
synced 2024-07-29 21:57:39 +00:00
716 lines
20 KiB
TypeScript
716 lines
20 KiB
TypeScript
import { expect } from "chai";
|
|
import hre from "hardhat";
|
|
import { abis } from "../../../scripts/constant/abis";
|
|
import { addresses } from "../../../scripts/tests/polygon/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";
|
|
import { BigNumber } from "bignumber.js";
|
|
|
|
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 setId4 = "55478249";
|
|
|
|
const vaultMaticUsdc = "0xAf047A21CE590B36FE894dd6fa350b57Ea5Cb0aa";
|
|
const vaultWethUsdc = "0xEad5D80db075a905c141b37cE903d621952eA3f6";
|
|
const vaultWethMatic = "0x23918014AF7610e31e58A9DC9f9A7DdbfcA4087e";
|
|
const vaultUsdcMatic = "0x6395Ddb6161CeF6e64D4c027fbBa26CC76F18148";
|
|
|
|
const wethHolder = "0xdeD8C5159CA3673f543D0F72043E4c655b35b96A";
|
|
const usdcHolder = "0xA67EFB69A4f58F568aAB1b9d51110102985835b0";
|
|
|
|
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: 53327050,
|
|
},
|
|
},
|
|
],
|
|
});
|
|
|
|
[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.connect(wethHolderSigner).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.connect(usdcHolderSigner).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 in MATIC-USDC", async function () {
|
|
const amtDeposit = parseEther("1000");
|
|
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operateWithIds",
|
|
args: [
|
|
vaultMaticUsdc,
|
|
'0', // new nft
|
|
amtDeposit, // +1000 collateral
|
|
'0', // 0 debt
|
|
'0',
|
|
['0', '0', '0', '0', '0'],
|
|
[setIdMaticUsdc, '0', '0', '0', '0'] // set NFT ID of position
|
|
],
|
|
},
|
|
];
|
|
|
|
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, 20 weth, 20 usdc
|
|
|
|
it("should deposit max Matic in Fluid in MATIC-USDC", async function () {
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operateWithIds",
|
|
args: [
|
|
vaultMaticUsdc, // matic-usdc vault
|
|
0, // NFT ID from setIdMaticUsdc
|
|
ethers.constants.MaxInt256, // + max collateral
|
|
0, // 0 debt
|
|
0,
|
|
[setIdMaticUsdc, '0', '0', '0', '0'],
|
|
[setIdMaticUsdc, '0', '0', '0', '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, 20 weth, 20 usdc
|
|
|
|
it("should deposit 9 Weth in Fluid in WETH-USDC", async function () {
|
|
const amtDeposit = parseEther("9");
|
|
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operateWithIds",
|
|
args: [
|
|
vaultWethUsdc,
|
|
0, // New nft for WETH-USDC market
|
|
amtDeposit, // +10 collateral
|
|
0, // 0 debt
|
|
0, // 0 repay
|
|
['0', '0', '0', '0', '0'],
|
|
[setIdWethUsdc, '0', '0', '0', '0']
|
|
],
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
|
|
expect(await wethToken.connect(wallet0).balanceOf(dsaWallet0.address)).to.lte(
|
|
parseEther("11")
|
|
);
|
|
});
|
|
|
|
// // 0 matic, 11 weth, 20 usdc
|
|
|
|
it("should deposit max Weth in Fluid in WETH-USDC", async function () {
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operateWithIds",
|
|
args: [
|
|
vaultWethUsdc,
|
|
0, // get nft id
|
|
ethers.constants.MaxInt256, // + max collateral
|
|
0, // 0 debt
|
|
0,
|
|
[setIdWethUsdc, '0', '0', '0', '0'],
|
|
[setIdWethUsdc, '0', '0', '0', '0']
|
|
],
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
|
|
expect(await wethToken.connect(wallet0).balanceOf(dsaWallet0.address)).to.lte(
|
|
parseEther("1")
|
|
);
|
|
});
|
|
|
|
// // 0 matic, 0 weth, 20 usdc
|
|
|
|
it("should deposit 10 USDC in Fluid in USDC-MATIC", async function () {
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operate",
|
|
args: [
|
|
vaultUsdcMatic,
|
|
0, // get nft id
|
|
parseUnits("10", 6), // + max collateral
|
|
0, // 0 debt
|
|
0
|
|
],
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
|
|
expect(await usdcToken.connect(wallet0).balanceOf(dsaWallet0.address)).to.lte(
|
|
parseEther("10")
|
|
);
|
|
});
|
|
|
|
// // 0 matic, 0 weth, 10 usdc
|
|
|
|
it("Should borrow 0.1 USDC from Fluid in WETH-USDC", async function () {
|
|
const amtBorrow = parseUnits("0.1", 6); // 0.1 USDC
|
|
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operateWithIds",
|
|
args: [
|
|
vaultWethUsdc,
|
|
0, // nft ID from getID
|
|
0, // 0 collateral
|
|
amtBorrow, // +0.1 debt
|
|
0,
|
|
[setIdWethUsdc, '0', '0', '0', '0'],
|
|
[setIdWethUsdc, '0', '0', '0', '0']
|
|
],
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
await tx.wait();
|
|
|
|
expect(await usdcToken.connect(wallet0).balanceOf(dsaWallet0.address)).to.gte(
|
|
parseUnits("10", 6)
|
|
);
|
|
});
|
|
|
|
// // 0 matic, 0 weth, 10.1 usdc
|
|
|
|
it("Should deposit 5 WETH and borrow 0.1 MATIC from Fluid in WETH-MATIC", 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("10"));
|
|
|
|
const amtDeposit = parseEther("5"); // 5 Weth
|
|
const amtBorrow = parseEther("0.1"); // 100 Matic
|
|
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operateWithIds",
|
|
args: [
|
|
vaultWethMatic,
|
|
0, // new nft id
|
|
amtDeposit, // 10 collateral
|
|
amtBorrow, // +100 debt
|
|
0,
|
|
['0', '0', '0', '0', '0'],
|
|
[setId3, '0', '0', '0', '0']
|
|
],
|
|
},
|
|
];
|
|
|
|
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("0.099")
|
|
);
|
|
|
|
expect(await wethToken.connect(wallet0).balanceOf(dsaWallet0.address)).to.lte(
|
|
parseEther("6")
|
|
);
|
|
});
|
|
|
|
// // 0.1 matic, 5 weth, 10.1 usdc
|
|
|
|
it("Should deposit 5 WETH and borrow 0.1 MATIC from Fluid in WETH-MATIC", 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("10"));
|
|
|
|
const amtDeposit = parseEther("5"); // 5 Weth
|
|
const amtBorrow = parseEther("0.1"); // 0.1 Matic
|
|
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operateWithIds",
|
|
args: [
|
|
vaultWethMatic,
|
|
0, // new nft id
|
|
amtDeposit, // 10 collateral
|
|
amtBorrow, // +0.1 debt
|
|
0,
|
|
['0', '0', '0', '0', '0'],
|
|
[setId4, '0', '0', '0', '0']
|
|
],
|
|
},
|
|
];
|
|
|
|
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("0.19")
|
|
);
|
|
|
|
expect(await wethToken.connect(wallet0).balanceOf(dsaWallet0.address)).to.lte(
|
|
parseEther("11")
|
|
);
|
|
});
|
|
|
|
// // 0.2 matic, 10 weth, 10.1 usdc
|
|
|
|
it("Should payback 0.04 Matic in Fluid in WETH-MATIC", async function () {
|
|
const amtPayback = new BigNumber(parseEther("0.04").toString()).multipliedBy(-1); // 0.04 Matic
|
|
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operateWithIds",
|
|
args: [
|
|
vaultWethMatic,
|
|
0, // nft id from setId3
|
|
0, // 0 collateral
|
|
amtPayback, // - 0.04 debt
|
|
new BigNumber(parseEther("0.04").toString()),
|
|
[setId3, '0', '0', '0', '0'],
|
|
[setId3, '0', '0', '0', '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("0.2")
|
|
);
|
|
});
|
|
|
|
// // 0.16 matic, 10 weth, 10.1 usdc
|
|
|
|
// it("Should payback max Matic in Fluid in WETH-MATIC", async function () {
|
|
// await wallet0.sendTransaction({
|
|
// to: dsaWallet0.address,
|
|
// value: parseEther("1"),
|
|
// });
|
|
|
|
// const spells = [
|
|
// {
|
|
// connector: connectorName,
|
|
// method: "operateWithIds",
|
|
// args: [
|
|
// vaultWethMatic,
|
|
// 0, // nft id from setId3
|
|
// 0, // 0 collateral
|
|
// ethers.constants.MinInt256, // min Int
|
|
// new BigNumber(parseEther("0.7").toString()),
|
|
// [setId3, '0', '0', '0', '0'],
|
|
// ['0', '0', '0', '0', '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("0.97")
|
|
// // );
|
|
// });
|
|
|
|
// // 0.96 matic, 10 weth, 10.1 usdc
|
|
|
|
it("Should payback 0.05 Usdc in Fluid in WETH-USDC", async function () {
|
|
const amtPayback = new BigNumber(parseUnits("0.05", 6).toString()).multipliedBy(-1); // 0.05 usdc
|
|
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operateWithIds",
|
|
args: [
|
|
vaultWethUsdc,
|
|
0, // nft id from setIdWethUsdc
|
|
0, // 0 collateral
|
|
amtPayback, // - 0.05 debt
|
|
new BigNumber(parseUnits("0.05", 6).toString()),
|
|
[setIdWethUsdc, '0', '0', '0', '0'],
|
|
[setIdWethUsdc, '0', '0', '0', '0']
|
|
],
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
await tx.wait();
|
|
|
|
expect(await usdcToken.connect(wallet0).balanceOf(dsaWallet0.address)).to.be.lte(parseUnits("10.05", 6));
|
|
});
|
|
|
|
// // 0.96 matic, 10 weth, 10.05 usdc
|
|
|
|
it("Should withdraw 100 Matic from Fluid in MATIC-USDC", async function () {
|
|
const amt = new BigNumber(parseEther("100").toString()).multipliedBy(-1); // 100 Matic
|
|
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operateWithIds",
|
|
args: [
|
|
vaultMaticUsdc,
|
|
0, // nft id from setIdMaticUsdc
|
|
amt, // - 100 collateral
|
|
0, // 0 debt
|
|
0,
|
|
[setIdMaticUsdc, '0', '0', '0', '0'],
|
|
[setIdMaticUsdc, '0', '0', '0', '0']
|
|
],
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
|
|
expect(await ethers.provider.getBalance(dsaWallet0.address)).to.gte(
|
|
parseEther("100")
|
|
);
|
|
});
|
|
|
|
// // 100.96 matic, 10 weth, 10.05 usdc
|
|
|
|
// it("Should withdraw max Matic from Fluid in MATIC-USDC", async function () {
|
|
// const spells = [
|
|
// {
|
|
// connector: connectorName,
|
|
// method: "operateWithIds",
|
|
// args: [
|
|
// vaultMaticUsdc,
|
|
// 0, // nft id from setIdMaticUsdc
|
|
// ethers.constants.MinInt256, // min integer value
|
|
// 0, // 0 debt
|
|
// 0,
|
|
// [setIdMaticUsdc, '0', '0', '0', '0'],
|
|
// ['0', '0', '0', '0', '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("2000")
|
|
// );
|
|
// });
|
|
|
|
// // 2000.96 matic, 10 weth, 10.05 usdc
|
|
|
|
it("Should withdraw 0.4 WETH from Fluid in WETH-USDC", async function () {
|
|
const amt = new BigNumber(parseEther("0.4").toString()).multipliedBy(-1); // 1 Weth
|
|
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operateWithIds",
|
|
args: [
|
|
vaultWethUsdc,
|
|
0, // nft id from setIdWethUsdc
|
|
amt, // -1 collateral
|
|
0, // 0 debt
|
|
0,
|
|
[setIdWethUsdc, '0', '0', '0', '0'],
|
|
[setIdWethUsdc, '0', '0', '0', '0']
|
|
],
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
|
|
// expect(await wethToken.connect(wallet0).balanceOf(dsaWallet0.address)).to.gte(
|
|
// parseEther("11")
|
|
// );
|
|
});
|
|
|
|
// // 2000.96 matic, 11 weth, 10.05 usdc
|
|
|
|
it("Should payback 0.02 and withdraw 0.5 WETH from Fluid in WETH-USDC", async function () {
|
|
const amt = new BigNumber(parseEther("0.5").toString()).multipliedBy(-1); // 1 Weth
|
|
const paybackAmt = new BigNumber(parseUnits("0.02", 6).toString()).multipliedBy(-1); // 1 Weth
|
|
|
|
const spells = [
|
|
{
|
|
connector: connectorName,
|
|
method: "operateWithIds",
|
|
args: [
|
|
vaultWethUsdc,
|
|
0, // nft id from setIdWethUsdc
|
|
amt, // -1 collateral
|
|
paybackAmt, // 0 debt
|
|
new BigNumber(parseUnits("0.03", 6).toString()),
|
|
[setIdWethUsdc, '0', '0', '0', '0'],
|
|
[setIdWethUsdc, '0', '0', '0', '0']
|
|
],
|
|
},
|
|
];
|
|
|
|
const tx = await dsaWallet0
|
|
.connect(wallet0)
|
|
.cast(...encodeSpells(spells), wallet1.getAddress());
|
|
|
|
await tx.wait();
|
|
|
|
// expect(await wethToken.connect(wallet0).balanceOf(dsaWallet0.address)).to.gte(
|
|
// parseEther("12")
|
|
// );
|
|
|
|
// expect(await usdcToken.connect(wallet0).balanceOf(dsaWallet0.address)).to.gte(
|
|
// parseEther("11")
|
|
// );
|
|
});
|
|
|
|
// todo: add a (payback and withdraw case)
|
|
});
|
|
});
|