From 2d594b0ad717cc97ad3c9005629ccdee91f8cbb8 Mon Sep 17 00:00:00 2001 From: pradyuman-verma Date: Mon, 6 Dec 2021 05:44:38 +0530 Subject: [PATCH] updated test cases + scripts + fixes --- package-lock.json | 19 + package.json | 1 + test/mainnet/b.protocol/b.compound.test.ts | 4 +- test/mainnet/b.protocol/b.liquity.test.ts | 4 +- test/mainnet/b.protocol/b.maker.test.ts | 4 +- .../mainnet/basic-ERC1155/ERC1155-transfer.ts | 4 +- test/mainnet/basic-ERC721/ERC721-transfer.ts | 4 +- test/mainnet/instapool/instapool.test.ts | 6 +- test/mainnet/mappings/mappings.test.ts | 6 +- .../pooltogether-polygon/pooltogether.test.ts | 933 ++++---- .../mainnet/pooltogether/pooltogether.test.ts | 1976 ++++++++++------- .../uniswap-sell-beta/uniswap-sell-beta.ts | 15 +- test/mainnet/uniswap/uniswap.test.ts | 109 +- .../mainnet/uniswapStake/uniswapStake.test.ts | 34 +- test/mainnet/yearn/yearn.test.ts | 293 +-- yarn.lock | 7 + 16 files changed, 2015 insertions(+), 1404 deletions(-) diff --git a/package-lock.json b/package-lock.json index 25dce20f..5c5dd07b 100644 --- a/package-lock.json +++ b/package-lock.json @@ -30,6 +30,7 @@ "@studydefi/money-legos": "^2.4.2", "@tenderly/hardhat-tenderly": "^1.0.13", "@types/chai": "^4.2.22", + "@types/chai-as-promised": "^7.1.4", "@types/mocha": "^9.0.0", "@types/node": "^16.11.11", "chai": "^4.3.4", @@ -4138,6 +4139,15 @@ "integrity": "sha512-tFfcE+DSTzWAgifkjik9AySNqIyNoYwmR+uecPwwD/XRNfvOjmC/FjCxpiUGDkDVDphPfCUecSQVFw+lN3M3kQ==", "dev": true }, + "node_modules/@types/chai-as-promised": { + "version": "7.1.4", + "resolved": "https://registry.npmjs.org/@types/chai-as-promised/-/chai-as-promised-7.1.4.tgz", + "integrity": "sha512-1y3L1cHePcIm5vXkh1DSGf/zQq5n5xDKG1fpCvf18+uOkpce0Z1ozNFPkyWsVswK7ntN1sZBw3oU6gmN+pDUcA==", + "dev": true, + "dependencies": { + "@types/chai": "*" + } + }, "node_modules/@types/glob": { "version": "7.2.0", "resolved": "https://registry.npmjs.org/@types/glob/-/glob-7.2.0.tgz", @@ -33045,6 +33055,15 @@ "integrity": "sha512-tFfcE+DSTzWAgifkjik9AySNqIyNoYwmR+uecPwwD/XRNfvOjmC/FjCxpiUGDkDVDphPfCUecSQVFw+lN3M3kQ==", "dev": true }, + "@types/chai-as-promised": { + "version": "7.1.4", + "resolved": "https://registry.npmjs.org/@types/chai-as-promised/-/chai-as-promised-7.1.4.tgz", + "integrity": "sha512-1y3L1cHePcIm5vXkh1DSGf/zQq5n5xDKG1fpCvf18+uOkpce0Z1ozNFPkyWsVswK7ntN1sZBw3oU6gmN+pDUcA==", + "dev": true, + "requires": { + "@types/chai": "*" + } + }, "@types/glob": { "version": "7.2.0", "resolved": "https://registry.npmjs.org/@types/glob/-/glob-7.2.0.tgz", diff --git a/package.json b/package.json index cd3d62d9..6c3139d9 100644 --- a/package.json +++ b/package.json @@ -42,6 +42,7 @@ "@studydefi/money-legos": "^2.4.2", "@tenderly/hardhat-tenderly": "^1.0.13", "@types/chai": "^4.2.22", + "@types/chai-as-promised": "^7.1.4", "@types/mocha": "^9.0.0", "@types/node": "^16.11.11", "chai": "^4.3.4", diff --git a/test/mainnet/b.protocol/b.compound.test.ts b/test/mainnet/b.protocol/b.compound.test.ts index 8c885a2b..fbda13f9 100644 --- a/test/mainnet/b.protocol/b.compound.test.ts +++ b/test/mainnet/b.protocol/b.compound.test.ts @@ -3,9 +3,9 @@ import hre from "hardhat"; const { web3, deployments, waffle, ethers } = hre; //check const { provider, deployContract } = waffle -import { deployAndEnableConnector } from "../../../scripts/tests/deployAndEnableConnector.js" +import { deployAndEnableConnector } from "../../../scripts/tests/deployAndEnableConnector" import { buildDSAv2 } from "../../../scripts/tests/buildDSAv2" -import { encodeSpells } from "../../../scripts/tests/encodeSpells.js" +import { encodeSpells } from "../../../scripts/tests/encodeSpells" import { getMasterSigner } from "../../../scripts/tests/getMasterSigner" import { addresses } from "../../../scripts/constant/addresses"; import { abis } from "../../../scripts/constant/abis"; diff --git a/test/mainnet/b.protocol/b.liquity.test.ts b/test/mainnet/b.protocol/b.liquity.test.ts index cefd7601..65d3996c 100644 --- a/test/mainnet/b.protocol/b.liquity.test.ts +++ b/test/mainnet/b.protocol/b.liquity.test.ts @@ -3,9 +3,9 @@ import hre from "hardhat"; const { web3, deployments, waffle, ethers } = hre; //check const { provider, deployContract } = waffle -import { deployAndEnableConnector } from "../../../scripts/tests/deployAndEnableConnector.js" +import { deployAndEnableConnector } from "../../../scripts/tests/deployAndEnableConnector" import { buildDSAv2 } from "../../../scripts/tests/buildDSAv2" -import { encodeSpells } from "../../../scripts/tests/encodeSpells.js" +import { encodeSpells } from "../../../scripts/tests/encodeSpells" import { getMasterSigner } from "../../../scripts/tests/getMasterSigner" import { addresses } from "../../../scripts/constant/addresses"; import { abis } from "../../../scripts/constant/abis"; diff --git a/test/mainnet/b.protocol/b.maker.test.ts b/test/mainnet/b.protocol/b.maker.test.ts index d87da72e..31f2c26a 100644 --- a/test/mainnet/b.protocol/b.maker.test.ts +++ b/test/mainnet/b.protocol/b.maker.test.ts @@ -3,9 +3,9 @@ import hre from "hardhat"; const { web3, deployments, waffle, ethers } = hre; const { provider, deployContract } = waffle -import { deployAndEnableConnector } from "../../../scripts/tests/deployAndEnableConnector.js" +import { deployAndEnableConnector } from "../../../scripts/tests/deployAndEnableConnector" import { buildDSAv2 } from "../../../scripts/tests/buildDSAv2" -import { encodeSpells } from "../../../scripts/tests/encodeSpells.js" +import { encodeSpells } from "../../../scripts/tests/encodeSpells" import { getMasterSigner } from "../../../scripts/tests/getMasterSigner" import { addresses } from "../../../scripts/constant/addresses"; import { abis } from "../../../scripts/constant/abis"; diff --git a/test/mainnet/basic-ERC1155/ERC1155-transfer.ts b/test/mainnet/basic-ERC1155/ERC1155-transfer.ts index 2d16e1d3..5c85581a 100644 --- a/test/mainnet/basic-ERC1155/ERC1155-transfer.ts +++ b/test/mainnet/basic-ERC1155/ERC1155-transfer.ts @@ -4,9 +4,9 @@ const { web3, deployments, waffle, ethers } = hre; const { provider, deployContract } = waffle import { abi } from "../../../scripts/constant/abi/core/InstaImplementations.json" -import { deployAndEnableConnector } from "../../../scripts/tests/deployAndEnableConnector.js" +import { deployAndEnableConnector } from "../../../scripts/tests/deployAndEnableConnector" import { buildDSAv2 } from "../../../scripts/tests/buildDSAv2" -import { encodeSpells } from "../../../scripts/tests/encodeSpells.js" +import { encodeSpells } from "../../../scripts/tests/encodeSpells" import { getMasterSigner } from "../../../scripts/tests/getMasterSigner" import { addresses } from "../../../scripts/constant/addresses" import { abis } from "../../../scripts/constant/abis" diff --git a/test/mainnet/basic-ERC721/ERC721-transfer.ts b/test/mainnet/basic-ERC721/ERC721-transfer.ts index 43dbb50e..db4acb9e 100644 --- a/test/mainnet/basic-ERC721/ERC721-transfer.ts +++ b/test/mainnet/basic-ERC721/ERC721-transfer.ts @@ -4,9 +4,9 @@ const { web3, deployments, waffle, ethers } = hre; const { provider, deployContract } = waffle import { abi } from "../../../scripts/constant/abi/core/InstaImplementations.json" -import { deployAndEnableConnector } from "../../../scripts/tests/deployAndEnableConnector.js" +import { deployAndEnableConnector } from "../../../scripts/tests/deployAndEnableConnector" import { buildDSAv2 } from "../../../scripts/tests/buildDSAv2" -import { encodeSpells } from "../../../scripts/tests/encodeSpells.js" +import { encodeSpells } from "../../../scripts/tests/encodeSpells" import { getMasterSigner } from "../../../scripts/tests/getMasterSigner" import { addresses } from "../../../scripts/constant/addresses" import { abis } from "../../../scripts/constant/abis" diff --git a/test/mainnet/instapool/instapool.test.ts b/test/mainnet/instapool/instapool.test.ts index 1a309416..3abb59c0 100644 --- a/test/mainnet/instapool/instapool.test.ts +++ b/test/mainnet/instapool/instapool.test.ts @@ -3,10 +3,10 @@ import hre from "hardhat"; const { web3, deployments, waffle, ethers } = hre; const { provider, deployContract } = waffle -import { deployAndEnableConnector } from "../../../scripts/tests/deployAndEnableConnector.js" +import { deployAndEnableConnector } from "../../../scripts/tests/deployAndEnableConnector" import { buildDSAv2 } from "../../../scripts/tests/buildDSAv2" -import { encodeSpells } from "../../../scripts/tests/encodeSpells.js" -import encodeFlashcastData from "../../../scripts/tests/encodeFlashcastData.js" +import { encodeSpells } from "../../../scripts/tests/encodeSpells" +import encodeFlashcastData from "../../../scripts/tests/encodeFlashcastData" import { getMasterSigner } from "../../../scripts/tests/getMasterSigner" import { addresses } from "../../../scripts/constant/addresses"; diff --git a/test/mainnet/mappings/mappings.test.ts b/test/mainnet/mappings/mappings.test.ts index bea79b0d..dfc60644 100644 --- a/test/mainnet/mappings/mappings.test.ts +++ b/test/mainnet/mappings/mappings.test.ts @@ -1,14 +1,15 @@ -import { ethers, network } from "hardhat"; +import hre, { ethers, network } from "hardhat"; import chai from "chai"; import chaiPromise from "chai-as-promised"; import { solidity } from "ethereum-waffle"; +import type { Signer, Contract } from "ethers"; chai.use(chaiPromise); chai.use(solidity); const { expect } = chai; -const getMapping = (address, signer) => { +const getMapping = (address: string, signer: Signer) => { return ethers.getContractAt("InstaMappingController", address, signer); }; @@ -25,6 +26,7 @@ describe("Test InstaMapping contract", () => { params: [ { forking: { + // @ts-ignore jsonRpcUrl: hre.config.networks.hardhat.forking.url, blockNumber: 12796965, }, diff --git a/test/mainnet/pooltogether-polygon/pooltogether.test.ts b/test/mainnet/pooltogether-polygon/pooltogether.test.ts index 462d7d4b..31b645f2 100644 --- a/test/mainnet/pooltogether-polygon/pooltogether.test.ts +++ b/test/mainnet/pooltogether-polygon/pooltogether.test.ts @@ -1,422 +1,561 @@ import { expect } from "chai"; import hre from "hardhat"; const { web3, deployments, waffle, ethers } = hre; -const { provider, deployContract } = waffle +const { provider, deployContract } = waffle; const ALCHEMY_ID = process.env.ALCHEMY_ID; -import { deployAndEnableConnector } from "../../../scripts/tests/deployAndEnableConnector.js" -import { buildDSAv2 } from "../../../scripts/tests/buildDSAv2" -import { encodeSpells } from "../../../scripts/tests/encodeSpells.js" -import { getMasterSigner } from "../../../scripts/tests/getMasterSigner" +import { deployAndEnableConnector } from "../../../scripts/tests/deployAndEnableConnector"; +import { buildDSAv2 } from "../../../scripts/tests/buildDSAv2"; +import { encodeSpells } from "../../../scripts/tests/encodeSpells"; +import { getMasterSigner } from "../../../scripts/tests/getMasterSigner"; +import { addresses } from "../../../scripts/constant/addresses"; +import { abis } from "../../../scripts/constant/abis"; +import { tokens } from "../../../scripts/constant/tokens"; +import type { Signer, Contract } from "ethers"; -import { addresses } from "../../../scripts/constant/addresses" -import { abis } from "../../../scripts/constant/abis" -import { constants } from "../../../scripts/constant/constant" -import { tokens } from "../../../scripts/constant/tokens" +import { ConnectV2AaveV2Polygon__factory, ConnectV2PoolTogetherPolygon__factory } from "../../../typechain"; - -import connectV2AaveV2Artifacts from "../../artifacts/contracts/polygon/connectors/aave/v2/main.sol/ConnectV2AaveV2Polygon.json" -import connectV2PoolTogetherArtifacts from "../../artifacts/contracts/polygon/connectors/pooltogether/main.sol/ConnectV2PoolTogetherPolygon.json" - -const DAI_TOKEN_ADDR = tokens.dai.address // DAI Token +const DAI_TOKEN_ADDR = tokens.dai.address; // DAI Token // PoolTogether Address: https://docs.pooltogether.com/resources/networks/matic -const USDC_PRIZE_POOL_ADDR = "0xEE06AbE9e2Af61cabcb13170e01266Af2DEFa946" // USDC Prize Pool -const PT_USDC_TICKET_ADDR = "0x473E484c722EF9ec6f63B509b07Bb9cfB258820b" // PT USDC Ticket -const PT_USDC_SPONGSOR_TICKET_ADDR = "0x19c0e557ee5a9b456f613ba3d025a4dc45b52c35" // PT USDC Sponsor Ticket -const USDC_POOL_FAUCET_ADDR = "0x6cbc003fE015D753180f072d904bA841b2415498" // USDC POOL Faucet -const POOL_TOKEN_ADDRESS = "0x25788a1a171ec66Da6502f9975a15B609fF54CF6" // POOL Tocken -const TOKEN_FAUCET_PROXY_FACTORY_ADDR = "0xeaa636304a7C8853324B6b603dCdE55F92dfbab1" // TokenFaucetProxyFactory for claimAll +const USDC_PRIZE_POOL_ADDR = "0xEE06AbE9e2Af61cabcb13170e01266Af2DEFa946"; // USDC Prize Pool +const PT_USDC_TICKET_ADDR = "0x473E484c722EF9ec6f63B509b07Bb9cfB258820b"; // PT USDC Ticket +const PT_USDC_SPONGSOR_TICKET_ADDR = + "0x19c0e557ee5a9b456f613ba3d025a4dc45b52c35"; // PT USDC Sponsor Ticket +const USDC_POOL_FAUCET_ADDR = "0x6cbc003fE015D753180f072d904bA841b2415498"; // USDC POOL Faucet +const POOL_TOKEN_ADDRESS = "0x25788a1a171ec66Da6502f9975a15B609fF54CF6"; // POOL Tocken +const TOKEN_FAUCET_PROXY_FACTORY_ADDR = + "0xeaa636304a7C8853324B6b603dCdE55F92dfbab1"; // TokenFaucetProxyFactory for claimAll // Community WETH Prize Pool (Rari): https://reference-app.pooltogether.com/pools/mainnet/0xa88ca010b32a54d446fc38091ddbca55750cbfc3/manage#stats -const WETH_PRIZE_POOL_ADDR = "0xa88ca010b32a54d446fc38091ddbca55750cbfc3" // Community WETH Prize Pool (Rari) -const WETH_POOL_TICKET_ADDR = "0x9b5c30aeb9ce2a6a121cea9a85bc0d662f6d9b40" // Community WETH Prize Pool Ticket (Rari) +const WETH_PRIZE_POOL_ADDR = "0xa88ca010b32a54d446fc38091ddbca55750cbfc3"; // Community WETH Prize Pool (Rari) +const WETH_POOL_TICKET_ADDR = "0x9b5c30aeb9ce2a6a121cea9a85bc0d662f6d9b40"; // Community WETH Prize Pool Ticket (Rari) const prizePoolABI = [ - "function calculateEarlyExitFee( address from, address controlledToken, uint256 amount) external returns ( uint256 exitFee, uint256 burnedCredit)", - "function creditPlanOf( address controlledToken) external view returns ( uint128 creditLimitMantissa, uint128 creditRateMantissa)" -] + "function calculateEarlyExitFee( address from, address controlledToken, uint256 amount) external returns ( uint256 exitFee, uint256 burnedCredit)", + "function creditPlanOf( address controlledToken) external view returns ( uint128 creditLimitMantissa, uint128 creditRateMantissa)", +]; const connectorsABI = [ - "function isConnectors(string[] calldata connectorNames) external view returns (bool, address[] memory)" -] + "function isConnectors(string[] calldata connectorNames) external view returns (bool, address[] memory)", +]; -describe("PoolTogether", function () { - const connectorName = "AAVEV2-TEST-A" - const ptConnectorName = "POOLTOGETHER-TEST-A" +describe("PoolTogether", function() { + const connectorName = "AAVEV2-TEST-A"; + const ptConnectorName = "POOLTOGETHER-TEST-A"; - let dsaWallet0 - let masterSigner; - let instaConnectorsV2; - let connector; - let ptConnector; + let dsaWallet0: any; + let masterSigner: Signer; + let instaConnectorsV2: Contract; + let connector: any; + let ptConnector: Contract; - const wallets = provider.getWallets() - const [wallet0, wallet1, wallet2, wallet3] = wallets - before(async () => { - await hre.network.provider.request({ - method: "hardhat_reset", - params: [ - { - forking: { - jsonRpcUrl: `https://polygon-mainnet.g.alchemy.com/v2/${ALCHEMY_ID}`, - blockNumber: 18717337, - }, - }, - ], - }); - - masterSigner = await getMasterSigner() - instaConnectorsV2 = await ethers.getContractAt(abis.core.connectorsV2, addresses.core.connectorsV2); - - // Deploy and enable Compound Connector - connector = await deployAndEnableConnector({ - connectorName, - contractArtifact: connectV2AaveV2Artifacts, - signer: masterSigner, - connectors: instaConnectorsV2 - }) - - // Deploy and enable Pool Together Connector - ptConnector = await deployAndEnableConnector({ - connectorName: ptConnectorName, - contractArtifact: connectV2PoolTogetherArtifacts, - signer: masterSigner, - connectors: instaConnectorsV2 - }) - }) - - it("Should have contracts deployed.", async function () { - expect(!!instaConnectorsV2.address).to.be.true; - expect(!!connector.address).to.be.true; - expect(!!ptConnector.address).to.be.true; - expect(!!masterSigner.address).to.be.true; + const wallets = provider.getWallets(); + const [wallet0, wallet1, wallet2, wallet3] = wallets; + before(async () => { + await hre.network.provider.request({ + method: "hardhat_reset", + params: [ + { + forking: { + jsonRpcUrl: `https://polygon-mainnet.g.alchemy.com/v2/${ALCHEMY_ID}`, + blockNumber: 18717337, + }, + }, + ], }); - describe("DSA wallet setup", function () { - it("Should build DSA v2", async function () { - dsaWallet0 = await buildDSAv2(wallet0.address) - expect(!!dsaWallet0.address).to.be.true; - }); + masterSigner = await getMasterSigner(); + instaConnectorsV2 = await ethers.getContractAt( + abis.core.connectorsV2, + addresses.core.connectorsV2 + ); - it("Deposit 1000 MATIC into DSA wallet", async function () { - await wallet0.sendTransaction({ - to: dsaWallet0.address, - value: ethers.utils.parseEther("1000") - }); - expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.gte(ethers.utils.parseEther("1000")); - }); + // Deploy and enable Compound Connector + connector = await deployAndEnableConnector({ + connectorName, + contractArtifact: ConnectV2AaveV2Polygon__factory, + signer: masterSigner, + connectors: instaConnectorsV2, }); - describe("Main - USDC Prize Pool Test", function () { - - it("Should deposit 100 MATIC in AAVE V2", async function () { - const amount = ethers.utils.parseEther("100") // 100 MATIC - const spells = [ - { - connector: connectorName, - method: "deposit", - args: [tokens.matic.address, amount, 0, 0] - } - ] - - const tx = await dsaWallet0.cast(...encodeSpells(spells), wallet1.address) - const receipt = await tx.wait() - expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.lte(ethers.utils.parseEther("900")); - }); - - it("Should borrow 10 USDC from AAVE V2 and deposit USDC into USDC Prize Pool", async function () { - const amount = ethers.utils.parseUnits("10", 6) // 10 USDC - const setId = "83478237" - const spells = [ - { - connector: connectorName, - method: "borrow", - args: [tokens.usdc.address, amount, 2, 0, setId] - }, - { - connector: ptConnectorName, - method: "depositTo", - args: [USDC_PRIZE_POOL_ADDR, amount, PT_USDC_SPONGSOR_TICKET_ADDR, setId, 0] - } - ] - // Before Spell - let usdcToken = await ethers.getContractAt(abis.basic.erc20, tokens.usdc.address) - let usdcBalance = await usdcToken.balanceOf(dsaWallet0.address); - expect(usdcBalance, `USDC balance is 0`).to.be.eq(ethers.utils.parseUnits("0", 6)); - - let cToken = await ethers.getContractAt(abis.basic.erc20, PT_USDC_SPONGSOR_TICKET_ADDR) - const balance = await cToken.balanceOf(dsaWallet0.address) - expect(balance, `PoolTogether USDC Ticket balance is 0`).to.be.eq(0); - - // Run spell transaction - const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet1.address) - const receipt = await tx.wait() - - // After spell - usdcBalance = await usdcToken.balanceOf(dsaWallet0.address); - expect(usdcBalance, `Expect USDC balance to still equal 0 since it was deposited into Prize Pool`).to.be.eq(0); - - const balanceAfter = await cToken.balanceOf(dsaWallet0.address) - expect(balanceAfter, `PoolTogether USDC Ticket balance equals 10`).to.be.eq(ethers.utils.parseUnits("10", 6)); - - // ETH used for transaction - expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.lte(ethers.utils.parseEther("900")); - }); - - it("Should wait 11 days, withdraw all PrizePool, get back 10 USDC, and claim POOL", async function () { - const amount = ethers.utils.parseUnits("10", 6) // 10 USDC - - let prizePoolContract = new ethers.Contract(USDC_PRIZE_POOL_ADDR, prizePoolABI, ethers.provider); - // const { creditLimitMantissa, creditRateMantissa } = await prizePoolContract.creditPlanOf(PT_USDC_TICKET_ADDR); - // console.log("CreditLimitMantiss: ", creditLimitMantissa.toString()); - // console.log("CreditRateMantiss: ", creditRateMantissa.toString()); - let earlyExitFee = await prizePoolContract.callStatic["calculateEarlyExitFee"](dsaWallet0.address, PT_USDC_SPONGSOR_TICKET_ADDR, amount); - expect(earlyExitFee.exitFee, "Exit Fee equal to 0 USDC because 0% fee for sponsorship ticket").to.be.eq(ethers.utils.parseUnits("0", 6)); - - const spells = [ - { - connector: ptConnectorName, - method: "claim", - args: [USDC_POOL_FAUCET_ADDR, 0] - }, - { - connector: ptConnectorName, - method: "withdrawInstantlyFrom", - args: [USDC_PRIZE_POOL_ADDR, amount, PT_USDC_SPONGSOR_TICKET_ADDR, earlyExitFee.exitFee, 0, 0] - } - - ] - - // Before spell - let usdcToken = await ethers.getContractAt(abis.basic.erc20, tokens.usdc.address) - let usdcBalance = await usdcToken.balanceOf(dsaWallet0.address); - expect(usdcBalance, `USDC balance equals 0`).to.be.eq(ethers.utils.parseEther("0")); - - let cToken = await ethers.getContractAt(abis.basic.erc20, PT_USDC_SPONGSOR_TICKET_ADDR) - const balance = await cToken.balanceOf(dsaWallet0.address) - expect(balance, `PoolTogether USDC Ticket is 10`).to.be.eq(ethers.utils.parseUnits("10", 6)); - - let poolToken = await ethers.getContractAt(abis.basic.erc20, POOL_TOKEN_ADDRESS) - const poolBalance = await poolToken.balanceOf(dsaWallet0.address) - expect(poolBalance, `POOL Token equals 0`).to.be.eq(ethers.utils.parseEther("0")); - - // Increase time by 11 days so we get back all USDC without early withdrawal fee - await ethers.provider.send("evm_increaseTime", [15 * 24 * 60 * 60]); - await ethers.provider.send("evm_mine"); - - earlyExitFee = await prizePoolContract.callStatic["calculateEarlyExitFee"](dsaWallet0.address, PT_USDC_SPONGSOR_TICKET_ADDR, amount); - expect(earlyExitFee.exitFee, "Exit Fee equal to 0 DAI because past 14 days").to.be.eq(0); - - // Run spell transaction - const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet1.address) - const receipt = await tx.wait() - - // After spell - usdcBalance = await usdcToken.balanceOf(dsaWallet0.address); - console.log("USDC BALANCE: ", usdcBalance.toString()); - console.log("USDC BALANCE: ", ethers.utils.parseUnits("10", 6).toString()); - expect(usdcBalance, - `USDC balance to be equal to 10, because of no early withdrawal fee` - ).to.be.eq(ethers.utils.parseUnits("10", 6)); - - const balanceAfter = await cToken.balanceOf(dsaWallet0.address) - expect(balanceAfter, `PoolTogether USDC Ticket to equal 0`).to.be.eq(0); - - const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address) - console.log("POOL BALANCE AFTER:", poolBalanceAfter.toString()); - expect(poolBalanceAfter, `POOL Token Balance to be greater than 0`).to.be.gt(ethers.utils.parseEther("0")); - }); - - it("Should deposit and withdraw all PrizePool, get back less than 10 USDC", async function () { - const amount = ethers.utils.parseUnits("10", 6) // 10 USDC - const exitFee = ethers.utils.parseUnits(".1", 6) // 1 USDC is 1% of 100 USDC - const spells = [ - { - connector: ptConnectorName, - method: "depositTo", - args: [USDC_PRIZE_POOL_ADDR, amount, PT_USDC_TICKET_ADDR, 0, 0] - }, - { - connector: ptConnectorName, - method: "withdrawInstantlyFrom", - args: [USDC_PRIZE_POOL_ADDR, amount, PT_USDC_TICKET_ADDR, exitFee, 0, 0] - } - ] - - // Before spell - let usdcToken = await ethers.getContractAt(abis.basic.erc20, tokens.usdc.address) - let usdcBalance = await usdcToken.balanceOf(dsaWallet0.address); - expect(usdcBalance, `USDC Balance equals 100`).to.be.eq(ethers.utils.parseUnits("10", 6)); - - let cToken = await ethers.getContractAt(abis.basic.erc20, PT_USDC_TICKET_ADDR) - const balance = await cToken.balanceOf(dsaWallet0.address) - expect(balance, `PoolTogether USDC Ticket equals 0`).to.be.eq(0); - - let poolToken = await ethers.getContractAt(abis.basic.erc20, POOL_TOKEN_ADDRESS) - const poolBalance = await poolToken.balanceOf(dsaWallet0.address) - expect(poolBalance, `PoolTogether Token greater than 0`).to.be.gt(0); - - // Run spell transaction - const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet1.address) - const receipt = await tx.wait() - - // After spell - usdcBalance = await usdcToken.balanceOf(dsaWallet0.address); - expect(usdcBalance, - `USDC balance to be less than 10, because of early withdrawal fee` - ).to.be.lt(ethers.utils.parseUnits("10", 6)); - - console.log("USDC BALANCE AFTER:", usdcBalance.toString()); - - const balanceAfter = await cToken.balanceOf(dsaWallet0.address) - expect(balanceAfter, `PoolTogether USDC Ticket to equal 0`).to.be.eq(0); - - const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address) - expect(poolBalanceAfter, `POOL Token Balance to greater than 0`).to.be.gt(ethers.utils.parseEther("0")); - - }); - - it("Should deposit, wait 11 days, and withdraw all PrizePool, get 10 USDC, and claim all POOL using claimAll", async function () { - const amount = ethers.utils.parseUnits("9.9", 6) // 9 USDC - const depositSpells = [ - { - connector: ptConnectorName, - method: "depositTo", - args: [USDC_PRIZE_POOL_ADDR, amount, PT_USDC_SPONGSOR_TICKET_ADDR, 0, 0] - } - ] - - // Before spell - let usdcToken = await ethers.getContractAt(abis.basic.erc20, tokens.usdc.address) - let usdcBalance = await usdcToken.balanceOf(dsaWallet0.address); - expect(usdcBalance, `USDC balance less than 10`).to.be.lt(ethers.utils.parseUnits("10", 6)); - - let cToken = await ethers.getContractAt(abis.basic.erc20, PT_USDC_SPONGSOR_TICKET_ADDR) - const balance = await cToken.balanceOf(dsaWallet0.address) - expect(balance, `PoolTogether USDC Ticket equal 0`).to.be.eq(0); - - let poolToken = await ethers.getContractAt(abis.basic.erc20, POOL_TOKEN_ADDRESS) - const poolBalance = await poolToken.balanceOf(dsaWallet0.address) - expect(poolBalance, `POOL Token is greater than 0`).to.be.gt(ethers.utils.parseEther("0")); - - // Run spell transaction - const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(depositSpells), wallet1.address) - const receipt = await tx.wait() - - const prizePoolContract = new ethers.Contract(USDC_PRIZE_POOL_ADDR, prizePoolABI, ethers.provider); - let earlyExitFee = await prizePoolContract.callStatic["calculateEarlyExitFee"](dsaWallet0.address, PT_USDC_SPONGSOR_TICKET_ADDR, amount); - expect(earlyExitFee.exitFee, "Exit Fee equal to 0 USDC because fee 0%").to.be.eq(0); - - // Increase time by 11 days so we get back all DAI without early withdrawal fee - await ethers.provider.send("evm_increaseTime", [11 * 24 * 60 * 60]); - await ethers.provider.send("evm_mine"); - - const withdrawSpells = [ - { - connector: ptConnectorName, - method: "withdrawInstantlyFrom", - args: [USDC_PRIZE_POOL_ADDR, amount, PT_USDC_SPONGSOR_TICKET_ADDR, earlyExitFee.exitFee, 0, 0] - }, - { - connector: ptConnectorName, - method: "claimAll", - args: [TOKEN_FAUCET_PROXY_FACTORY_ADDR, [USDC_POOL_FAUCET_ADDR]] - } - ] - - // Run spell transaction - const tx2 = await dsaWallet0.connect(wallet0).cast(...encodeSpells(withdrawSpells), wallet1.address) - const receipt2 = await tx2.wait() - - // After spell - usdcBalance = await usdcToken.balanceOf(dsaWallet0.address); - expect(usdcBalance, `USDC balance equals 9.9`).to.be.eq(ethers.utils.parseUnits("9.9", 6)); - - const balanceAfter = await cToken.balanceOf(dsaWallet0.address) - expect(balanceAfter, `PoolTogether USDC Ticket equal 0`).to.be.eq(0); - - // Expect - const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address) - console.log("POOL BALANCE AFTER:", poolBalanceAfter.toString()); - expect(poolBalanceAfter, `Pool Token to be greater than before`).to.be.gt(poolBalance); - }); - // }) - - // NO WMATIC POOLS: https://reference-app.pooltogether.com/pools/polygon - // describe("Main - WETH Prize Pool Test", function () { - // it("Deposit 1 ETH into WETH Prize Pool and withdraw immediately", async function () { - // const amount = ethers.utils.parseEther("1") // 1 ETH - // const setId = "83478237" - // const spells = [ - // { - // connector: ptConnectorName, - // method: "depositTo", - // args: [WETH_PRIZE_POOL_ADDR, amount, WETH_POOL_TICKET_ADDR, 0, setId] - // }, - // { - // connector: ptConnectorName, - // method: "withdrawInstantlyFrom", - // args: [WETH_PRIZE_POOL_ADDR, amount, WETH_POOL_TICKET_ADDR, amount, setId, 0] - // }, - // ] - // // Before Spell - // const ethBalanceBefore = await ethers.provider.getBalance(dsaWallet0.address); - - // // Run spell transaction - // const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet1.address) - // const receipt = await tx.wait() - - // // After spell - // const ethBalanceAfter = await ethers.provider.getBalance(dsaWallet0.address); - - // // ETH used for transaction - // expect(ethBalanceAfter, `ETH Balance less than before spell because of early withdrawal fee`).to.be.lte(ethBalanceBefore); - // }); - - // it("Deposit 1 ETH into WETH Prize Pool, wait 14 days, then withdraw", async function () { - // const amount = ethers.utils.parseEther("1") // 1 ETH - // const depositSpell = [ - // { - // connector: ptConnectorName, - // method: "depositTo", - // args: [WETH_PRIZE_POOL_ADDR, amount, WETH_POOL_TICKET_ADDR, 0, 0] - // } - // ] - - // const withdrawSpell = [ - // { - // connector: ptConnectorName, - // method: "withdrawInstantlyFrom", - // args: [WETH_PRIZE_POOL_ADDR, amount, WETH_POOL_TICKET_ADDR, amount, 0, 0] - // } - // ] - - // // Before Deposit Spell - // let ethBalanceBefore = await ethers.provider.getBalance(dsaWallet0.address); - - // // Run deposit spell transaction - // const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(depositSpell), wallet1.address) - // const receipt = await tx.wait() - - // // After Deposit spell - // let ethBalanceAfter = await ethers.provider.getBalance(dsaWallet0.address); - - // expect(ethBalanceAfter, `ETH Balance less than before spell`).to.be.lte(ethBalanceBefore); - - // // Increase time by 11 days so we get back all ETH without early withdrawal fee - // await ethers.provider.send("evm_increaseTime", [14*24*60*60]); - // await ethers.provider.send("evm_mine"); - - // // Run withdraw spell transaction - // const tx2 = await dsaWallet0.connect(wallet0).cast(...encodeSpells(withdrawSpell), wallet1.address) - // const receipt2 = await tx.wait() - - // // After Deposit spell - // ethBalanceAfter = await ethers.provider.getBalance(dsaWallet0.address); - - // expect(ethBalanceAfter, `ETH Balance equal to before spell because no early exit fee`).to.be.eq(ethBalanceBefore); - // }); + // Deploy and enable Pool Together Connector + ptConnector = await deployAndEnableConnector({ + connectorName: ptConnectorName, + contractArtifact: ConnectV2PoolTogetherPolygon__factory, + signer: masterSigner, + connectors: instaConnectorsV2, }); -}) \ No newline at end of file + }); + + it("Should have contracts deployed.", async function() { + expect(!!instaConnectorsV2.address).to.be.true; + expect(!!connector.address).to.be.true; + expect(!!ptConnector.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.address); + expect(!!dsaWallet0.address).to.be.true; + }); + + it("Deposit 1000 MATIC into DSA wallet", async function() { + await wallet0.sendTransaction({ + to: dsaWallet0.address, + value: ethers.utils.parseEther("1000"), + }); + expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.gte( + ethers.utils.parseEther("1000") + ); + }); + }); + + describe("Main - USDC Prize Pool Test", function() { + it("Should deposit 100 MATIC in AAVE V2", async function() { + const amount = ethers.utils.parseEther("100"); // 100 MATIC + const spells = [ + { + connector: connectorName, + method: "deposit", + args: [tokens.eth.address, amount, 0, 0], + }, + ]; + + const tx = await dsaWallet0.cast( + ...encodeSpells(spells), + wallet1.address + ); + const receipt = await tx.wait(); + expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.lte( + ethers.utils.parseEther("900") + ); + }); + + it("Should borrow 10 USDC from AAVE V2 and deposit USDC into USDC Prize Pool", async function() { + const amount = ethers.utils.parseUnits("10", 6); // 10 USDC + const setId = "83478237"; + const spells = [ + { + connector: connectorName, + method: "borrow", + args: [tokens.usdc.address, amount, 2, 0, setId], + }, + { + connector: ptConnectorName, + method: "depositTo", + args: [ + USDC_PRIZE_POOL_ADDR, + amount, + PT_USDC_SPONGSOR_TICKET_ADDR, + setId, + 0, + ], + }, + ]; + // Before Spell + let usdcToken = await ethers.getContractAt( + abis.basic.erc20, + tokens.usdc.address + ); + let usdcBalance = await usdcToken.balanceOf(dsaWallet0.address); + expect(usdcBalance, `USDC balance is 0`).to.be.eq( + ethers.utils.parseUnits("0", 6) + ); + + let cToken = await ethers.getContractAt( + abis.basic.erc20, + PT_USDC_SPONGSOR_TICKET_ADDR + ); + const balance = await cToken.balanceOf(dsaWallet0.address); + expect(balance, `PoolTogether USDC Ticket balance is 0`).to.be.eq(0); + + // Run spell transaction + const tx = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(spells), wallet1.address); + const receipt = await tx.wait(); + + // After spell + usdcBalance = await usdcToken.balanceOf(dsaWallet0.address); + expect( + usdcBalance, + `Expect USDC balance to still equal 0 since it was deposited into Prize Pool` + ).to.be.eq(0); + + const balanceAfter = await cToken.balanceOf(dsaWallet0.address); + expect( + balanceAfter, + `PoolTogether USDC Ticket balance equals 10` + ).to.be.eq(ethers.utils.parseUnits("10", 6)); + + // ETH used for transaction + expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.lte( + ethers.utils.parseEther("900") + ); + }); + + it("Should wait 11 days, withdraw all PrizePool, get back 10 USDC, and claim POOL", async function() { + const amount = ethers.utils.parseUnits("10", 6); // 10 USDC + + let prizePoolContract = new ethers.Contract( + USDC_PRIZE_POOL_ADDR, + prizePoolABI, + ethers.provider + ); + // const { creditLimitMantissa, creditRateMantissa } = await prizePoolContract.creditPlanOf(PT_USDC_TICKET_ADDR); + // console.log("CreditLimitMantiss: ", creditLimitMantissa.toString()); + // console.log("CreditRateMantiss: ", creditRateMantissa.toString()); + let earlyExitFee = await prizePoolContract.callStatic[ + "calculateEarlyExitFee" + ](dsaWallet0.address, PT_USDC_SPONGSOR_TICKET_ADDR, amount); + expect( + earlyExitFee.exitFee, + "Exit Fee equal to 0 USDC because 0% fee for sponsorship ticket" + ).to.be.eq(ethers.utils.parseUnits("0", 6)); + + const spells = [ + { + connector: ptConnectorName, + method: "claim", + args: [USDC_POOL_FAUCET_ADDR, 0], + }, + { + connector: ptConnectorName, + method: "withdrawInstantlyFrom", + args: [ + USDC_PRIZE_POOL_ADDR, + amount, + PT_USDC_SPONGSOR_TICKET_ADDR, + earlyExitFee.exitFee, + 0, + 0, + ], + }, + ]; + + // Before spell + let usdcToken = await ethers.getContractAt( + abis.basic.erc20, + tokens.usdc.address + ); + let usdcBalance = await usdcToken.balanceOf(dsaWallet0.address); + expect(usdcBalance, `USDC balance equals 0`).to.be.eq( + ethers.utils.parseEther("0") + ); + + let cToken = await ethers.getContractAt( + abis.basic.erc20, + PT_USDC_SPONGSOR_TICKET_ADDR + ); + const balance = await cToken.balanceOf(dsaWallet0.address); + expect(balance, `PoolTogether USDC Ticket is 10`).to.be.eq( + ethers.utils.parseUnits("10", 6) + ); + + let poolToken = await ethers.getContractAt( + abis.basic.erc20, + POOL_TOKEN_ADDRESS + ); + const poolBalance = await poolToken.balanceOf(dsaWallet0.address); + expect(poolBalance, `POOL Token equals 0`).to.be.eq( + ethers.utils.parseEther("0") + ); + + // Increase time by 11 days so we get back all USDC without early withdrawal fee + await ethers.provider.send("evm_increaseTime", [15 * 24 * 60 * 60]); + + earlyExitFee = await prizePoolContract.callStatic[ + "calculateEarlyExitFee" + ](dsaWallet0.address, PT_USDC_SPONGSOR_TICKET_ADDR, amount); + expect( + earlyExitFee.exitFee, + "Exit Fee equal to 0 DAI because past 14 days" + ).to.be.eq(0); + + // Run spell transaction + const tx = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(spells), wallet1.address); + const receipt = await tx.wait(); + + // After spell + usdcBalance = await usdcToken.balanceOf(dsaWallet0.address); + console.log("USDC BALANCE: ", usdcBalance.toString()); + console.log( + "USDC BALANCE: ", + ethers.utils.parseUnits("10", 6).toString() + ); + expect( + usdcBalance, + `USDC balance to be equal to 10, because of no early withdrawal fee` + ).to.be.eq(ethers.utils.parseUnits("10", 6)); + + const balanceAfter = await cToken.balanceOf(dsaWallet0.address); + expect(balanceAfter, `PoolTogether USDC Ticket to equal 0`).to.be.eq(0); + + const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address); + console.log("POOL BALANCE AFTER:", poolBalanceAfter.toString()); + expect( + poolBalanceAfter, + `POOL Token Balance to be greater than 0` + ).to.be.gt(ethers.utils.parseEther("0")); + }); + + it("Should deposit and withdraw all PrizePool, get back less than 10 USDC", async function() { + const amount = ethers.utils.parseUnits("10", 6); // 10 USDC + const exitFee = ethers.utils.parseUnits(".1", 6); // 1 USDC is 1% of 100 USDC + const spells = [ + { + connector: ptConnectorName, + method: "depositTo", + args: [USDC_PRIZE_POOL_ADDR, amount, PT_USDC_TICKET_ADDR, 0, 0], + }, + { + connector: ptConnectorName, + method: "withdrawInstantlyFrom", + args: [ + USDC_PRIZE_POOL_ADDR, + amount, + PT_USDC_TICKET_ADDR, + exitFee, + 0, + 0, + ], + }, + ]; + + // Before spell + let usdcToken = await ethers.getContractAt( + abis.basic.erc20, + tokens.usdc.address + ); + let usdcBalance = await usdcToken.balanceOf(dsaWallet0.address); + expect(usdcBalance, `USDC Balance equals 100`).to.be.eq( + ethers.utils.parseUnits("10", 6) + ); + + let cToken = await ethers.getContractAt( + abis.basic.erc20, + PT_USDC_TICKET_ADDR + ); + const balance = await cToken.balanceOf(dsaWallet0.address); + expect(balance, `PoolTogether USDC Ticket equals 0`).to.be.eq(0); + + let poolToken = await ethers.getContractAt( + abis.basic.erc20, + POOL_TOKEN_ADDRESS + ); + const poolBalance = await poolToken.balanceOf(dsaWallet0.address); + expect(poolBalance, `PoolTogether Token greater than 0`).to.be.gt(0); + + // Run spell transaction + const tx = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(spells), wallet1.address); + const receipt = await tx.wait(); + + // After spell + usdcBalance = await usdcToken.balanceOf(dsaWallet0.address); + expect( + usdcBalance, + `USDC balance to be less than 10, because of early withdrawal fee` + ).to.be.lt(ethers.utils.parseUnits("10", 6)); + + console.log("USDC BALANCE AFTER:", usdcBalance.toString()); + + const balanceAfter = await cToken.balanceOf(dsaWallet0.address); + expect(balanceAfter, `PoolTogether USDC Ticket to equal 0`).to.be.eq(0); + + const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address); + expect(poolBalanceAfter, `POOL Token Balance to greater than 0`).to.be.gt( + ethers.utils.parseEther("0") + ); + }); + + it("Should deposit, wait 11 days, and withdraw all PrizePool, get 10 USDC, and claim all POOL using claimAll", async function() { + const amount = ethers.utils.parseUnits("9.9", 6); // 9 USDC + const depositSpells = [ + { + connector: ptConnectorName, + method: "depositTo", + args: [ + USDC_PRIZE_POOL_ADDR, + amount, + PT_USDC_SPONGSOR_TICKET_ADDR, + 0, + 0, + ], + }, + ]; + + // Before spell + let usdcToken = await ethers.getContractAt( + abis.basic.erc20, + tokens.usdc.address + ); + let usdcBalance = await usdcToken.balanceOf(dsaWallet0.address); + expect(usdcBalance, `USDC balance less than 10`).to.be.lt( + ethers.utils.parseUnits("10", 6) + ); + + let cToken = await ethers.getContractAt( + abis.basic.erc20, + PT_USDC_SPONGSOR_TICKET_ADDR + ); + const balance = await cToken.balanceOf(dsaWallet0.address); + expect(balance, `PoolTogether USDC Ticket equal 0`).to.be.eq(0); + + let poolToken = await ethers.getContractAt( + abis.basic.erc20, + POOL_TOKEN_ADDRESS + ); + const poolBalance = await poolToken.balanceOf(dsaWallet0.address); + expect(poolBalance, `POOL Token is greater than 0`).to.be.gt( + ethers.utils.parseEther("0") + ); + + // Run spell transaction + const tx = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(depositSpells), wallet1.address); + const receipt = await tx.wait(); + + const prizePoolContract = new ethers.Contract( + USDC_PRIZE_POOL_ADDR, + prizePoolABI, + ethers.provider + ); + let earlyExitFee = await prizePoolContract.callStatic[ + "calculateEarlyExitFee" + ](dsaWallet0.address, PT_USDC_SPONGSOR_TICKET_ADDR, amount); + expect( + earlyExitFee.exitFee, + "Exit Fee equal to 0 USDC because fee 0%" + ).to.be.eq(0); + + // Increase time by 11 days so we get back all DAI without early withdrawal fee + await ethers.provider.send("evm_increaseTime", [11 * 24 * 60 * 60]); + + const withdrawSpells = [ + { + connector: ptConnectorName, + method: "withdrawInstantlyFrom", + args: [ + USDC_PRIZE_POOL_ADDR, + amount, + PT_USDC_SPONGSOR_TICKET_ADDR, + earlyExitFee.exitFee, + 0, + 0, + ], + }, + { + connector: ptConnectorName, + method: "claimAll", + args: [TOKEN_FAUCET_PROXY_FACTORY_ADDR, [USDC_POOL_FAUCET_ADDR]], + }, + ]; + + // Run spell transaction + const tx2 = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(withdrawSpells), wallet1.address); + const receipt2 = await tx2.wait(); + + // After spell + usdcBalance = await usdcToken.balanceOf(dsaWallet0.address); + expect(usdcBalance, `USDC balance equals 9.9`).to.be.eq( + ethers.utils.parseUnits("9.9", 6) + ); + + const balanceAfter = await cToken.balanceOf(dsaWallet0.address); + expect(balanceAfter, `PoolTogether USDC Ticket equal 0`).to.be.eq(0); + + // Expect + const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address); + console.log("POOL BALANCE AFTER:", poolBalanceAfter.toString()); + expect(poolBalanceAfter, `Pool Token to be greater than before`).to.be.gt( + poolBalance + ); + }); + // }) + + // NO WMATIC POOLS: https://reference-app.pooltogether.com/pools/polygon + // describe("Main - WETH Prize Pool Test", function () { + // it("Deposit 1 ETH into WETH Prize Pool and withdraw immediately", async function () { + // const amount = ethers.utils.parseEther("1") // 1 ETH + // const setId = "83478237" + // const spells = [ + // { + // connector: ptConnectorName, + // method: "depositTo", + // args: [WETH_PRIZE_POOL_ADDR, amount, WETH_POOL_TICKET_ADDR, 0, setId] + // }, + // { + // connector: ptConnectorName, + // method: "withdrawInstantlyFrom", + // args: [WETH_PRIZE_POOL_ADDR, amount, WETH_POOL_TICKET_ADDR, amount, setId, 0] + // }, + // ] + // // Before Spell + // const ethBalanceBefore = await ethers.provider.getBalance(dsaWallet0.address); + + // // Run spell transaction + // const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet1.address) + // const receipt = await tx.wait() + + // // After spell + // const ethBalanceAfter = await ethers.provider.getBalance(dsaWallet0.address); + + // // ETH used for transaction + // expect(ethBalanceAfter, `ETH Balance less than before spell because of early withdrawal fee`).to.be.lte(ethBalanceBefore); + // }); + + // it("Deposit 1 ETH into WETH Prize Pool, wait 14 days, then withdraw", async function () { + // const amount = ethers.utils.parseEther("1") // 1 ETH + // const depositSpell = [ + // { + // connector: ptConnectorName, + // method: "depositTo", + // args: [WETH_PRIZE_POOL_ADDR, amount, WETH_POOL_TICKET_ADDR, 0, 0] + // } + // ] + + // const withdrawSpell = [ + // { + // connector: ptConnectorName, + // method: "withdrawInstantlyFrom", + // args: [WETH_PRIZE_POOL_ADDR, amount, WETH_POOL_TICKET_ADDR, amount, 0, 0] + // } + // ] + + // // Before Deposit Spell + // let ethBalanceBefore = await ethers.provider.getBalance(dsaWallet0.address); + + // // Run deposit spell transaction + // const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(depositSpell), wallet1.address) + // const receipt = await tx.wait() + + // // After Deposit spell + // let ethBalanceAfter = await ethers.provider.getBalance(dsaWallet0.address); + + // expect(ethBalanceAfter, `ETH Balance less than before spell`).to.be.lte(ethBalanceBefore); + + // // Increase time by 11 days so we get back all ETH without early withdrawal fee + // await ethers.provider.send("evm_increaseTime", [14*24*60*60]); + // await ethers.provider.send("evm_mine"); + + // // Run withdraw spell transaction + // const tx2 = await dsaWallet0.connect(wallet0).cast(...encodeSpells(withdrawSpell), wallet1.address) + // const receipt2 = await tx.wait() + + // // After Deposit spell + // ethBalanceAfter = await ethers.provider.getBalance(dsaWallet0.address); + + // expect(ethBalanceAfter, `ETH Balance equal to before spell because no early exit fee`).to.be.eq(ethBalanceBefore); + // }); + }); +}); diff --git a/test/mainnet/pooltogether/pooltogether.test.ts b/test/mainnet/pooltogether/pooltogether.test.ts index 2aadfa8e..610a3bbe 100644 --- a/test/mainnet/pooltogether/pooltogether.test.ts +++ b/test/mainnet/pooltogether/pooltogether.test.ts @@ -1,811 +1,1225 @@ import { expect } from "chai"; import hre from "hardhat"; const { web3, deployments, waffle, ethers } = hre; -const { provider, deployContract } = waffle +const { provider, deployContract } = waffle; -import { deployAndEnableConnector } from "../../../scripts/tests/deployAndEnableConnector.js" -import { buildDSAv2 } from "../../../scripts/tests/buildDSAv2" -import { encodeSpells } from "../../../scripts/tests/encodeSpells.js" -import { getMasterSigner } from "../../../scripts/tests/getMasterSigner" +import { deployAndEnableConnector } from "../../../scripts/tests/deployAndEnableConnector"; +import { buildDSAv2 } from "../../../scripts/tests/buildDSAv2"; +import { encodeSpells } from "../../../scripts/tests/encodeSpells"; +import { getMasterSigner } from "../../../scripts/tests/getMasterSigner"; -import { addresses } from "../../../scripts/constant/addresses" -import { abis } from "../../../scripts/constant/abis" -import { constants } from "../../../scripts/constant/constant" -import { tokens } from "../../../scripts/constant/tokens" +import { addresses } from "../../../scripts/constant/addresses"; +import { abis } from "../../../scripts/constant/abis"; +import { constants } from "../../../scripts/constant/constant"; +import { tokens } from "../../../scripts/constant/tokens"; +import type { Signer, Contract } from "ethers"; -import connectV2CompoundArtifacts from "../../artifacts/contracts/mainnet/connectors/compound/main.sol/ConnectV2Compound.json" -import connectV2PoolTogetherArtifacts from "../../artifacts/contracts/mainnet/connectors/pooltogether/main.sol/ConnectV2PoolTogether.json" -import connectV2UniswapArtifacts from "../../artifacts/contracts/mainnet/connectors/uniswap/main.sol/ConnectV2UniswapV2.json" +import { + ConnectV2Compound__factory, + ConnectV2PoolTogether__factory, + ConnectV2UniswapV2__factory, +} from "../../../typechain"; -const DAI_TOKEN_ADDR = tokens.dai.address // DAI Token +const DAI_TOKEN_ADDR = tokens.dai.address; // DAI Token // PoolTogether Address: https://docs.pooltogether.com/resources/networks/ethereum -const DAI_PRIZE_POOL_ADDR = "0xEBfb47A7ad0FD6e57323C8A42B2E5A6a4F68fc1a" // DAI Prize Pool -const PT_DAI_TICKET_ADDR = "0x334cBb5858417Aee161B53Ee0D5349cCF54514CF" // PT DAI Ticket -const DAI_POOL_FAUCET_ADDR = "0xF362ce295F2A4eaE4348fFC8cDBCe8d729ccb8Eb" // DAI POOL Faucet -const POOL_TOKEN_ADDRESS = "0x0cEC1A9154Ff802e7934Fc916Ed7Ca50bDE6844e" // POOL Tocken -const TOKEN_FAUCET_PROXY_FACTORY_ADDR = "0xE4E9cDB3E139D7E8a41172C20b6Ed17b6750f117" // TokenFaucetProxyFactory for claimAll -const DAI_POD_ADDR = "0x2f994e2E4F3395649eeE8A89092e63Ca526dA829" // DAI Pod -const UNISWAP_POOLETHLP_PRIZE_POOL_ADDR = "0x3AF7072D29Adde20FC7e173a7CB9e45307d2FB0A" // Uniswap Pool/ETH LP PrizePool -const UNISWAP_POOLETHLP_FAUCET_ADDR = "0x9A29401EF1856b669f55Ae5b24505b3B6fAEb370" // Uniswap Pool/ETH LP Faucet -const UNISWAP_POOLETHLP_TOKEN_ADDR = "0x85cb0bab616fe88a89a35080516a8928f38b518b" // Uniswap Pool/ETH Token -const PT_UNISWAP_POOLETHLP_TICKET_ADDR = "0xeb8928ee92efb06c44d072a24c2bcb993b61e543" // Pool Together Uniswap Pool/ETH LP Ticket -const POOL_PRIZE_POOL_ADDR = "0x396b4489da692788e327e2e4b2b0459a5ef26791" // POOL Prize Pool -const PT_POOL_TICKET_ADDR = "0x27d22a7648e955e510a40bdb058333e9190d12d4" // Pool Together POOL Ticket -const WETH_ADDR = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2" // WETH -const DAI_POD_TOKEN_DROP = "0xc5209623E3dFdf9C0cCbe497c8012883C4147731" +const DAI_PRIZE_POOL_ADDR = "0xEBfb47A7ad0FD6e57323C8A42B2E5A6a4F68fc1a"; // DAI Prize Pool +const PT_DAI_TICKET_ADDR = "0x334cBb5858417Aee161B53Ee0D5349cCF54514CF"; // PT DAI Ticket +const DAI_POOL_FAUCET_ADDR = "0xF362ce295F2A4eaE4348fFC8cDBCe8d729ccb8Eb"; // DAI POOL Faucet +const POOL_TOKEN_ADDRESS = "0x0cEC1A9154Ff802e7934Fc916Ed7Ca50bDE6844e"; // POOL Tocken +const TOKEN_FAUCET_PROXY_FACTORY_ADDR = + "0xE4E9cDB3E139D7E8a41172C20b6Ed17b6750f117"; // TokenFaucetProxyFactory for claimAll +const DAI_POD_ADDR = "0x2f994e2E4F3395649eeE8A89092e63Ca526dA829"; // DAI Pod +const UNISWAP_POOLETHLP_PRIZE_POOL_ADDR = + "0x3AF7072D29Adde20FC7e173a7CB9e45307d2FB0A"; // Uniswap Pool/ETH LP PrizePool +const UNISWAP_POOLETHLP_FAUCET_ADDR = + "0x9A29401EF1856b669f55Ae5b24505b3B6fAEb370"; // Uniswap Pool/ETH LP Faucet +const UNISWAP_POOLETHLP_TOKEN_ADDR = + "0x85cb0bab616fe88a89a35080516a8928f38b518b"; // Uniswap Pool/ETH Token +const PT_UNISWAP_POOLETHLP_TICKET_ADDR = + "0xeb8928ee92efb06c44d072a24c2bcb993b61e543"; // Pool Together Uniswap Pool/ETH LP Ticket +const POOL_PRIZE_POOL_ADDR = "0x396b4489da692788e327e2e4b2b0459a5ef26791"; // POOL Prize Pool +const PT_POOL_TICKET_ADDR = "0x27d22a7648e955e510a40bdb058333e9190d12d4"; // Pool Together POOL Ticket +const WETH_ADDR = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"; // WETH +const DAI_POD_TOKEN_DROP = "0xc5209623E3dFdf9C0cCbe497c8012883C4147731"; // Community WETH Prize Pool (Rari): https://reference-app.pooltogether.com/pools/mainnet/0xa88ca010b32a54d446fc38091ddbca55750cbfc3/manage#stats -const WETH_PRIZE_POOL_ADDR = "0xa88ca010b32a54d446fc38091ddbca55750cbfc3" // Community WETH Prize Pool (Rari) -const WETH_POOL_TICKET_ADDR = "0x9b5c30aeb9ce2a6a121cea9a85bc0d662f6d9b40" // Community WETH Prize Pool Ticket (Rari) +const WETH_PRIZE_POOL_ADDR = "0xa88ca010b32a54d446fc38091ddbca55750cbfc3"; // Community WETH Prize Pool (Rari) +const WETH_POOL_TICKET_ADDR = "0x9b5c30aeb9ce2a6a121cea9a85bc0d662f6d9b40"; // Community WETH Prize Pool Ticket (Rari) const prizePoolABI = [ - "function calculateEarlyExitFee( address from, address controlledToken, uint256 amount) external returns ( uint256 exitFee, uint256 burnedCredit)" -] + "function calculateEarlyExitFee( address from, address controlledToken, uint256 amount) external returns ( uint256 exitFee, uint256 burnedCredit)", +]; const podABI = [ - "function getEarlyExitFee(uint256 amount) external returns (uint256)", - "function balanceOfUnderlying(address user) external view returns (uint256 amount)", - "function drop() public returns (uint256)", - "function balanceOf(address account) external view returns (uint256)" -] + "function getEarlyExitFee(uint256 amount) external returns (uint256)", + "function balanceOfUnderlying(address user) external view returns (uint256 amount)", + "function drop() public returns (uint256)", + "function balanceOf(address account) external view returns (uint256)", +]; -const POD_FACTORY_ADDRESS = "0x4e3a9f9fbafb2ec49727cffa2a411f7a0c1c4ce1" +const POD_FACTORY_ADDRESS = "0x4e3a9f9fbafb2ec49727cffa2a411f7a0c1c4ce1"; const podFactoryABI = [ - "function create( address _prizePool, address _ticket, address _faucet, address _manager, uint8 _decimals) external returns (address pod)" -] + "function create( address _prizePool, address _ticket, address _faucet, address _manager, uint8 _decimals) external returns (address pod)", +]; const tokenDropABI = [ - "function claim(address user) external returns (uint256)", -] + "function claim(address user) external returns (uint256)", +]; -describe("PoolTogether", function () { - const connectorName = "COMPOUND-TEST-A" - const uniswapConnectorName = "UNISWAP-TEST-A" - const ptConnectorName = "POOLTOGETHER-TEST-A" +describe("PoolTogether", function() { + const connectorName = "COMPOUND-TEST-A"; + const uniswapConnectorName = "UNISWAP-TEST-A"; + const ptConnectorName = "POOLTOGETHER-TEST-A"; - let dsaWallet0: any - let masterSigner: any; - let instaConnectorsV2: any; - let connector: any; - let ptConnector: any; - let uniswapConnector: any; + let dsaWallet0: any; + let masterSigner: Signer; + let instaConnectorsV2: Contract; + let connector: any; + let ptConnector: any; + let uniswapConnector: any; - const wallets = provider.getWallets() - const [wallet0, wallet1, wallet2, wallet3] = wallets - before(async () => { - masterSigner = await getMasterSigner(wallet3) - instaConnectorsV2 = await ethers.getContractAt(abis.core.connectorsV2, addresses.core.connectorsV2); + const wallets = provider.getWallets(); + const [wallet0, wallet1, wallet2, wallet3] = wallets; + before(async () => { + masterSigner = await getMasterSigner(); + instaConnectorsV2 = await ethers.getContractAt( + abis.core.connectorsV2, + addresses.core.connectorsV2 + ); - // Deploy and enable Compound Connector - connector = await deployAndEnableConnector({ - connectorName, - contractArtifact: connectV2CompoundArtifacts, - signer: masterSigner, - connectors: instaConnectorsV2 - }) - - // Deploy and enable Pool Together Connector - ptConnector = await deployAndEnableConnector({ - connectorName: ptConnectorName, - contractArtifact: connectV2PoolTogetherArtifacts, - signer: masterSigner, - connectors: instaConnectorsV2 - }) - - // Deploy and enable Uniswap Connector - uniswapConnector = await deployAndEnableConnector({ - connectorName: uniswapConnectorName, - contractArtifact: connectV2UniswapArtifacts, - signer: masterSigner, - connectors: instaConnectorsV2 - }) - }) - - it("Should have contracts deployed.", async function () { - expect(!!instaConnectorsV2.address).to.be.true; - expect(!!connector.address).to.be.true; - expect(!!ptConnector.address).to.be.true; - expect(!!uniswapConnector.address).to.be.true; - expect(!!masterSigner.address).to.be.true; + // Deploy and enable Compound Connector + connector = await deployAndEnableConnector({ + connectorName, + contractArtifact: ConnectV2Compound__factory, + signer: masterSigner, + connectors: instaConnectorsV2, }); - describe("DSA wallet setup", function () { - it("Should build DSA v2", async function () { - dsaWallet0 = await buildDSAv2(wallet0.address) - expect(!!dsaWallet0.address).to.be.true; - }); - - it("Deposit 10 ETH into DSA wallet", async function () { - await wallet0.sendTransaction({ - to: dsaWallet0.address, - value: ethers.utils.parseEther("10") - }); - expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.gte(ethers.utils.parseEther("10")); - }); + // Deploy and enable Pool Together Connector + ptConnector = await deployAndEnableConnector({ + connectorName: ptConnectorName, + contractArtifact: ConnectV2PoolTogether__factory, + signer: masterSigner, + connectors: instaConnectorsV2, }); - describe("Main - DAI Prize Pool Test", function () { - - it("Should deposit 1 ETH in Compound", async function () { - const amount = ethers.utils.parseEther("1") // 1 ETH - const spells = [ - { - connector: connectorName, - method: "deposit", - args: ["ETH-A", amount, 0, 0] - } - ] - - const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet1.address) - const receipt = await tx.wait() - expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.lte(ethers.utils.parseEther("9")); - }); - - it("Should borrow 100 DAI from Compound and deposit DAI into DAI Prize Pool", async function () { - const amount = ethers.utils.parseEther("100") // 100 DAI - const setId = "83478237" - const spells = [ - { - connector: connectorName, - method: "borrow", - args: ["DAI-A", amount, 0, setId] - }, - { - connector: ptConnectorName, - method: "depositTo", - args: [DAI_PRIZE_POOL_ADDR, amount, PT_DAI_TICKET_ADDR, setId, 0] - } - ] - // Before Spell - let daiToken = await ethers.getContractAt(abis.basic.erc20, DAI_TOKEN_ADDR) - let daiBalance = await daiToken.balanceOf(dsaWallet0.address); - expect(daiBalance, `DAI balance is 0`).to.be.eq(ethers.utils.parseEther("0")); - - let cToken = await ethers.getContractAt(abis.basic.erc20, PT_DAI_TICKET_ADDR) - const balance = await cToken.balanceOf(dsaWallet0.address) - expect(balance, `PoolTogether DAI Ticket balance is 0`).to.be.eq(0); - - // Run spell transaction - const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet1.address) - const receipt = await tx.wait() - - // After spell - daiBalance = await daiToken.balanceOf(dsaWallet0.address); - expect(daiBalance, `Expect DAI balance to still equal 0 since it was deposited into Prize Pool`).to.be.eq(0); - - const balanceAfter = await cToken.balanceOf(dsaWallet0.address) - expect(balanceAfter, `PoolTogether DAI Ticket balance equals 100`).to.be.eq(ethers.utils.parseEther("100")); - - // ETH used for transaction - expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.lte(ethers.utils.parseEther("9")); - }); - - it("Should wait 11 days, withdraw all PrizePool, get back 100 DAI, and claim POOL", async function () { - const amount = ethers.utils.parseEther("100") // 100 DAI - - let prizePoolContract = new ethers.Contract(DAI_PRIZE_POOL_ADDR, prizePoolABI, ethers.provider); - let earlyExitFee = await prizePoolContract.callStatic["calculateEarlyExitFee"](dsaWallet0.address, PT_DAI_TICKET_ADDR, amount); - expect(earlyExitFee.exitFee, "Exit Fee equal to 1 DAI because starts at 10%").to.be.eq(ethers.utils.parseEther("1")); - - const spells = [ - { - connector: ptConnectorName, - method: "withdrawInstantlyFrom", - args: [DAI_PRIZE_POOL_ADDR, amount, PT_DAI_TICKET_ADDR, earlyExitFee.exitFee, 0, 0] - }, - { - connector: ptConnectorName, - method: "claim", - args: [DAI_POOL_FAUCET_ADDR, 0] - } - ] - - // Before spell - let daiToken = await ethers.getContractAt(abis.basic.erc20, DAI_TOKEN_ADDR) - let daiBalance = await daiToken.balanceOf(dsaWallet0.address); - expect(daiBalance, `DAI balance equals 0`).to.be.eq(ethers.utils.parseEther("0")); - - let cToken = await ethers.getContractAt(abis.basic.erc20, PT_DAI_TICKET_ADDR) - const balance = await cToken.balanceOf(dsaWallet0.address) - expect(balance, `PoolTogether Dai Ticket is 100`).to.be.eq(ethers.utils.parseEther("100")); - - let poolToken = await ethers.getContractAt(abis.basic.erc20, POOL_TOKEN_ADDRESS) - const poolBalance = await poolToken.balanceOf(dsaWallet0.address) - expect(poolBalance, `POOL Token equals 0`).to.be.eq(ethers.utils.parseEther("0")); - - // Increase time by 11 days so we get back all DAI without early withdrawal fee - await ethers.provider.send("evm_increaseTime", [11 * 24 * 60 * 60]); - await ethers.provider.send("evm_mine"); - - earlyExitFee = await prizePoolContract.callStatic["calculateEarlyExitFee"](dsaWallet0.address, PT_DAI_TICKET_ADDR, amount); - expect(earlyExitFee.exitFee, "Exit Fee equal to 0 DAI because past 10 days").to.be.eq(0); - - // Run spell transaction - const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet1.address) - const receipt = await tx.wait() - - // After spell - daiBalance = await daiToken.balanceOf(dsaWallet0.address); - expect(daiBalance, - `DAI balance to be equal to 100, because of no early withdrawal fee` - ).to.be.eq(ethers.utils.parseEther("100")); - - const balanceAfter = await cToken.balanceOf(dsaWallet0.address) - expect(balanceAfter, `PoolTogether Dai Ticket to equal 0`).to.be.eq(0); - - const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address) - expect(poolBalanceAfter, `POOL Token Balance to be greater than 0`).to.be.gt(ethers.utils.parseEther("0")); - }); - - it("Should deposit and withdraw all PrizePool, get back less than 100 DAI", async function () { - const amount = ethers.utils.parseEther("100") // 100 DAI - const exitFee = ethers.utils.parseEther("1") // 1 DAI is 10% of 100 DAI - const spells = [ - { - connector: ptConnectorName, - method: "depositTo", - args: [DAI_PRIZE_POOL_ADDR, amount, PT_DAI_TICKET_ADDR, 0, 0] - }, - { - connector: ptConnectorName, - method: "withdrawInstantlyFrom", - args: [DAI_PRIZE_POOL_ADDR, amount, PT_DAI_TICKET_ADDR, exitFee, 0, 0] - } - ] - - // Before spell - let daiToken = await ethers.getContractAt(abis.basic.erc20, DAI_TOKEN_ADDR) - let daiBalance = await daiToken.balanceOf(dsaWallet0.address); - expect(daiBalance, `DAI Balance equals 0`).to.be.eq(ethers.utils.parseEther("100")); - - let cToken = await ethers.getContractAt(abis.basic.erc20, PT_DAI_TICKET_ADDR) - const balance = await cToken.balanceOf(dsaWallet0.address) - expect(balance, `PoolTogether DAI Ticket equals 0`).to.be.eq(0); - - let poolToken = await ethers.getContractAt(abis.basic.erc20, POOL_TOKEN_ADDRESS) - const poolBalance = await poolToken.balanceOf(dsaWallet0.address) - expect(poolBalance, `PoolTogether Token greater than 0`).to.be.gt(0); - - // Run spell transaction - const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet1.address) - const receipt = await tx.wait() - - // After spell - daiBalance = await daiToken.balanceOf(dsaWallet0.address); - expect(daiBalance, - `DAI balance to be less than 100, because of early withdrawal fee` - ).to.be.lt(ethers.utils.parseEther("100")); - - const balanceAfter = await cToken.balanceOf(dsaWallet0.address) - expect(balanceAfter, `PoolTogether Dai Ticket to equal 0`).to.be.eq(0); - - const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address) - expect(poolBalanceAfter, `POOL Token Balance to greater than 0`).to.be.gt(ethers.utils.parseEther("0")); - - }); - - it("Should deposit, wait 11 days, and withdraw all PrizePool, get 99 DAI, and claim all POOL using claimAll", async function () { - const amount = ethers.utils.parseEther("99") // 99 DAI - const depositSpells = [ - { - connector: ptConnectorName, - method: "depositTo", - args: [DAI_PRIZE_POOL_ADDR, amount, PT_DAI_TICKET_ADDR, 0, 0] - } - ] - - // Before spell - let daiToken = await ethers.getContractAt(abis.basic.erc20, DAI_TOKEN_ADDR) - let daiBalance = await daiToken.balanceOf(dsaWallet0.address); - expect(daiBalance, `DAI balance less than 100`).to.be.lt(ethers.utils.parseEther("100")); - - let cToken = await ethers.getContractAt(abis.basic.erc20, PT_DAI_TICKET_ADDR) - const balance = await cToken.balanceOf(dsaWallet0.address) - expect(balance, `PoolTogether DAI Ticket equal 0`).to.be.eq(0); - - let poolToken = await ethers.getContractAt(abis.basic.erc20, POOL_TOKEN_ADDRESS) - const poolBalance = await poolToken.balanceOf(dsaWallet0.address) - expect(poolBalance, `POOL Token is greater than 0`).to.be.gt(ethers.utils.parseEther("0")); - - // Run spell transaction - const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(depositSpells), wallet1.address) - const receipt = await tx.wait() - - const prizePoolContract = new ethers.Contract(DAI_PRIZE_POOL_ADDR, prizePoolABI, ethers.provider); - let earlyExitFee = await prizePoolContract.callStatic["calculateEarlyExitFee"](dsaWallet0.address, PT_DAI_TICKET_ADDR, amount); - expect(earlyExitFee.exitFee, "Exit Fee equal to .99 DAI because starts at 10%").to.be.eq(ethers.utils.parseEther(".99")); - - - // Increase time by 11 days so we get back all DAI without early withdrawal fee - await ethers.provider.send("evm_increaseTime", [11 * 24 * 60 * 60]); - await ethers.provider.send("evm_mine"); - - earlyExitFee = await prizePoolContract.callStatic["calculateEarlyExitFee"](dsaWallet0.address, PT_DAI_TICKET_ADDR, amount); - expect(earlyExitFee.exitFee, "Exit Fee equal to 0 DAI because past 10 days").to.be.eq(0); - - const withdrawSpells = [ - { - connector: ptConnectorName, - method: "withdrawInstantlyFrom", - args: [DAI_PRIZE_POOL_ADDR, amount, PT_DAI_TICKET_ADDR, earlyExitFee.exitFee, 0, 0] - }, - { - connector: ptConnectorName, - method: "claimAll", - args: [TOKEN_FAUCET_PROXY_FACTORY_ADDR, [DAI_POOL_FAUCET_ADDR]] - } - ] - - // Run spell transaction - const tx2 = await dsaWallet0.connect(wallet0).cast(...encodeSpells(withdrawSpells), wallet1.address) - const receipt2 = await tx2.wait() - - // After spell - daiBalance = await daiToken.balanceOf(dsaWallet0.address); - expect(daiBalance, `DAI balance equals 99`).to.be.eq(ethers.utils.parseEther("99")); - - const balanceAfter = await cToken.balanceOf(dsaWallet0.address) - expect(balanceAfter, `PoolTogether DAI Ticket equal 0`).to.be.eq(0); - - // Expect - const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address) - expect(poolBalanceAfter, `Pool Token to be greateir than 0`).to.be.gt(ethers.utils.parseEther("0")); - }); - }) - - describe("Main - DAI Pod Test", function () { - it("Should deposit 99 DAI in DAI Pod", async function () { - const amount = ethers.utils.parseEther("99") // 99 DAI - const spells = [ - { - connector: ptConnectorName, - method: "depositToPod", - args: [DAI_TOKEN_ADDR, DAI_POD_ADDR, amount, 0, 0] - } - ] - - // Before spell - let daiToken = await ethers.getContractAt(abis.basic.erc20, DAI_TOKEN_ADDR) - let daiBalance = await daiToken.balanceOf(dsaWallet0.address); - expect(daiBalance, `DAI balance equals 99`).to.be.eq(ethers.utils.parseEther("99")); - - let poolToken = await ethers.getContractAt(abis.basic.erc20, POOL_TOKEN_ADDRESS) - const poolBalance = await poolToken.balanceOf(dsaWallet0.address) - expect(poolBalance, `POOL Token greater than 0`).to.be.gt(0); - - let podToken = await ethers.getContractAt(abis.basic.erc20, DAI_POD_ADDR) - const podBalance = await podToken.balanceOf(dsaWallet0.address) - expect(podBalance, `Pod DAI Token equals 0`).to.be.eq(0); - - // Run spell transaction - const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet1.address) - const receipt = await tx.wait() - - // After spell - daiBalance = await daiToken.balanceOf(dsaWallet0.address); - expect(daiBalance, `DAI equals 0`).to.be.eq(0); - - const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address) - expect(poolBalanceAfter, `POOL Token greater than 0`).to.be.gt(0); - - const podBalanceAfter = await podToken.balanceOf(dsaWallet0.address) - expect(podBalanceAfter, `Pod DAI token greater than 0`).to.be.eq(ethers.utils.parseEther("99")); - }); - - it("Should claim rewards from pod token drop", async function () { - const spells = [ - { - connector: ptConnectorName, - method: "claimPodTokenDrop", - args: [DAI_POD_TOKEN_DROP, 0] - } - ] - - const tokenDropContract = new ethers.Contract(DAI_POD_TOKEN_DROP, tokenDropABI, ethers.provider); - const podContract = new ethers.Contract(DAI_POD_ADDR, podABI, masterSigner); - - // drop(): Claim TokenDrop asset for PrizePool Pod and transfers token(s) to external Pod TokenDrop - // dropt() also calls batch which, Deposit Pod float into PrizePool. Deposits the current float - // amount into the PrizePool and claims current POOL rewards. - const dropTx = await podContract.drop(); - await dropTx.wait(); - - // POOL Rewards able to claim from Pod Token Drop - let claimAmount = await tokenDropContract.callStatic["claim"](dsaWallet0.address); - - // Before spell - let poolToken = await ethers.getContractAt(abis.basic.erc20, POOL_TOKEN_ADDRESS) - const poolBalance = await poolToken.balanceOf(dsaWallet0.address) - expect(poolBalance, `POOL Token greater than 0`).to.be.gt(0); - - // Run spell transaction - const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet1.address) - const receipt = await tx.wait() - - // After spell - const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address) - const total = claimAmount.add(poolBalance); - expect(poolBalanceAfter, `POOL Token same as before spell`).to.be.eq(total); - }); - - it("Should wait 11 days, withdraw all podTokens, get back 99 DAI", async function () { - const amount = ethers.utils.parseEther("99") // 99 DAI - - const podContract = new ethers.Contract(DAI_POD_ADDR, podABI, ethers.provider); - let maxFee = await podContract.callStatic["getEarlyExitFee"](amount); - // maxFee depends on if token has been deposited to PrizePool yet - // since we called drop in previous test case, the tokens were deposited to PrizePool - expect(maxFee, "Exit Fee equal to .99 DAI because token still in float").to.be.eq(ethers.utils.parseEther(".99")); - - const spells = [ - { - connector: ptConnectorName, - method: "withdrawFromPod", - args: [DAI_POD_ADDR, amount, maxFee, 0, 0] - } - ] - - // Before spell - let daiToken = await ethers.getContractAt(abis.basic.erc20, DAI_TOKEN_ADDR) - let daiBalance = await daiToken.balanceOf(dsaWallet0.address); - expect(daiBalance, `DAI Balance equals 0`).to.be.eq(0); - - let poolToken = await ethers.getContractAt(abis.basic.erc20, POOL_TOKEN_ADDRESS) - const poolBalance = await poolToken.balanceOf(dsaWallet0.address) - expect(poolBalance, `POOL Token balance greater than 0`).to.be.gt(0); - - let podToken = await ethers.getContractAt(abis.basic.erc20, DAI_POD_ADDR) - const podBalance = await podToken.balanceOf(dsaWallet0.address) - expect(podBalance, `Pod DAI Token equals 99`).to.be.eq(ethers.utils.parseEther("99")); - - // Increase time by 11 days so we get back all DAI without early withdrawal fee - await ethers.provider.send("evm_increaseTime", [11 * 24 * 60 * 60]); - await ethers.provider.send("evm_mine"); - - // Run spell transaction - const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet1.address) - const receipt = await tx.wait() - - // After spell - daiBalance = await daiToken.balanceOf(dsaWallet0.address); - expect(daiBalance, - `DAI balance equals 99, because of no early withdrawal fee` - ).to.be.eq(ethers.utils.parseEther("99")); - - const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address) - expect(poolBalanceAfter, `POOL Token to be greater than 0`).to.be.gt(0); - - const podBalanceAfter = await podToken.balanceOf(dsaWallet0.address) - expect(podBalanceAfter, `Pod DAI Token equals 0`).to.be.eq(0); - }); - - - - - it("Should deposit and withdraw from pod, get back same amount of 99 DAI", async function () { - const amount = ethers.utils.parseEther("99") - const maxFee = 0; // maxFee 0 since it doesn't give chance for Pod to actually deposit into PrizePool - - const spells = [ - { - connector: ptConnectorName, - method: "depositToPod", - args: [DAI_TOKEN_ADDR, DAI_POD_ADDR, amount, 0, 0] - }, - { - connector: ptConnectorName, - method: "withdrawFromPod", - args: [DAI_POD_ADDR, amount, maxFee, 0, 0] - } - ] - - // Before spell - let daiToken = await ethers.getContractAt(abis.basic.erc20, DAI_TOKEN_ADDR) - let daiBalance = await daiToken.balanceOf(dsaWallet0.address); - expect(daiBalance, `DAI equals 99`).to.be.eq(ethers.utils.parseEther("99")); - - let poolToken = await ethers.getContractAt(abis.basic.erc20, POOL_TOKEN_ADDRESS) - const poolBalance = await poolToken.balanceOf(dsaWallet0.address) - expect(poolBalance, `POOL Token greater than 0`).to.be.gt(0); - - // PodToken is 0 - let podToken = await ethers.getContractAt(abis.basic.erc20, DAI_POD_ADDR) - const podBalance = await podToken.balanceOf(dsaWallet0.address) - expect(podBalance, `Pod DAI Token equals 0`).to.be.eq(0); - - // Run spell transaction - const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet1.address) - const receipt = await tx.wait() - - // After spell - daiBalance = await daiToken.balanceOf(dsaWallet0.address); - expect(daiBalance, - `DAI balance to be equal to 99, because funds still in 'float` - ).to.be.eq(ethers.utils.parseEther("99")); - - const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address) - expect(poolBalanceAfter, `POOL Token same as before spell`).to.be.eq(poolBalance); - - // Expect Pod Token Balance to equal 0 - const podBalanceAfter = await podToken.balanceOf(dsaWallet0.address) - expect(podBalanceAfter, `Pod DAI Token equals 0`).to.be.eq(ethers.utils.parseEther("0")); - }); - }) - - describe("Main - UNISWAP POOL/ETH Prize Pool Test", function () { - it("Should use uniswap to swap ETH for POOL, deposit to POOL/ETH LP, deposit POOL/ETH LP to PrizePool", async function () { - const amount = ethers.utils.parseEther("100") // 100 POOL - const slippage = ethers.utils.parseEther("0.03"); - const setId = "83478237" - - const UniswapV2Router02ABI = [ - "function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts)" - ]; - - // Get amount of ETH for 100 POOL from Uniswap - const UniswapV2Router02 = await ethers.getContractAt(UniswapV2Router02ABI, "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D"); - const amounts = await UniswapV2Router02.getAmountsOut(amount, [POOL_TOKEN_ADDRESS, WETH_ADDR]); - const unitAmount = ethers.utils.parseEther(((amounts[1] * 1.03) / amounts[0]).toString()); - - const spells = [ - { - connector: uniswapConnectorName, - method: "buy", - args: [POOL_TOKEN_ADDRESS, tokens.eth.address, amount, unitAmount, 0, setId] - }, - { - connector: uniswapConnectorName, - method: "deposit", - args: [POOL_TOKEN_ADDRESS, tokens.eth.address, amount, unitAmount, slippage, 0, setId] - }, - { - connector: ptConnectorName, - method: "depositTo", - args: [UNISWAP_POOLETHLP_PRIZE_POOL_ADDR, 0, PT_UNISWAP_POOLETHLP_TICKET_ADDR, setId, 0] - } - ] - - // Before Spell - let ethBalance = await ethers.provider.getBalance(dsaWallet0.address); - expect(ethBalance, `ETH Balance equals 9`).to.be.eq(ethers.utils.parseEther("9")); - - let poolToken = await ethers.getContractAt(abis.basic.erc20, POOL_TOKEN_ADDRESS) - const poolBalance = await poolToken.balanceOf(dsaWallet0.address) - expect(poolBalance, `POOL Token greater than 0`).to.be.gt(0); - - let uniswapLPToken = await ethers.getContractAt(abis.basic.erc20, UNISWAP_POOLETHLP_TOKEN_ADDR) - const uniswapPoolEthBalance = await uniswapLPToken.balanceOf(dsaWallet0.address) - expect(uniswapPoolEthBalance, `Uniswap POOL/ETH LP equals 0`).to.be.eq(0); - - let ptUniswapPoolEthToken = await ethers.getContractAt(abis.basic.erc20, PT_UNISWAP_POOLETHLP_TICKET_ADDR) - const ptUniswapPoolEthBalance = await ptUniswapPoolEthToken.balanceOf(dsaWallet0.address) - expect(ptUniswapPoolEthBalance, `PoolTogether Uniswap POOL?ETH LP equals 0`).to.be.eq(0); - - // Run spell transaction - const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet1.address) - const receipt = await tx.wait() - - // After spell - ethBalance = await ethers.provider.getBalance(dsaWallet0.address); - expect(ethBalance, `ETH Balance less than 9`).to.be.lt(ethers.utils.parseEther("9")); - - const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address) - expect(poolBalanceAfter, `POOL Token to be same after spell`).to.be.eq(poolBalance); - - const uniswapPoolEthBalanceAfter = await uniswapLPToken.balanceOf(dsaWallet0.address) - expect(uniswapPoolEthBalanceAfter, `Uniswap POOL/ETH LP equals 0`).to.be.eq(0); - - const ptUniswapPoolEthBalanceAfter = await ptUniswapPoolEthToken.balanceOf(dsaWallet0.address) - expect(ptUniswapPoolEthBalanceAfter, `PT Uniswap POOL/ETH LP to greater than 0`).to.be.gt(0); - }); - - it("Should withdraw all PrizePool, get back Uniswap LP, claim POOL, deposit claimed POOL into Pool PrizePool", async function () { - let ptUniswapPoolEthToken = await ethers.getContractAt(abis.basic.erc20, PT_UNISWAP_POOLETHLP_TICKET_ADDR) - const ptUniswapPoolEthBalance = await ptUniswapPoolEthToken.balanceOf(dsaWallet0.address) - const setId = "83478237" - - let uniswapPrizePoolContract = new ethers.Contract(UNISWAP_POOLETHLP_PRIZE_POOL_ADDR, prizePoolABI, ethers.provider); - let earlyExitFee = await uniswapPrizePoolContract.callStatic["calculateEarlyExitFee"](dsaWallet0.address, PT_UNISWAP_POOLETHLP_TICKET_ADDR, ptUniswapPoolEthBalance); - expect(earlyExitFee.exitFee, "Exit Fee equals 0 because no early exit fee for this prize pool").to.be.eq(0); - - const spells = [ - { - connector: ptConnectorName, - method: "withdrawInstantlyFrom", - args: [UNISWAP_POOLETHLP_PRIZE_POOL_ADDR, ptUniswapPoolEthBalance, PT_UNISWAP_POOLETHLP_TICKET_ADDR, earlyExitFee.exitFee, 0, 0] - }, - { - connector: ptConnectorName, - method: "claim", - args: [UNISWAP_POOLETHLP_FAUCET_ADDR, setId] - }, - { - connector: ptConnectorName, - method: "depositTo", - args: [POOL_PRIZE_POOL_ADDR, 0, PT_POOL_TICKET_ADDR, setId, 0] - } - ] - - // Before spell - let poolToken = await ethers.getContractAt(abis.basic.erc20, POOL_TOKEN_ADDRESS) - const poolBalance = await poolToken.balanceOf(dsaWallet0.address) - expect(poolBalance, `POOL Token greater than 0`).to.be.gt(0); - - // Uniswap POOL/ETH LP is 0 - let uniswapLPToken = await ethers.getContractAt(abis.basic.erc20, UNISWAP_POOLETHLP_TOKEN_ADDR) - const uniswapPoolEthBalance = await uniswapLPToken.balanceOf(dsaWallet0.address) - expect(uniswapPoolEthBalance, `Uniswap POOL/ETH LP equals 0`).to.be.eq(0); - - expect(ptUniswapPoolEthBalance, `PT Uniswap POOL/ETH LP greater than 0`).to.be.gt(0); - - let poolPoolTicket = await ethers.getContractAt(abis.basic.erc20, PT_POOL_TICKET_ADDR) - const poolPoolTicketBalance = await poolPoolTicket.balanceOf(dsaWallet0.address) - expect(poolPoolTicketBalance, `PoolTogether POOL Ticket equals 0`).to.be.eq(0); - - // Run spell transaction - const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet1.address) - const receipt = await tx.wait() - - // After spell - const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address) - expect(poolBalanceAfter, `Pool Token Balance equal to balance before spell`).to.be.eq(poolBalance); - - const uniswapPoolEthBalanceAfter = await uniswapLPToken.balanceOf(dsaWallet0.address) - expect(uniswapPoolEthBalanceAfter, `Uniswap POOL/ETH LP to greater than 0`).to.be.gt(0); - - const ptUniswapPoolEthBalanceAfter = await ptUniswapPoolEthToken.balanceOf(dsaWallet0.address) - expect(ptUniswapPoolEthBalanceAfter, `PT Uniswap POOL/ETH LP equal 0`).to.be.eq(0); - - const poolPoolTicketBalanceAfter = await poolPoolTicket.balanceOf(dsaWallet0.address) - expect(poolPoolTicketBalanceAfter, `PoolTogether POOL Ticket greater than 0`).to.be.gt(0); - }); - }) - - describe("Main - WETH Prize Pool Test", function () { - it("Deposit 1 ETH into WETH Prize Pool and withdraw immediately", async function () { - const amount = ethers.utils.parseEther("1") // 1 ETH - const setId = "83478237" - const spells = [ - { - connector: ptConnectorName, - method: "depositTo", - args: [WETH_PRIZE_POOL_ADDR, amount, WETH_POOL_TICKET_ADDR, 0, setId] - }, - { - connector: ptConnectorName, - method: "withdrawInstantlyFrom", - args: [WETH_PRIZE_POOL_ADDR, amount, WETH_POOL_TICKET_ADDR, amount, setId, 0] - }, - ] - // Before Spell - const ethBalanceBefore = await ethers.provider.getBalance(dsaWallet0.address); - - // Run spell transaction - const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet1.address) - const receipt = await tx.wait() - - // After spell - const ethBalanceAfter = await ethers.provider.getBalance(dsaWallet0.address); - - // ETH used for transaction - expect(ethBalanceAfter, `ETH Balance less than before spell because of early withdrawal fee`).to.be.lte(ethBalanceBefore); - }); - - it("Deposit 1 ETH into WETH Prize Pool, wait 14 days, then withdraw", async function () { - const amount = ethers.utils.parseEther("1") // 1 ETH - const depositSpell = [ - { - connector: ptConnectorName, - method: "depositTo", - args: [WETH_PRIZE_POOL_ADDR, amount, WETH_POOL_TICKET_ADDR, 0, 0] - } - ] - - const withdrawSpell = [ - { - connector: ptConnectorName, - method: "withdrawInstantlyFrom", - args: [WETH_PRIZE_POOL_ADDR, amount, WETH_POOL_TICKET_ADDR, amount, 0, 0] - } - ] - - // Before Deposit Spell - let ethBalanceBefore = await ethers.provider.getBalance(dsaWallet0.address); - - // Run deposit spell transaction - const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(depositSpell), wallet1.address) - const receipt = await tx.wait() - - // After Deposit spell - let ethBalanceAfter = await ethers.provider.getBalance(dsaWallet0.address); - - expect(ethBalanceAfter, `ETH Balance less than before spell`).to.be.lte(ethBalanceBefore); - - // Increase time by 11 days so we get back all ETH without early withdrawal fee - await ethers.provider.send("evm_increaseTime", [14 * 24 * 60 * 60]); - await ethers.provider.send("evm_mine"); - - // Run withdraw spell transaction - const tx2 = await dsaWallet0.connect(wallet0).cast(...encodeSpells(withdrawSpell), wallet1.address) - const receipt2 = await tx.wait() - - // After Deposit spell - ethBalanceAfter = await ethers.provider.getBalance(dsaWallet0.address); - - expect(ethBalanceAfter, `ETH Balance equal to before spell because no early exit fee`).to.be.eq(ethBalanceBefore); - }); + // Deploy and enable Uniswap Connector + uniswapConnector = await deployAndEnableConnector({ + connectorName: uniswapConnectorName, + contractArtifact: ConnectV2UniswapV2__factory, + signer: masterSigner, + connectors: instaConnectorsV2, + }); + }); + + it("Should have contracts deployed.", async function() { + expect(!!instaConnectorsV2.address).to.be.true; + expect(!!connector.address).to.be.true; + expect(!!ptConnector.address).to.be.true; + expect(!!uniswapConnector.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.address); + expect(!!dsaWallet0.address).to.be.true; }); - describe("Main - WETH Pod Test", function () { - let podAddress - it("Should deposit 1 ETH in WETH Pod and get Pod Ticket", async function () { - const amount = ethers.utils.parseEther("1") - - // Create Pod for WETH Prize Pool (Rari) - const podFactoryContract = new ethers.Contract(POD_FACTORY_ADDRESS, podFactoryABI, masterSigner) - podAddress = await podFactoryContract.callStatic.create(WETH_PRIZE_POOL_ADDR, WETH_POOL_TICKET_ADDR, constants.address_zero, wallet0.address, 18) - await podFactoryContract.create(WETH_PRIZE_POOL_ADDR, WETH_POOL_TICKET_ADDR, constants.address_zero, wallet0.address, 18) - - const spells = [ - { - connector: ptConnectorName, - method: "depositToPod", - args: [WETH_ADDR, podAddress, amount, 0, 0] - } - ] - - // Before Deposit Spell - const podContract = new ethers.Contract(podAddress, podABI, ethers.provider); - let podBalanceBefore = await podContract.balanceOfUnderlying(dsaWallet0.address) - expect(podBalanceBefore, `Pod balance equal to 0`).to.be.eq(0); - - let ethBalanceBefore = await ethers.provider.getBalance(dsaWallet0.address); - - // Run spell transaction - const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet1.address) - const receipt = await tx.wait() - - // After Deposit spell - let ethBalanceAfter = await ethers.provider.getBalance(dsaWallet0.address); - expect(ethBalanceAfter, `ETH balance less than before`).to.be.lt(ethBalanceBefore); - - podBalanceAfter = await podContract.balanceOfUnderlying(dsaWallet0.address) - expect(podBalanceAfter, `Pod balance equal to 1`).to.be.eq(ethers.utils.parseEther("1")); - }); - - it("Should withdraw 1 Ticket from WETH Pod and get back ETH", async function () { - const amount = ethers.utils.parseEther("1") - - const podContract = new ethers.Contract(podAddress, podABI, ethers.provider); - let maxFee = await podContract.callStatic["getEarlyExitFee"](amount); - expect(maxFee, "Exit Fee equal to 0 DAI because token still in float").to.be.eq(0); - // maxFee depends on if token has been deposited to PrizePool yet - - const spells = [ - { - connector: ptConnectorName, - method: "withdrawFromPod", - args: [podAddress, amount, maxFee, 0, 0] - } - ] - - // Before Deposit Spell - let podBalanceBefore = await podContract.balanceOfUnderlying(dsaWallet0.address) - expect(podBalanceBefore, `Pod balance equal to 1`).to.be.eq(ethers.utils.parseEther("1")); - - let ethBalanceBefore = await ethers.provider.getBalance(dsaWallet0.address); - - // Run spell transaction - const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet1.address) - const receipt = await tx.wait() - - // After Deposit spell - let ethBalanceAfter = await ethers.provider.getBalance(dsaWallet0.address); - expect(ethBalanceAfter, `ETH balance greater than before`).to.be.gt(ethBalanceBefore); - - podBalanceAfter = await podContract.balanceOfUnderlying(dsaWallet0.address) - expect(podBalanceAfter, `Pod balance equal to 0`).to.be.eq(ethers.utils.parseEther("0")); - }); + it("Deposit 10 ETH into DSA wallet", async function() { + await wallet0.sendTransaction({ + to: dsaWallet0.address, + value: ethers.utils.parseEther("10"), + }); + expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.gte( + ethers.utils.parseEther("10") + ); }); -}) \ No newline at end of file + }); + + describe("Main - DAI Prize Pool Test", function() { + it("Should deposit 1 ETH in Compound", async function() { + const amount = ethers.utils.parseEther("1"); // 1 ETH + const spells = [ + { + connector: connectorName, + method: "deposit", + args: ["ETH-A", amount, 0, 0], + }, + ]; + + const tx = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(spells), wallet1.address); + const receipt = await tx.wait(); + expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.lte( + ethers.utils.parseEther("9") + ); + }); + + it("Should borrow 100 DAI from Compound and deposit DAI into DAI Prize Pool", async function() { + const amount = ethers.utils.parseEther("100"); // 100 DAI + const setId = "83478237"; + const spells = [ + { + connector: connectorName, + method: "borrow", + args: ["DAI-A", amount, 0, setId], + }, + { + connector: ptConnectorName, + method: "depositTo", + args: [DAI_PRIZE_POOL_ADDR, amount, PT_DAI_TICKET_ADDR, setId, 0], + }, + ]; + // Before Spell + let daiToken = await ethers.getContractAt( + abis.basic.erc20, + DAI_TOKEN_ADDR + ); + let daiBalance = await daiToken.balanceOf(dsaWallet0.address); + expect(daiBalance, `DAI balance is 0`).to.be.eq( + ethers.utils.parseEther("0") + ); + + let cToken = await ethers.getContractAt( + abis.basic.erc20, + PT_DAI_TICKET_ADDR + ); + const balance = await cToken.balanceOf(dsaWallet0.address); + expect(balance, `PoolTogether DAI Ticket balance is 0`).to.be.eq(0); + + // Run spell transaction + const tx = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(spells), wallet1.address); + const receipt = await tx.wait(); + + // After spell + daiBalance = await daiToken.balanceOf(dsaWallet0.address); + expect( + daiBalance, + `Expect DAI balance to still equal 0 since it was deposited into Prize Pool` + ).to.be.eq(0); + + const balanceAfter = await cToken.balanceOf(dsaWallet0.address); + expect( + balanceAfter, + `PoolTogether DAI Ticket balance equals 100` + ).to.be.eq(ethers.utils.parseEther("100")); + + // ETH used for transaction + expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.lte( + ethers.utils.parseEther("9") + ); + }); + + it("Should wait 11 days, withdraw all PrizePool, get back 100 DAI, and claim POOL", async function() { + const amount = ethers.utils.parseEther("100"); // 100 DAI + + let prizePoolContract = new ethers.Contract( + DAI_PRIZE_POOL_ADDR, + prizePoolABI, + ethers.provider + ); + let earlyExitFee = await prizePoolContract.callStatic[ + "calculateEarlyExitFee" + ](dsaWallet0.address, PT_DAI_TICKET_ADDR, amount); + expect( + earlyExitFee.exitFee, + "Exit Fee equal to 1 DAI because starts at 10%" + ).to.be.eq(ethers.utils.parseEther("1")); + + const spells = [ + { + connector: ptConnectorName, + method: "withdrawInstantlyFrom", + args: [ + DAI_PRIZE_POOL_ADDR, + amount, + PT_DAI_TICKET_ADDR, + earlyExitFee.exitFee, + 0, + 0, + ], + }, + { + connector: ptConnectorName, + method: "claim", + args: [DAI_POOL_FAUCET_ADDR, 0], + }, + ]; + + // Before spell + let daiToken = await ethers.getContractAt( + abis.basic.erc20, + DAI_TOKEN_ADDR + ); + let daiBalance = await daiToken.balanceOf(dsaWallet0.address); + expect(daiBalance, `DAI balance equals 0`).to.be.eq( + ethers.utils.parseEther("0") + ); + + let cToken = await ethers.getContractAt( + abis.basic.erc20, + PT_DAI_TICKET_ADDR + ); + const balance = await cToken.balanceOf(dsaWallet0.address); + expect(balance, `PoolTogether Dai Ticket is 100`).to.be.eq( + ethers.utils.parseEther("100") + ); + + let poolToken = await ethers.getContractAt( + abis.basic.erc20, + POOL_TOKEN_ADDRESS + ); + const poolBalance = await poolToken.balanceOf(dsaWallet0.address); + expect(poolBalance, `POOL Token equals 0`).to.be.eq( + ethers.utils.parseEther("0") + ); + + // Increase time by 11 days so we get back all DAI without early withdrawal fee + await ethers.provider.send("evm_increaseTime", [11 * 24 * 60 * 60]); + + earlyExitFee = await prizePoolContract.callStatic[ + "calculateEarlyExitFee" + ](dsaWallet0.address, PT_DAI_TICKET_ADDR, amount); + expect( + earlyExitFee.exitFee, + "Exit Fee equal to 0 DAI because past 10 days" + ).to.be.eq(0); + + // Run spell transaction + const tx = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(spells), wallet1.address); + const receipt = await tx.wait(); + + // After spell + daiBalance = await daiToken.balanceOf(dsaWallet0.address); + expect( + daiBalance, + `DAI balance to be equal to 100, because of no early withdrawal fee` + ).to.be.eq(ethers.utils.parseEther("100")); + + const balanceAfter = await cToken.balanceOf(dsaWallet0.address); + expect(balanceAfter, `PoolTogether Dai Ticket to equal 0`).to.be.eq(0); + + const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address); + expect( + poolBalanceAfter, + `POOL Token Balance to be greater than 0` + ).to.be.gt(ethers.utils.parseEther("0")); + }); + + it("Should deposit and withdraw all PrizePool, get back less than 100 DAI", async function() { + const amount = ethers.utils.parseEther("100"); // 100 DAI + const exitFee = ethers.utils.parseEther("1"); // 1 DAI is 10% of 100 DAI + const spells = [ + { + connector: ptConnectorName, + method: "depositTo", + args: [DAI_PRIZE_POOL_ADDR, amount, PT_DAI_TICKET_ADDR, 0, 0], + }, + { + connector: ptConnectorName, + method: "withdrawInstantlyFrom", + args: [ + DAI_PRIZE_POOL_ADDR, + amount, + PT_DAI_TICKET_ADDR, + exitFee, + 0, + 0, + ], + }, + ]; + + // Before spell + let daiToken = await ethers.getContractAt( + abis.basic.erc20, + DAI_TOKEN_ADDR + ); + let daiBalance = await daiToken.balanceOf(dsaWallet0.address); + expect(daiBalance, `DAI Balance equals 0`).to.be.eq( + ethers.utils.parseEther("100") + ); + + let cToken = await ethers.getContractAt( + abis.basic.erc20, + PT_DAI_TICKET_ADDR + ); + const balance = await cToken.balanceOf(dsaWallet0.address); + expect(balance, `PoolTogether DAI Ticket equals 0`).to.be.eq(0); + + let poolToken = await ethers.getContractAt( + abis.basic.erc20, + POOL_TOKEN_ADDRESS + ); + const poolBalance = await poolToken.balanceOf(dsaWallet0.address); + expect(poolBalance, `PoolTogether Token greater than 0`).to.be.gt(0); + + // Run spell transaction + const tx = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(spells), wallet1.address); + const receipt = await tx.wait(); + + // After spell + daiBalance = await daiToken.balanceOf(dsaWallet0.address); + expect( + daiBalance, + `DAI balance to be less than 100, because of early withdrawal fee` + ).to.be.lt(ethers.utils.parseEther("100")); + + const balanceAfter = await cToken.balanceOf(dsaWallet0.address); + expect(balanceAfter, `PoolTogether Dai Ticket to equal 0`).to.be.eq(0); + + const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address); + expect(poolBalanceAfter, `POOL Token Balance to greater than 0`).to.be.gt( + ethers.utils.parseEther("0") + ); + }); + + it("Should deposit, wait 11 days, and withdraw all PrizePool, get 99 DAI, and claim all POOL using claimAll", async function() { + const amount = ethers.utils.parseEther("99"); // 99 DAI + const depositSpells = [ + { + connector: ptConnectorName, + method: "depositTo", + args: [DAI_PRIZE_POOL_ADDR, amount, PT_DAI_TICKET_ADDR, 0, 0], + }, + ]; + + // Before spell + let daiToken = await ethers.getContractAt( + abis.basic.erc20, + DAI_TOKEN_ADDR + ); + let daiBalance = await daiToken.balanceOf(dsaWallet0.address); + expect(daiBalance, `DAI balance less than 100`).to.be.lt( + ethers.utils.parseEther("100") + ); + + let cToken = await ethers.getContractAt( + abis.basic.erc20, + PT_DAI_TICKET_ADDR + ); + const balance = await cToken.balanceOf(dsaWallet0.address); + expect(balance, `PoolTogether DAI Ticket equal 0`).to.be.eq(0); + + let poolToken = await ethers.getContractAt( + abis.basic.erc20, + POOL_TOKEN_ADDRESS + ); + const poolBalance = await poolToken.balanceOf(dsaWallet0.address); + expect(poolBalance, `POOL Token is greater than 0`).to.be.gt( + ethers.utils.parseEther("0") + ); + + // Run spell transaction + const tx = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(depositSpells), wallet1.address); + const receipt = await tx.wait(); + + const prizePoolContract = new ethers.Contract( + DAI_PRIZE_POOL_ADDR, + prizePoolABI, + ethers.provider + ); + let earlyExitFee = await prizePoolContract.callStatic[ + "calculateEarlyExitFee" + ](dsaWallet0.address, PT_DAI_TICKET_ADDR, amount); + expect( + earlyExitFee.exitFee, + "Exit Fee equal to .99 DAI because starts at 10%" + ).to.be.eq(ethers.utils.parseEther(".99")); + + // Increase time by 11 days so we get back all DAI without early withdrawal fee + await ethers.provider.send("evm_increaseTime", [11 * 24 * 60 * 60]); + + earlyExitFee = await prizePoolContract.callStatic[ + "calculateEarlyExitFee" + ](dsaWallet0.address, PT_DAI_TICKET_ADDR, amount); + expect( + earlyExitFee.exitFee, + "Exit Fee equal to 0 DAI because past 10 days" + ).to.be.eq(0); + + const withdrawSpells = [ + { + connector: ptConnectorName, + method: "withdrawInstantlyFrom", + args: [ + DAI_PRIZE_POOL_ADDR, + amount, + PT_DAI_TICKET_ADDR, + earlyExitFee.exitFee, + 0, + 0, + ], + }, + { + connector: ptConnectorName, + method: "claimAll", + args: [TOKEN_FAUCET_PROXY_FACTORY_ADDR, [DAI_POOL_FAUCET_ADDR]], + }, + ]; + + // Run spell transaction + const tx2 = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(withdrawSpells), wallet1.address); + const receipt2 = await tx2.wait(); + + // After spell + daiBalance = await daiToken.balanceOf(dsaWallet0.address); + expect(daiBalance, `DAI balance equals 99`).to.be.eq( + ethers.utils.parseEther("99") + ); + + const balanceAfter = await cToken.balanceOf(dsaWallet0.address); + expect(balanceAfter, `PoolTogether DAI Ticket equal 0`).to.be.eq(0); + + // Expect + const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address); + expect(poolBalanceAfter, `Pool Token to be greateir than 0`).to.be.gt( + ethers.utils.parseEther("0") + ); + }); + }); + + describe("Main - DAI Pod Test", function() { + it("Should deposit 99 DAI in DAI Pod", async function() { + const amount = ethers.utils.parseEther("99"); // 99 DAI + const spells = [ + { + connector: ptConnectorName, + method: "depositToPod", + args: [DAI_TOKEN_ADDR, DAI_POD_ADDR, amount, 0, 0], + }, + ]; + + // Before spell + let daiToken = await ethers.getContractAt( + abis.basic.erc20, + DAI_TOKEN_ADDR + ); + let daiBalance = await daiToken.balanceOf(dsaWallet0.address); + expect(daiBalance, `DAI balance equals 99`).to.be.eq( + ethers.utils.parseEther("99") + ); + + let poolToken = await ethers.getContractAt( + abis.basic.erc20, + POOL_TOKEN_ADDRESS + ); + const poolBalance = await poolToken.balanceOf(dsaWallet0.address); + expect(poolBalance, `POOL Token greater than 0`).to.be.gt(0); + + let podToken = await ethers.getContractAt(abis.basic.erc20, DAI_POD_ADDR); + const podBalance = await podToken.balanceOf(dsaWallet0.address); + expect(podBalance, `Pod DAI Token equals 0`).to.be.eq(0); + + // Run spell transaction + const tx = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(spells), wallet1.address); + const receipt = await tx.wait(); + + // After spell + daiBalance = await daiToken.balanceOf(dsaWallet0.address); + expect(daiBalance, `DAI equals 0`).to.be.eq(0); + + const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address); + expect(poolBalanceAfter, `POOL Token greater than 0`).to.be.gt(0); + + const podBalanceAfter = await podToken.balanceOf(dsaWallet0.address); + expect(podBalanceAfter, `Pod DAI token greater than 0`).to.be.eq( + ethers.utils.parseEther("99") + ); + }); + + it("Should claim rewards from pod token drop", async function() { + const spells = [ + { + connector: ptConnectorName, + method: "claimPodTokenDrop", + args: [DAI_POD_TOKEN_DROP, 0], + }, + ]; + + const tokenDropContract = new ethers.Contract( + DAI_POD_TOKEN_DROP, + tokenDropABI, + ethers.provider + ); + const podContract = new ethers.Contract( + DAI_POD_ADDR, + podABI, + masterSigner + ); + + // drop(): Claim TokenDrop asset for PrizePool Pod and transfers token(s) to external Pod TokenDrop + // dropt() also calls batch which, Deposit Pod float into PrizePool. Deposits the current float + // amount into the PrizePool and claims current POOL rewards. + const dropTx = await podContract.drop(); + await dropTx.wait(); + + // POOL Rewards able to claim from Pod Token Drop + let claimAmount = await tokenDropContract.callStatic["claim"]( + dsaWallet0.address + ); + + // Before spell + let poolToken = await ethers.getContractAt( + abis.basic.erc20, + POOL_TOKEN_ADDRESS + ); + const poolBalance = await poolToken.balanceOf(dsaWallet0.address); + expect(poolBalance, `POOL Token greater than 0`).to.be.gt(0); + + // Run spell transaction + const tx = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(spells), wallet1.address); + const receipt = await tx.wait(); + + // After spell + const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address); + const total = claimAmount.add(poolBalance); + expect(poolBalanceAfter, `POOL Token same as before spell`).to.be.eq( + total + ); + }); + + it("Should wait 11 days, withdraw all podTokens, get back 99 DAI", async function() { + const amount = ethers.utils.parseEther("99"); // 99 DAI + + const podContract = new ethers.Contract( + DAI_POD_ADDR, + podABI, + ethers.provider + ); + let maxFee = await podContract.callStatic["getEarlyExitFee"](amount); + // maxFee depends on if token has been deposited to PrizePool yet + // since we called drop in previous test case, the tokens were deposited to PrizePool + expect( + maxFee, + "Exit Fee equal to .99 DAI because token still in float" + ).to.be.eq(ethers.utils.parseEther(".99")); + + const spells = [ + { + connector: ptConnectorName, + method: "withdrawFromPod", + args: [DAI_POD_ADDR, amount, maxFee, 0, 0], + }, + ]; + + // Before spell + let daiToken = await ethers.getContractAt( + abis.basic.erc20, + DAI_TOKEN_ADDR + ); + let daiBalance = await daiToken.balanceOf(dsaWallet0.address); + expect(daiBalance, `DAI Balance equals 0`).to.be.eq(0); + + let poolToken = await ethers.getContractAt( + abis.basic.erc20, + POOL_TOKEN_ADDRESS + ); + const poolBalance = await poolToken.balanceOf(dsaWallet0.address); + expect(poolBalance, `POOL Token balance greater than 0`).to.be.gt(0); + + let podToken = await ethers.getContractAt(abis.basic.erc20, DAI_POD_ADDR); + const podBalance = await podToken.balanceOf(dsaWallet0.address); + expect(podBalance, `Pod DAI Token equals 99`).to.be.eq( + ethers.utils.parseEther("99") + ); + + // Increase time by 11 days so we get back all DAI without early withdrawal fee + await ethers.provider.send("evm_increaseTime", [11 * 24 * 60 * 60]); + + // Run spell transaction + const tx = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(spells), wallet1.address); + const receipt = await tx.wait(); + + // After spell + daiBalance = await daiToken.balanceOf(dsaWallet0.address); + expect( + daiBalance, + `DAI balance equals 99, because of no early withdrawal fee` + ).to.be.eq(ethers.utils.parseEther("99")); + + const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address); + expect(poolBalanceAfter, `POOL Token to be greater than 0`).to.be.gt(0); + + const podBalanceAfter = await podToken.balanceOf(dsaWallet0.address); + expect(podBalanceAfter, `Pod DAI Token equals 0`).to.be.eq(0); + }); + + it("Should deposit and withdraw from pod, get back same amount of 99 DAI", async function() { + const amount = ethers.utils.parseEther("99"); + const maxFee = 0; // maxFee 0 since it doesn't give chance for Pod to actually deposit into PrizePool + + const spells = [ + { + connector: ptConnectorName, + method: "depositToPod", + args: [DAI_TOKEN_ADDR, DAI_POD_ADDR, amount, 0, 0], + }, + { + connector: ptConnectorName, + method: "withdrawFromPod", + args: [DAI_POD_ADDR, amount, maxFee, 0, 0], + }, + ]; + + // Before spell + let daiToken = await ethers.getContractAt( + abis.basic.erc20, + DAI_TOKEN_ADDR + ); + let daiBalance = await daiToken.balanceOf(dsaWallet0.address); + expect(daiBalance, `DAI equals 99`).to.be.eq( + ethers.utils.parseEther("99") + ); + + let poolToken = await ethers.getContractAt( + abis.basic.erc20, + POOL_TOKEN_ADDRESS + ); + const poolBalance = await poolToken.balanceOf(dsaWallet0.address); + expect(poolBalance, `POOL Token greater than 0`).to.be.gt(0); + + // PodToken is 0 + let podToken = await ethers.getContractAt(abis.basic.erc20, DAI_POD_ADDR); + const podBalance = await podToken.balanceOf(dsaWallet0.address); + expect(podBalance, `Pod DAI Token equals 0`).to.be.eq(0); + + // Run spell transaction + const tx = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(spells), wallet1.address); + const receipt = await tx.wait(); + + // After spell + daiBalance = await daiToken.balanceOf(dsaWallet0.address); + expect( + daiBalance, + `DAI balance to be equal to 99, because funds still in 'float` + ).to.be.eq(ethers.utils.parseEther("99")); + + const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address); + expect(poolBalanceAfter, `POOL Token same as before spell`).to.be.eq( + poolBalance + ); + + // Expect Pod Token Balance to equal 0 + const podBalanceAfter = await podToken.balanceOf(dsaWallet0.address); + expect(podBalanceAfter, `Pod DAI Token equals 0`).to.be.eq( + ethers.utils.parseEther("0") + ); + }); + }); + + describe("Main - UNISWAP POOL/ETH Prize Pool Test", function() { + it("Should use uniswap to swap ETH for POOL, deposit to POOL/ETH LP, deposit POOL/ETH LP to PrizePool", async function() { + const amount = ethers.utils.parseEther("100"); // 100 POOL + const slippage = ethers.utils.parseEther("0.03"); + const setId = "83478237"; + + const UniswapV2Router02ABI = [ + "function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts)", + ]; + + // Get amount of ETH for 100 POOL from Uniswap + const UniswapV2Router02 = await ethers.getContractAt( + UniswapV2Router02ABI, + "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D" + ); + const amounts = await UniswapV2Router02.getAmountsOut(amount, [ + POOL_TOKEN_ADDRESS, + WETH_ADDR, + ]); + const unitAmount = ethers.utils.parseEther( + ((amounts[1] * 1.03) / amounts[0]).toString() + ); + + const spells = [ + { + connector: uniswapConnectorName, + method: "buy", + args: [ + POOL_TOKEN_ADDRESS, + tokens.eth.address, + amount, + unitAmount, + 0, + setId, + ], + }, + { + connector: uniswapConnectorName, + method: "deposit", + args: [ + POOL_TOKEN_ADDRESS, + tokens.eth.address, + amount, + unitAmount, + slippage, + 0, + setId, + ], + }, + { + connector: ptConnectorName, + method: "depositTo", + args: [ + UNISWAP_POOLETHLP_PRIZE_POOL_ADDR, + 0, + PT_UNISWAP_POOLETHLP_TICKET_ADDR, + setId, + 0, + ], + }, + ]; + + // Before Spell + let ethBalance = await ethers.provider.getBalance(dsaWallet0.address); + expect(ethBalance, `ETH Balance equals 9`).to.be.eq( + ethers.utils.parseEther("9") + ); + + let poolToken = await ethers.getContractAt( + abis.basic.erc20, + POOL_TOKEN_ADDRESS + ); + const poolBalance = await poolToken.balanceOf(dsaWallet0.address); + expect(poolBalance, `POOL Token greater than 0`).to.be.gt(0); + + let uniswapLPToken = await ethers.getContractAt( + abis.basic.erc20, + UNISWAP_POOLETHLP_TOKEN_ADDR + ); + const uniswapPoolEthBalance = await uniswapLPToken.balanceOf( + dsaWallet0.address + ); + expect(uniswapPoolEthBalance, `Uniswap POOL/ETH LP equals 0`).to.be.eq(0); + + let ptUniswapPoolEthToken = await ethers.getContractAt( + abis.basic.erc20, + PT_UNISWAP_POOLETHLP_TICKET_ADDR + ); + const ptUniswapPoolEthBalance = await ptUniswapPoolEthToken.balanceOf( + dsaWallet0.address + ); + expect( + ptUniswapPoolEthBalance, + `PoolTogether Uniswap POOL?ETH LP equals 0` + ).to.be.eq(0); + + // Run spell transaction + const tx = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(spells), wallet1.address); + const receipt = await tx.wait(); + + // After spell + ethBalance = await ethers.provider.getBalance(dsaWallet0.address); + expect(ethBalance, `ETH Balance less than 9`).to.be.lt( + ethers.utils.parseEther("9") + ); + + const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address); + expect(poolBalanceAfter, `POOL Token to be same after spell`).to.be.eq( + poolBalance + ); + + const uniswapPoolEthBalanceAfter = await uniswapLPToken.balanceOf( + dsaWallet0.address + ); + expect( + uniswapPoolEthBalanceAfter, + `Uniswap POOL/ETH LP equals 0` + ).to.be.eq(0); + + const ptUniswapPoolEthBalanceAfter = await ptUniswapPoolEthToken.balanceOf( + dsaWallet0.address + ); + expect( + ptUniswapPoolEthBalanceAfter, + `PT Uniswap POOL/ETH LP to greater than 0` + ).to.be.gt(0); + }); + + it("Should withdraw all PrizePool, get back Uniswap LP, claim POOL, deposit claimed POOL into Pool PrizePool", async function() { + let ptUniswapPoolEthToken = await ethers.getContractAt( + abis.basic.erc20, + PT_UNISWAP_POOLETHLP_TICKET_ADDR + ); + const ptUniswapPoolEthBalance = await ptUniswapPoolEthToken.balanceOf( + dsaWallet0.address + ); + const setId = "83478237"; + + let uniswapPrizePoolContract = new ethers.Contract( + UNISWAP_POOLETHLP_PRIZE_POOL_ADDR, + prizePoolABI, + ethers.provider + ); + let earlyExitFee = await uniswapPrizePoolContract.callStatic[ + "calculateEarlyExitFee" + ]( + dsaWallet0.address, + PT_UNISWAP_POOLETHLP_TICKET_ADDR, + ptUniswapPoolEthBalance + ); + expect( + earlyExitFee.exitFee, + "Exit Fee equals 0 because no early exit fee for this prize pool" + ).to.be.eq(0); + + const spells = [ + { + connector: ptConnectorName, + method: "withdrawInstantlyFrom", + args: [ + UNISWAP_POOLETHLP_PRIZE_POOL_ADDR, + ptUniswapPoolEthBalance, + PT_UNISWAP_POOLETHLP_TICKET_ADDR, + earlyExitFee.exitFee, + 0, + 0, + ], + }, + { + connector: ptConnectorName, + method: "claim", + args: [UNISWAP_POOLETHLP_FAUCET_ADDR, setId], + }, + { + connector: ptConnectorName, + method: "depositTo", + args: [POOL_PRIZE_POOL_ADDR, 0, PT_POOL_TICKET_ADDR, setId, 0], + }, + ]; + + // Before spell + let poolToken = await ethers.getContractAt( + abis.basic.erc20, + POOL_TOKEN_ADDRESS + ); + const poolBalance = await poolToken.balanceOf(dsaWallet0.address); + expect(poolBalance, `POOL Token greater than 0`).to.be.gt(0); + + // Uniswap POOL/ETH LP is 0 + let uniswapLPToken = await ethers.getContractAt( + abis.basic.erc20, + UNISWAP_POOLETHLP_TOKEN_ADDR + ); + const uniswapPoolEthBalance = await uniswapLPToken.balanceOf( + dsaWallet0.address + ); + expect(uniswapPoolEthBalance, `Uniswap POOL/ETH LP equals 0`).to.be.eq(0); + + expect( + ptUniswapPoolEthBalance, + `PT Uniswap POOL/ETH LP greater than 0` + ).to.be.gt(0); + + let poolPoolTicket = await ethers.getContractAt( + abis.basic.erc20, + PT_POOL_TICKET_ADDR + ); + const poolPoolTicketBalance = await poolPoolTicket.balanceOf( + dsaWallet0.address + ); + expect( + poolPoolTicketBalance, + `PoolTogether POOL Ticket equals 0` + ).to.be.eq(0); + + // Run spell transaction + const tx = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(spells), wallet1.address); + const receipt = await tx.wait(); + + // After spell + const poolBalanceAfter = await poolToken.balanceOf(dsaWallet0.address); + expect( + poolBalanceAfter, + `Pool Token Balance equal to balance before spell` + ).to.be.eq(poolBalance); + + const uniswapPoolEthBalanceAfter = await uniswapLPToken.balanceOf( + dsaWallet0.address + ); + expect( + uniswapPoolEthBalanceAfter, + `Uniswap POOL/ETH LP to greater than 0` + ).to.be.gt(0); + + const ptUniswapPoolEthBalanceAfter = await ptUniswapPoolEthToken.balanceOf( + dsaWallet0.address + ); + expect( + ptUniswapPoolEthBalanceAfter, + `PT Uniswap POOL/ETH LP equal 0` + ).to.be.eq(0); + + const poolPoolTicketBalanceAfter = await poolPoolTicket.balanceOf( + dsaWallet0.address + ); + expect( + poolPoolTicketBalanceAfter, + `PoolTogether POOL Ticket greater than 0` + ).to.be.gt(0); + }); + }); + + describe("Main - WETH Prize Pool Test", function() { + it("Deposit 1 ETH into WETH Prize Pool and withdraw immediately", async function() { + const amount = ethers.utils.parseEther("1"); // 1 ETH + const setId = "83478237"; + const spells = [ + { + connector: ptConnectorName, + method: "depositTo", + args: [WETH_PRIZE_POOL_ADDR, amount, WETH_POOL_TICKET_ADDR, 0, setId], + }, + { + connector: ptConnectorName, + method: "withdrawInstantlyFrom", + args: [ + WETH_PRIZE_POOL_ADDR, + amount, + WETH_POOL_TICKET_ADDR, + amount, + setId, + 0, + ], + }, + ]; + // Before Spell + const ethBalanceBefore = await ethers.provider.getBalance( + dsaWallet0.address + ); + + // Run spell transaction + const tx = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(spells), wallet1.address); + const receipt = await tx.wait(); + + // After spell + const ethBalanceAfter = await ethers.provider.getBalance( + dsaWallet0.address + ); + + // ETH used for transaction + expect( + ethBalanceAfter, + `ETH Balance less than before spell because of early withdrawal fee` + ).to.be.lte(ethBalanceBefore); + }); + + it("Deposit 1 ETH into WETH Prize Pool, wait 14 days, then withdraw", async function() { + const amount = ethers.utils.parseEther("1"); // 1 ETH + const depositSpell = [ + { + connector: ptConnectorName, + method: "depositTo", + args: [WETH_PRIZE_POOL_ADDR, amount, WETH_POOL_TICKET_ADDR, 0, 0], + }, + ]; + + const withdrawSpell = [ + { + connector: ptConnectorName, + method: "withdrawInstantlyFrom", + args: [ + WETH_PRIZE_POOL_ADDR, + amount, + WETH_POOL_TICKET_ADDR, + amount, + 0, + 0, + ], + }, + ]; + + // Before Deposit Spell + let ethBalanceBefore = await ethers.provider.getBalance( + dsaWallet0.address + ); + + // Run deposit spell transaction + const tx = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(depositSpell), wallet1.address); + const receipt = await tx.wait(); + + // After Deposit spell + let ethBalanceAfter = await ethers.provider.getBalance( + dsaWallet0.address + ); + + expect(ethBalanceAfter, `ETH Balance less than before spell`).to.be.lte( + ethBalanceBefore + ); + + // Increase time by 11 days so we get back all ETH without early withdrawal fee + await ethers.provider.send("evm_increaseTime", [14 * 24 * 60 * 60]); + + // Run withdraw spell transaction + const tx2 = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(withdrawSpell), wallet1.address); + const receipt2 = await tx.wait(); + + // After Deposit spell + ethBalanceAfter = await ethers.provider.getBalance(dsaWallet0.address); + + expect( + ethBalanceAfter, + `ETH Balance equal to before spell because no early exit fee` + ).to.be.eq(ethBalanceBefore); + }); + }); + + describe("Main - WETH Pod Test", function() { + let podAddress: string; + it("Should deposit 1 ETH in WETH Pod and get Pod Ticket", async function() { + const amount = ethers.utils.parseEther("1"); + + // Create Pod for WETH Prize Pool (Rari) + const podFactoryContract = new ethers.Contract( + POD_FACTORY_ADDRESS, + podFactoryABI, + masterSigner + ); + podAddress = await podFactoryContract.callStatic.create( + WETH_PRIZE_POOL_ADDR, + WETH_POOL_TICKET_ADDR, + constants.address_zero, + wallet0.address, + 18 + ); + await podFactoryContract.create( + WETH_PRIZE_POOL_ADDR, + WETH_POOL_TICKET_ADDR, + constants.address_zero, + wallet0.address, + 18 + ); + + const spells = [ + { + connector: ptConnectorName, + method: "depositToPod", + args: [WETH_ADDR, podAddress, amount, 0, 0], + }, + ]; + + // Before Deposit Spell + const podContract = new ethers.Contract( + podAddress, + podABI, + ethers.provider + ); + let podBalanceBefore = await podContract.balanceOfUnderlying( + dsaWallet0.address + ); + expect(podBalanceBefore, `Pod balance equal to 0`).to.be.eq(0); + + let ethBalanceBefore = await ethers.provider.getBalance( + dsaWallet0.address + ); + + // Run spell transaction + const tx = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(spells), wallet1.address); + const receipt = await tx.wait(); + + // After Deposit spell + let ethBalanceAfter = await ethers.provider.getBalance( + dsaWallet0.address + ); + expect(ethBalanceAfter, `ETH balance less than before`).to.be.lt( + ethBalanceBefore + ); + + let podBalanceAfter = await podContract.balanceOfUnderlying( + dsaWallet0.address + ); + expect(podBalanceAfter, `Pod balance equal to 1`).to.be.eq( + ethers.utils.parseEther("1") + ); + }); + + it("Should withdraw 1 Ticket from WETH Pod and get back ETH", async function() { + const amount = ethers.utils.parseEther("1"); + + const podContract = new ethers.Contract( + podAddress, + podABI, + ethers.provider + ); + let maxFee = await podContract.callStatic["getEarlyExitFee"](amount); + expect( + maxFee, + "Exit Fee equal to 0 DAI because token still in float" + ).to.be.eq(0); + // maxFee depends on if token has been deposited to PrizePool yet + + const spells = [ + { + connector: ptConnectorName, + method: "withdrawFromPod", + args: [podAddress, amount, maxFee, 0, 0], + }, + ]; + + // Before Deposit Spell + let podBalanceBefore = await podContract.balanceOfUnderlying( + dsaWallet0.address + ); + expect(podBalanceBefore, `Pod balance equal to 1`).to.be.eq( + ethers.utils.parseEther("1") + ); + + let ethBalanceBefore = await ethers.provider.getBalance( + dsaWallet0.address + ); + + // Run spell transaction + const tx = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(spells), wallet1.address); + const receipt = await tx.wait(); + + // After Deposit spell + let ethBalanceAfter = await ethers.provider.getBalance( + dsaWallet0.address + ); + expect(ethBalanceAfter, `ETH balance greater than before`).to.be.gt( + ethBalanceBefore + ); + + let podBalanceAfter = await podContract.balanceOfUnderlying( + dsaWallet0.address + ); + expect(podBalanceAfter, `Pod balance equal to 0`).to.be.eq( + ethers.utils.parseEther("0") + ); + }); + }); +}); diff --git a/test/mainnet/uniswap-sell-beta/uniswap-sell-beta.ts b/test/mainnet/uniswap-sell-beta/uniswap-sell-beta.ts index b607a822..73b9df8b 100644 --- a/test/mainnet/uniswap-sell-beta/uniswap-sell-beta.ts +++ b/test/mainnet/uniswap-sell-beta/uniswap-sell-beta.ts @@ -1,22 +1,23 @@ +import { BigNumberish } from "@ethersproject/bignumber"; +import { Contract } from "@ethersproject/contracts"; import { expect } from "chai"; -import hre from "hardhat"; -const { web3, deployments, waffle, ethers } = hre; -const { provider, deployContract } = waffle +import hre, { artifacts } from "hardhat"; +const { ethers } = hre; const USDC_ADDR = "0xff970a61a04b1ca14834a43f5de4533ebddb5cc8"; const WETH_ADDR = "0x82af49447d8a07e3bd95bd0d56f35241523fbab1"; describe("Uniswap-sell-beta", function () { - let UniswapSellBeta, uniswapSellBeta; + let UniswapSellBeta, uniswapSellBeta: Contract; - async function setBalance(address) { - await network.provider.send("hardhat_setBalance", [ + async function setBalance(address: any) { + await hre.network.provider.send("hardhat_setBalance", [ address, ethers.utils.parseEther("10.0").toHexString(), ]); } - async function impersonate(owner, account, token0, decimals) { + async function impersonate(owner: string, account: any, token0: string, decimals: BigNumberish | undefined) { const tokenArtifact = await artifacts.readArtifact( "@openzeppelin/contracts/token/ERC20/IERC20.sol:IERC20" ); diff --git a/test/mainnet/uniswap/uniswap.test.ts b/test/mainnet/uniswap/uniswap.test.ts index cb1dc61e..0a5deea3 100644 --- a/test/mainnet/uniswap/uniswap.test.ts +++ b/test/mainnet/uniswap/uniswap.test.ts @@ -1,27 +1,19 @@ import { expect } from "chai"; import hre from "hardhat"; const { web3, deployments, waffle, ethers } = hre; -const { provider, deployContract } = waffle +const { provider, deployContract } = waffle; -import { deployAndEnableConnector } from "../../../scripts/tests/deployAndEnableConnector.js"; +import { deployAndEnableConnector } from "../../../scripts/tests/deployAndEnableConnector"; import { buildDSAv2 } from "../../../scripts/tests/buildDSAv2"; -import { encodeSpells } from "../../../scripts/tests/encodeSpells.js"; -import { encodeFlashcastData } from "../../../scripts/tests/encodeFlashcastData.js"; +import { encodeSpells } from "../../../scripts/tests/encodeSpells"; import { getMasterSigner } from "../../../scripts/tests/getMasterSigner"; import { addLiquidity } from "../../../scripts/tests/addLiquidity"; - import { addresses } from "../../../scripts/constant/addresses"; import { abis } from "../../../scripts/constant/abis"; -import { constants } from "../../../scripts/constant/constant"; -import { tokens } from "../../../scripts/constant/tokens"; +import type { Signer, Contract } from "ethers"; -import { - abi: nftManagerAbi, -} from "@uniswap/v3-periphery/artifacts/contracts/NonfungiblePositionManager.sol/NonfungiblePositionManager.json"; - -import connectV2UniswapV3Artifacts from "../../artifacts/contracts/mainnet/connectors/uniswap/v3/main.sol/ConnectV2UniswapV3.json" -import { eth } from "../../../scripts/constant/tokens" -import { BigNumber } from "ethers" +import { abi } from "@uniswap/v3-periphery/artifacts/contracts/NonfungiblePositionManager.sol/NonfungiblePositionManager.json"; +import { ConnectV2UniswapV3__factory } from "../../../typechain"; const FeeAmount = { LOW: 500, @@ -29,7 +21,7 @@ const FeeAmount = { HIGH: 10000, }; -const TICK_SPACINGS = { +const TICK_SPACINGS: Record = { 500: 10, 3000: 60, 10000: 200, @@ -38,18 +30,18 @@ const TICK_SPACINGS = { const USDT_ADDR = "0xdac17f958d2ee523a2206206994597c13d831ec7"; const DAI_ADDR = "0x6b175474e89094c44da98b954eedeac495271d0f"; -let tokenIds = []; -let liquidities = []; +let tokenIds: any[] = []; +let liquidities: any[] = []; const abiCoder = ethers.utils.defaultAbiCoder; -describe("UniswapV3", function () { +describe("UniswapV3", function() { const connectorName = "UniswapV3-v1"; - let dsaWallet0; - let masterSigner; - let instaConnectorsV2; - let connector; - let nftManager; + let dsaWallet0: any; + let masterSigner: Signer; + let instaConnectorsV2: Contract; + let connector: Contract; + let nftManager: Contract; const wallets = provider.getWallets(); const [wallet0, wallet1, wallet2, wallet3] = wallets; @@ -59,43 +51,44 @@ describe("UniswapV3", function () { params: [ { forking: { + // @ts-ignore jsonRpcUrl: hre.config.networks.hardhat.forking.url, blockNumber: 13005785, }, }, ], }); - masterSigner = await getMasterSigner(wallet3); + masterSigner = await getMasterSigner(); instaConnectorsV2 = await ethers.getContractAt( abis.core.connectorsV2, addresses.core.connectorsV2 ); nftManager = await ethers.getContractAt( - nftManagerAbi, + abi, "0xC36442b4a4522E871399CD717aBDD847Ab11FE88" ); connector = await deployAndEnableConnector({ connectorName, - contractArtifact: connectV2UniswapV3Artifacts, + contractArtifact: ConnectV2UniswapV3__factory, signer: masterSigner, connectors: instaConnectorsV2, }); console.log("Connector address", connector.address); }); - it("Should have contracts deployed.", async function () { + it("Should have contracts deployed.", async function() { expect(!!instaConnectorsV2.address).to.be.true; expect(!!connector.address).to.be.true; - expect(!!masterSigner.address).to.be.true; + expect(!!(await masterSigner.getAddress())).to.be.true; }); - describe("DSA wallet setup", function () { - it("Should build DSA v2", async function () { + describe("DSA wallet setup", function() { + it("Should build DSA v2", async function() { dsaWallet0 = await buildDSAv2(wallet0.address); expect(!!dsaWallet0.address).to.be.true; }); - it("Deposit ETH & DAI into DSA wallet", async function () { + it("Deposit ETH & DAI into DSA wallet", async function() { await wallet0.sendTransaction({ to: dsaWallet0.address, value: ethers.utils.parseEther("10"), @@ -111,7 +104,7 @@ describe("UniswapV3", function () { ); }); - it("Deposit ETH & USDT into DSA wallet", async function () { + it("Deposit ETH & USDT into DSA wallet", async function() { await wallet0.sendTransaction({ to: dsaWallet0.address, value: ethers.utils.parseEther("10"), @@ -128,11 +121,11 @@ describe("UniswapV3", function () { }); }); - describe("Main", function () { - it("Should mint successfully", async function () { + describe("Main", function() { + it("Should mint successfully", async function() { const ethAmount = ethers.utils.parseEther("0.1"); // 1 ETH const daiAmount = ethers.utils.parseEther("400"); // 1 ETH - const usdtAmount = ethers.utils.parseEther("400") / Math.pow(10, 12); // 1 ETH + const usdtAmount = Number(ethers.utils.parseEther("400")) / Math.pow(10, 12); // 1 ETH const ethAddress = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"; const getIds = ["0", "0"]; @@ -197,14 +190,14 @@ describe("UniswapV3", function () { dsaWallet0.on( "LogCast", ( - origin, - sender, - value, - targetNames, - targets, - eventNames, - eventParams, - event + origin: any, + sender: any, + value: any, + targetNames: any, + targets: any, + eventNames: any, + eventParams: any, + event: any ) => { const params = abiCoder.decode( ["uint256", "uint256", "uint256", "uint256", "int24", "int24"], @@ -237,11 +230,9 @@ describe("UniswapV3", function () { expect(data.liquidity).to.be.equals(liquidities[0]); }).timeout(10000000000); - it("Should deposit successfully", async function () { + it("Should deposit successfully", async function() { const daiAmount = ethers.utils.parseEther("400"); // 1 ETH const ethAmount = ethers.utils.parseEther("0.1"); // 1 ETH - const usdtAmount = ethers.utils.parseEther("400") / Math.pow(10, 12); // 1 ETH - const ethAddress = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"; const getIds = ["0", "0"]; const setId = "0"; @@ -270,14 +261,14 @@ describe("UniswapV3", function () { dsaWallet0.on( "LogCast", ( - origin, - sender, - value, - targetNames, - targets, - eventNames, - eventParams, - event + origin: any, + sender: any, + value: any, + targetNames: any, + targets: any, + eventNames: any, + eventParams: any, + event: any ) => { const params = abiCoder.decode( ["uint256", "uint256", "uint256", "uint256"], @@ -303,7 +294,7 @@ describe("UniswapV3", function () { expect(data.liquidity).to.be.equals(liquidities[0]); }); - it("Should withdraw successfully", async function () { + it("Should withdraw successfully", async function() { const getId = "0"; const setIds = ["0", "0"]; @@ -332,7 +323,7 @@ describe("UniswapV3", function () { expect(data1.liquidity.toNumber()).to.be.equals(0); }); - it("Should collect successfully", async function () { + it("Should collect successfully", async function() { const ethAmount = ethers.utils.parseEther("0.2"); // 1 ETH const daiAmount = ethers.utils.parseEther("800"); // 1 ETH const getIds = ["0", "0"]; @@ -352,7 +343,7 @@ describe("UniswapV3", function () { const receipt = await tx.wait(); }); - it("Should burn successfully", async function () { + it("Should burn successfully", async function() { const spells = [ { connector: connectorName, @@ -369,7 +360,7 @@ describe("UniswapV3", function () { }); }); -const getMinTick = (tickSpacing) => +const getMinTick = (tickSpacing: number) => Math.ceil(-887272 / tickSpacing) * tickSpacing; -const getMaxTick = (tickSpacing) => +const getMaxTick = (tickSpacing: number) => Math.floor(887272 / tickSpacing) * tickSpacing; diff --git a/test/mainnet/uniswapStake/uniswapStake.test.ts b/test/mainnet/uniswapStake/uniswapStake.test.ts index 7051acec..bc2cf3e0 100644 --- a/test/mainnet/uniswapStake/uniswapStake.test.ts +++ b/test/mainnet/uniswapStake/uniswapStake.test.ts @@ -3,18 +3,18 @@ import hre from "hardhat"; const { web3, deployments, waffle, ethers } = hre; const { provider, deployContract } = waffle -import { deployAndEnableConnector } from "../../../scripts/tests/deployAndEnableConnector.js"; +import { deployAndEnableConnector } from "../../../scripts/tests/deployAndEnableConnector"; import { buildDSAv2 } from "../../../scripts/tests/buildDSAv2"; -import { encodeSpells } from "../../../scripts/tests/encodeSpells.js"; +import { encodeSpells } from "../../../scripts/tests/encodeSpells"; import { getMasterSigner } from "../../../scripts/tests/getMasterSigner"; import { addLiquidity } from "../../../scripts/tests/addLiquidity"; import { addresses } from "../../../scripts/constant/addresses"; import { abis } from "../../../scripts/constant/abis"; -import { abi: nftManagerAbi } from "@uniswap/v3-periphery/artifacts/contracts/NonfungiblePositionManager.sol/NonfungiblePositionManager.json" +import { abi } from "@uniswap/v3-periphery/artifacts/contracts/NonfungiblePositionManager.sol/NonfungiblePositionManager.json" +import type { Signer, Contract } from "ethers"; -import connectV2UniswapStakerArtifacts from "../../artifacts/contracts/mainnet/connectors/uniswap/v3_staker/main.sol/ConnectV2UniswapV3Staker.json"; -import connectV2UniswapV3Artifacts from "../../artifacts/contracts/mainnet/connectors/uniswap/v3/main.sol/ConnectV2UniswapV3.json"; +import { ConnectV2UniswapV3Staker__factory, ConnectV2UniswapV3__factory } from "../../../typechain"; const FeeAmount = { LOW: 500, @@ -22,7 +22,7 @@ const FeeAmount = { HIGH: 10000, } -const TICK_SPACINGS = { +const TICK_SPACINGS: Record = { 500: 10, 3000: 60, 10000: 200 @@ -32,7 +32,7 @@ const DAI_ADDR = "0x6b175474e89094c44da98b954eedeac495271d0f" const ethAddress = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee" const INST_ADDR = "0x6f40d4a6237c257fff2db00fa0510deeecd303eb" -let tokenIds = [] +let tokenIds: any[] = [] const abiCoder = ethers.utils.defaultAbiCoder describe("UniswapV3", function () { @@ -44,6 +44,7 @@ describe("UniswapV3", function () { let instaConnectorsV2: any; let connector: any; let startTime: any, endTime: any; + let nftManager: Contract; const wallets = provider.getWallets() const [wallet0, wallet1, wallet2, wallet3] = wallets @@ -53,18 +54,19 @@ describe("UniswapV3", function () { params: [ { forking: { + // @ts-ignore jsonRpcUrl: hre.config.networks.hardhat.forking.url, blockNumber: 13300000, }, }, ], }); - masterSigner = await getMasterSigner(wallet3) + masterSigner = await getMasterSigner() instaConnectorsV2 = await ethers.getContractAt(abis.core.connectorsV2, addresses.core.connectorsV2); - let nftManager = await ethers.getContractAt(nftManagerAbi, "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"); + nftManager = await ethers.getContractAt(abi, "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"); connector = await deployAndEnableConnector({ connectorName: connectorStaker, - contractArtifact: connectV2UniswapStakerArtifacts, + contractArtifact: ConnectV2UniswapV3Staker__factory, signer: masterSigner, connectors: instaConnectorsV2 }) @@ -72,7 +74,7 @@ describe("UniswapV3", function () { let uniswapConnector = await deployAndEnableConnector({ connectorName: connectorUniswap, - contractArtifact: connectV2UniswapV3Artifacts, + contractArtifact: ConnectV2UniswapV3__factory, signer: masterSigner, connectors: instaConnectorsV2 }); @@ -161,7 +163,7 @@ describe("UniswapV3", function () { let receipt = await tx.wait() let castEvent = new Promise((resolve, reject) => { - dsaWallet0.on('LogCast', (origin, sender, value, targetNames, targets, eventNames, eventParams, event) => { + dsaWallet0.on('LogCast', (origin: any, sender: any, value: any, targetNames: any, targets: any, eventNames: any, eventParams: any, event: any) => { const params = abiCoder.decode(["uint256", "uint256", "uint256", "uint256", "int24", "int24"], eventParams[0]); const params1 = abiCoder.decode(["uint256", "uint256", "uint256", "uint256", "int24", "int24"], eventParams[1]); tokenIds.push(params[0]); @@ -213,7 +215,7 @@ describe("UniswapV3", function () { let receipt = await tx.wait() let castEvent = new Promise((resolve, reject) => { - dsaWallet0.on('LogCast', (origin, sender, value, targetNames, targets, eventNames, eventParams, event) => { + dsaWallet0.on('LogCast', (origin: any, sender: any, value: any, targetNames: any, targets: any, eventNames: any, eventParams: any, event: any) => { const params = abiCoder.decode(["bytes32", "address", "address", "uint256", "uint256", "uint256"], eventParams[0]); const params1 = abiCoder.decode(["bytes32", "address", "address", "uint256", "uint256", "uint256"], eventParams[1]); event.removeListener(); @@ -226,7 +228,7 @@ describe("UniswapV3", function () { }, 60000) }); - let event = await castEvent + let event: any = await castEvent startTime = event.start; endTime = event.end; }); @@ -351,5 +353,5 @@ describe("UniswapV3", function () { }) }) -const getMinTick = (tickSpacing) => Math.ceil(-887272 / tickSpacing) * tickSpacing -const getMaxTick = (tickSpacing) => Math.floor(887272 / tickSpacing) * tickSpacing +const getMinTick = (tickSpacing: number) => Math.ceil(-887272 / tickSpacing) * tickSpacing +const getMaxTick = (tickSpacing: number) => Math.floor(887272 / tickSpacing) * tickSpacing diff --git a/test/mainnet/yearn/yearn.test.ts b/test/mainnet/yearn/yearn.test.ts index c3e9028c..68757674 100644 --- a/test/mainnet/yearn/yearn.test.ts +++ b/test/mainnet/yearn/yearn.test.ts @@ -1,154 +1,189 @@ import { expect } from "chai"; import hre from "hardhat"; const { web3, deployments, waffle, ethers } = hre; -const { provider, deployContract } = waffle +const { provider, deployContract } = waffle; -import { deployAndEnableConnector } from "../../../scripts/tests/deployAndEnableConnector.js" -import { buildDSAv2 } from "../../../scripts/tests/buildDSAv2" -import { encodeSpells } from "../../../scripts/tests/encodeSpells.js" -import { getMasterSigner } from "../../../scripts/tests/getMasterSigner" +import { deployAndEnableConnector } from "../../../scripts/tests/deployAndEnableConnector"; +import { buildDSAv2 } from "../../../scripts/tests/buildDSAv2"; +import { encodeSpells } from "../../../scripts/tests/encodeSpells"; +import { getMasterSigner } from "../../../scripts/tests/getMasterSigner"; import { addresses } from "../../../scripts/constant/addresses"; import { abis } from "../../../scripts/constant/abis"; import { tokens } from "../../../scripts/constant/tokens"; +import { Signer, Contract, BigNumber } from "ethers"; -import connectV2YearnArtifacts from "../../artifacts/contracts/mainnet/connectors/yearn_v2/main.sol/ConnectV2YearnV2.json" +import { ConnectV2YearnV2__factory } from "../../../typechain"; -const toBytes32 = (bn) => { - return ethers.utils.hexlify(ethers.utils.zeroPad(bn.toHexString(), 32)); -}; -const setStorageAt = async (address, index, value) => { - await ethers.provider.send("hardhat_setStorageAt", [address, index, value]); - await ethers.provider.send("evm_mine", []); // Just mines to the next block +const toBytes32 = (bn: BigNumber) => { + return ethers.utils.hexlify(ethers.utils.zeroPad(bn.toHexString(), 32)); }; -describe("Yearn", function () { - const connectorName = "YEARN-TEST-A" +const setStorageAt = async (address: string, index: string, value: string) => { + await ethers.provider.send("hardhat_setStorageAt", [address, index, value]); + await ethers.provider.send("evm_mine", []); // Just mines to the next block +}; - let dsaWallet0 - let masterSigner; - let instaConnectorsV2; - let connector; +describe("Yearn", function() { + const connectorName = "YEARN-TEST-A"; - const wallets = provider.getWallets() - const [wallet0, wallet1, wallet2, wallet3] = wallets - before(async () => { - await hre.network.provider.request({ - method: "hardhat_reset", - params: [ - { - forking: { - jsonRpcUrl: hre.config.networks.hardhat.forking.url, - blockNumber: 12996975, - }, - }, - ], - }); - masterSigner = await getMasterSigner(wallet3) - instaConnectorsV2 = await ethers.getContractAt(abis.core.connectorsV2, addresses.core.connectorsV2); - connector = await deployAndEnableConnector({ - connectorName, - contractArtifact: connectV2YearnArtifacts, - signer: masterSigner, - connectors: instaConnectorsV2 - }) - console.log("Connector address", connector.address) - }) + let dsaWallet0: any; + let masterSigner: Signer; + let instaConnectorsV2: Contract; + let connector: Contract; - it("Should have contracts deployed.", async function () { - expect(!!instaConnectorsV2.address).to.be.true; - expect(!!connector.address).to.be.true; - expect(!!masterSigner.address).to.be.true; + const wallets = provider.getWallets(); + const [wallet0, wallet1, wallet2, wallet3] = wallets; + before(async () => { + await hre.network.provider.request({ + method: "hardhat_reset", + params: [ + { + forking: { + // @ts-ignore + jsonRpcUrl: hre.config.networks.hardhat.forking.url, + blockNumber: 12996975, + }, + }, + ], + }); + masterSigner = await getMasterSigner(); + instaConnectorsV2 = await ethers.getContractAt( + abis.core.connectorsV2, + addresses.core.connectorsV2 + ); + connector = await deployAndEnableConnector({ + connectorName, + contractArtifact: ConnectV2YearnV2__factory, + signer: masterSigner, + connectors: instaConnectorsV2, + }); + console.log("Connector address", connector.address); + }); + + it("Should have contracts deployed.", async function() { + 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.address); + expect(!!dsaWallet0.address).to.be.true; }); - describe("DSA wallet setup", function () { - it("Should build DSA v2", async function () { - dsaWallet0 = await buildDSAv2(wallet0.address) - expect(!!dsaWallet0.address).to.be.true; - }); + it("Deposit ETH into DSA wallet", async function() { + await wallet0.sendTransaction({ + to: dsaWallet0.address, + value: ethers.utils.parseEther("10"), + }); + expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.gte( + ethers.utils.parseEther("10") + ); + }); + }); - it("Deposit ETH into DSA wallet", async function () { - await wallet0.sendTransaction({ - to: dsaWallet0.address, - value: ethers.utils.parseEther("10") - }); - expect(await ethers.provider.getBalance(dsaWallet0.address)).to.be.gte(ethers.utils.parseEther("10")); - }); + describe("Main", function() { + it("Should increase the DAI balance to 100 DAI", async function() { + const DAI = new ethers.Contract( + tokens.dai.address, + abis.basic.erc20, + ethers.provider + ); + const DAI_SLOT = 2; + const locallyManipulatedBalance = ethers.utils.parseEther("100"); + + // Get storage slot index + const index = ethers.utils.solidityKeccak256( + ["uint256", "uint256"], + [dsaWallet0.address, DAI_SLOT] + ); + // Manipulate local balance (needs to be bytes32 string) + await setStorageAt( + tokens.dai.address, + index.toString(), + toBytes32(locallyManipulatedBalance).toString() + ); + + // Get DAI balance + const balance = await DAI.balanceOf(dsaWallet0.address); + expect( + await ethers.BigNumber.from(balance).eq(ethers.utils.parseEther("100")) + ); }); - describe("Main", function () { + it("Should deposit and withdraw 50 DAI in/out the Yearn Vault", async function() { + const DAI = new ethers.Contract( + tokens.dai.address, + abis.basic.erc20, + ethers.provider + ); + const DAI_VAULT = "0xdA816459F1AB5631232FE5e97a05BBBb94970c95"; + const amount = ethers.utils.parseEther("50"); // 50 DAI + const setId = "132456"; + const spells = [ + { + connector: connectorName, + method: "deposit", + args: [DAI_VAULT, amount, 0, setId], + }, + { + connector: connectorName, + method: "withdraw", + args: [DAI_VAULT, amount, setId, 0], + }, + ]; - it("Should increase the DAI balance to 100 DAI", async function () { - const DAI = new ethers.Contract(tokens.dai.address, abis.basic.erc20, ethers.provider); - const DAI_SLOT = 2; - const locallyManipulatedBalance = ethers.utils.parseEther("100"); + const tx = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(spells), wallet0.address); + await tx.wait(); - // Get storage slot index - const index = ethers.utils.solidityKeccak256( - ["uint256", "uint256"], - [dsaWallet0.address, DAI_SLOT] - ); - // Manipulate local balance (needs to be bytes32 string) - await setStorageAt( - tokens.dai.address, - index.toString(), - toBytes32(locallyManipulatedBalance).toString() - ); + // Get DAI balance + const balance = await DAI.balanceOf(dsaWallet0.address); + expect( + await ethers.BigNumber.from(balance).eq(ethers.utils.parseEther("100")) + ); + }); - // Get DAI balance - const balance = await DAI.balanceOf(dsaWallet0.address); - expect(await ethers.BigNumber.from(balance).eq(ethers.utils.parseEther("100"))); - }); + it("Should deposit 70 DAI in the Yearn Vault", async function() { + const DAI_VAULT = "0xdA816459F1AB5631232FE5e97a05BBBb94970c95"; + const DAI = new ethers.Contract( + tokens.dai.address, + abis.basic.erc20, + ethers.provider + ); + const YVDAI = new ethers.Contract( + DAI_VAULT, + abis.basic.erc20, + ethers.provider + ); + const amount = ethers.utils.parseEther("70"); // 70 DAI + const setId = "568445"; + const spells = [ + { + connector: connectorName, + method: "deposit", + args: [DAI_VAULT, amount, 0, setId], + }, + ]; - it("Should deposit and withdraw 50 DAI in/out the Yearn Vault", async function () { - const DAI = new ethers.Contract(tokens.dai.address, abis.basic.erc20, ethers.provider); - const DAI_VAULT = '0xdA816459F1AB5631232FE5e97a05BBBb94970c95'; - const amount = ethers.utils.parseEther("50") // 50 DAI - const setId = "132456"; - const spells = [ - { - connector: connectorName, - method: "deposit", - args: [DAI_VAULT, amount, 0, setId] - }, - { - connector: connectorName, - method: "withdraw", - args: [DAI_VAULT, amount, setId, 0] - } - ] + const tx = await dsaWallet0 + .connect(wallet0) + .cast(...encodeSpells(spells), wallet0.address); + await tx.wait(); - const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet0.address); - await tx.wait(); - - // Get DAI balance - const balance = await DAI.balanceOf(dsaWallet0.address); - expect(await ethers.BigNumber.from(balance).eq(ethers.utils.parseEther("100"))); - }); - - it("Should deposit 70 DAI in the Yearn Vault", async function () { - const DAI_VAULT = '0xdA816459F1AB5631232FE5e97a05BBBb94970c95'; - const DAI = new ethers.Contract(tokens.dai.address, abis.basic.erc20, ethers.provider); - const YVDAI = new ethers.Contract(DAI_VAULT, abis.basic.erc20, ethers.provider); - const amount = ethers.utils.parseEther("70") // 70 DAI - const setId = "568445"; - const spells = [ - { - connector: connectorName, - method: "deposit", - args: [DAI_VAULT, amount, 0, setId] - } - ] - - const tx = await dsaWallet0.connect(wallet0).cast(...encodeSpells(spells), wallet0.address); - await tx.wait(); - - // Get DAI balance - const yvDAIBalance = await YVDAI.balanceOf(dsaWallet0.address); - const daiBalance = await DAI.balanceOf(dsaWallet0.address); - const correctDaiBalance = await ethers.BigNumber.from(daiBalance).eq(ethers.utils.parseEther("30")); - const correctYVDaiBalance = await ethers.BigNumber.from(yvDAIBalance).lte(ethers.utils.parseEther("70")); - expect(correctDaiBalance && correctYVDaiBalance); - }); - }) -}) + // Get DAI balance + const yvDAIBalance = await YVDAI.balanceOf(dsaWallet0.address); + const daiBalance = await DAI.balanceOf(dsaWallet0.address); + const correctDaiBalance = ethers.BigNumber.from(daiBalance).eq( + ethers.utils.parseEther("30") + ); + const correctYVDaiBalance = ethers.BigNumber.from(yvDAIBalance).lte( + ethers.utils.parseEther("70") + ); + expect(correctDaiBalance && correctYVDaiBalance); + }); + }); +}); diff --git a/yarn.lock b/yarn.lock index 51e7f458..7d4de696 100644 --- a/yarn.lock +++ b/yarn.lock @@ -1271,6 +1271,13 @@ dependencies: "@types/node" "*" +"@types/chai-as-promised@^7.1.4": + "integrity" "sha512-1y3L1cHePcIm5vXkh1DSGf/zQq5n5xDKG1fpCvf18+uOkpce0Z1ozNFPkyWsVswK7ntN1sZBw3oU6gmN+pDUcA==" + "resolved" "https://registry.npmjs.org/@types/chai-as-promised/-/chai-as-promised-7.1.4.tgz" + "version" "7.1.4" + dependencies: + "@types/chai" "*" + "@types/chai@*", "@types/chai@^4.2.22": "integrity" "sha512-tFfcE+DSTzWAgifkjik9AySNqIyNoYwmR+uecPwwD/XRNfvOjmC/FjCxpiUGDkDVDphPfCUecSQVFw+lN3M3kQ==" "resolved" "https://registry.npmjs.org/@types/chai/-/chai-4.2.22.tgz"