@dhedge/v2-sdk 1.9.8 → 1.10.0

package/src/test/flatmoney.test.ts

@@ -0,0 +1,164 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import BigNumber from "bignumber.js";
+import { Dhedge, Pool } from "../entities";
+import { AssetEnabled, Network } from "../types";
+import {
+  TestingRunParams,
+  setTokenAmount,
+  testingHelper
+} from "./utils/testingHelper";
+import { Contract, ethers } from "ethers";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import { flatMoneyContractAddresses } from "../config";
+import DelayedOrderAbi from "../abi/flatmoney/DelayedOrder.json";
+import { allowanceDelta } from "./utils/token";
+import { getKeeperFee } from "../services/flatmoney/keeperFee";
+
+const RETH = "0xb6fe221fe9eef5aba221c348ba20a1bf5e73624c";
+const RETH_SLOT = 0;
+const UNIT = "0xb95fB324b8A2fAF8ec4f76e3dF46C718402736e2";
+// https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable/blob/master/contracts/token/ERC20/ERC20Upgradeable.sol#L31
+// https://eips.ethereum.org/EIPS/eip-7201
+const UNIT_SLOT =
+  "0x52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace00";
+
+const testFlatMoney = ({
+  wallet,
+  network,
+  provider,
+  rpcUrl
+}: TestingRunParams) => {
+  let dhedge: Dhedge;
+  let pool: Pool;
+  let delayOrderContract: Contract;
+  jest.setTimeout(200000);
+  describe(`flatmoney on ${network}`, () => {
+    beforeAll(async () => {
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+
+      const flatMoneyContracts = flatMoneyContractAddresses[pool.network];
+      if (!flatMoneyContracts) {
+        throw new Error("testFlatMoney: network not supported");
+      }
+      delayOrderContract = new Contract(
+        flatMoneyContracts.DelayedOrder,
+        DelayedOrderAbi,
+        pool.signer
+      );
+
+      // top up gas
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x10000000000000000"
+      ]);
+      await provider.send("evm_mine", []);
+
+      await setTokenAmount({
+        amount: new BigNumber(100).times(1e18).toString(),
+        provider,
+        tokenAddress: RETH,
+        slot: RETH_SLOT,
+        userAddress: pool.address
+      });
+      await setTokenAmount({
+        amount: new BigNumber(100).times(1e18).toString(),
+        provider,
+        tokenAddress: UNIT,
+        slot: UNIT_SLOT,
+        userAddress: pool.address
+      });
+
+      const currentAssets: any[] = await pool.managerLogic.getSupportedAssets();
+      const exisitingAssets = currentAssets.map(item => {
+        return {
+          asset: item[0],
+          isDeposit: item[1]
+        };
+      });
+
+      const newAssets: AssetEnabled[] = [
+        ...exisitingAssets,
+        { asset: CONTRACT_ADDRESS[network].USDC, isDeposit: true },
+        { asset: CONTRACT_ADDRESS[network].WETH, isDeposit: true },
+        {
+          asset: UNIT,
+          isDeposit: false
+        },
+        {
+          asset: RETH,
+          isDeposit: false
+        }
+      ];
+      await pool.changeAssets(newAssets);
+    });
+
+    it("mint UNIT", async () => {
+      //approve
+      await pool.approveSpender(delayOrderContract.address, RETH, MAX_AMOUNT);
+      const collateralAllowanceDelta = await allowanceDelta(
+        pool.address,
+        RETH,
+        delayOrderContract.address,
+        pool.signer
+      );
+      await expect(collateralAllowanceDelta.gt(0));
+
+      const depositAmountStr = new BigNumber(1).times(1e18).toString();
+      const tx = await pool.mintUnitViaFlatMoney(
+        depositAmountStr,
+        0.5,
+        10, // set higher to tolerate high gasPrice returned by forked local chain
+        null,
+        false
+      );
+      expect(tx).not.toBe(null);
+      const existingOrder = await delayOrderContract.getAnnouncedOrder(
+        pool.address
+      );
+      expect(existingOrder.orderType).toBe(1);
+    });
+
+    it("cancel order", async () => {
+      await provider.send("evm_increaseTime", [60 * 2]); // more than 1 min
+      await pool.cancelOrderViaFlatMoney();
+      const existingOrder = await delayOrderContract.getAnnouncedOrder(
+        pool.address
+      );
+      expect(existingOrder.orderType).toBe(0);
+    });
+
+    it("redeem UNIT", async () => {
+      const withdrawAmountStr = new BigNumber(2).times(1e18).toString();
+      const tx = await pool.redeemUnitViaFlatMoney(
+        withdrawAmountStr,
+        0.5,
+        10, //  set higher to tolerate high gasPrice returned by forked local chain
+        null,
+        false
+      );
+      expect(tx).not.toBe(null);
+      const existingOrder = await delayOrderContract.getAnnouncedOrder(
+        pool.address
+      );
+      expect(existingOrder.orderType).toBe(2);
+
+      await provider.send("evm_increaseTime", [60 * 2]); // more than 1 min
+      await pool.cancelOrderViaFlatMoney();
+    });
+
+    it("keeperFee is small", async () => {
+      const provider = new ethers.providers.JsonRpcProvider(rpcUrl);
+      const walletOnChain = wallet.connect(provider);
+      const dhedge = new Dhedge(walletOnChain, network);
+      const pool = await dhedge.loadPool(TEST_POOL[network]);
+      const keeperFee = await getKeeperFee(pool, 3);
+      expect(keeperFee).toBeTruthy();
+    });
+  });
+};
+
+testingHelper({
+  network: Network.BASE,
+  testingRun: testFlatMoney
+});

package/src/test/uniswap.test.ts

@@ -1,5 +1,4 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { FeeAmount } from "@uniswap/v3-sdk";
 import { Dhedge, ethers, Pool } from "..";
 import { routerAddress } from "../config";
 import { AssetEnabled, Dapp, Network } from "../types";
@@ -76,7 +75,7 @@ const testUniswapV3 = ({ wallet, network, provider }: TestingRunParams) => {
         CONTRACT_ADDRESS[network].USDC,
         CONTRACT_ADDRESS[network].WETH,
         new BigNumber(5000).times(1e6).toFixed(0),
-        FeeAmount.LOW,
+        500,
         0.5
       );
 
@@ -121,15 +120,16 @@ const testUniswapV3 = ({ wallet, network, provider }: TestingRunParams) => {
 
       try {
         result = await pool.addLiquidityUniswapV3(
+          Dapp.UNISWAPV3,
           CONTRACT_ADDRESS[network].WETH,
           CONTRACT_ADDRESS[network].USDC,
           wethBalance,
           usdcBalance,
-          2000,
-          3000,
+          3500,
+          4000,
           null,
           null,
-          FeeAmount.LOW
+          500
           // options
         );
         await result.wait(1);
@@ -155,11 +155,20 @@ const testUniswapV3 = ({ wallet, network, provider }: TestingRunParams) => {
     });
 
     it("should increase liquidity in the existing WETH/USDC pool", async () => {
+      const usdcBalance = await dhedge.utils.getBalance(
+        CONTRACT_ADDRESS[network].USDC,
+        pool.address
+      );
+      const wethBalance = await dhedge.utils.getBalance(
+        CONTRACT_ADDRESS[network].WETH,
+        pool.address
+      );
+
       const result = await pool.increaseLiquidity(
         Dapp.UNISWAPV3,
         tokenId.toString(),
-        new BigNumber(3000).times(1e6).toFixed(0), // usdc
-        new BigNumber(1).times(1e18).toFixed(0) // eth
+        wethBalance,
+        usdcBalance // eth
       );
       // console.log("result", result);
       expect(result).not.toBe(null);
@@ -210,12 +219,12 @@ testingHelper({
   testingRun: testUniswapV3
 });
 
-testingHelper({
-  network: Network.POLYGON,
-  testingRun: testUniswapV3
-});
+// testingHelper({
+//   network: Network.POLYGON,
+//   testingRun: testUniswapV3
+// });
 
-testingHelper({
-  network: Network.ARBITRUM,
-  testingRun: testUniswapV3
-});
+// testingHelper({
+//   network: Network.ARBITRUM,
+//   testingRun: testUniswapV3
+// });

package/src/test/utils/testingHelper.ts

@@ -1,12 +1,17 @@
 import { BigNumber, ethers } from "ethers";
 import { Network } from "../../types";
 import { getWalletData } from "../wallet";
-import { CONTRACT_ADDRESS, USDC_BALANCEOF_SLOT } from "../constants";
+import {
+  CONTRACT_ADDRESS,
+  USDC_BALANCEOF_SLOT,
+  WETH_BALANCEOF_SLOT
+} from "../constants";
 
 export type TestingRunParams = {
   network: Network;
   wallet: ethers.Wallet;
   provider: ethers.providers.JsonRpcProvider;
+  rpcUrl: string;
 };
 
 type TestHelperParams = {
@@ -17,8 +22,8 @@ export const testingHelper = ({
   network,
   testingRun
 }: TestHelperParams): void => {
-  const { wallet, provider } = getWalletData(network);
-  testingRun({ network, wallet, provider });
+  const { wallet, provider, rpcUrl } = getWalletData(network);
+  testingRun({ network, wallet, provider, rpcUrl });
 };
 
 export const beforeAfterReset = ({
@@ -52,7 +57,7 @@ export const setTokenAmount = async ({
   amount: string;
   userAddress: string;
   tokenAddress: string;
-  slot: number;
+  slot: number | string;
   provider: ethers.providers.JsonRpcProvider;
 }): Promise<void> => {
   const toBytes32 = (bn: string) => {
@@ -91,6 +96,26 @@ export const setUSDCAmount = async ({
   });
 };
 
+export const setWETHAmount = async ({
+  provider,
+  userAddress,
+  amount,
+  network
+}: {
+  amount: string;
+  userAddress: string;
+  provider: ethers.providers.JsonRpcProvider;
+  network: Network;
+}): Promise<void> => {
+  await setTokenAmount({
+    amount,
+    userAddress,
+    provider,
+    tokenAddress: CONTRACT_ADDRESS[network].WETH,
+    slot: WETH_BALANCEOF_SLOT[network]
+  });
+};
+
 export const wait = (seconds: number): Promise<void> => {
   return new Promise(resolve => setTimeout(resolve, seconds * 1000));
 };

package/src/test/velodromeCL.test.ts

@@ -0,0 +1,223 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import BigNumber from "bignumber.js";
+import { Dhedge, Pool, ethers } from "..";
+import { nonfungiblePositionManagerAddress } from "../config";
+import { AssetEnabled, Dapp, Network } from "../types";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import {
+  TestingRunParams,
+  beforeAfterReset,
+  setUSDCAmount,
+  setWETHAmount,
+  testingHelper
+} from "./utils/testingHelper";
+import { balanceDelta } from "./utils/token";
+import INonfungiblePositionManager from "../abi/INonfungiblePositionManager.json";
+
+const testVelodromeCL = ({ wallet, network, provider }: TestingRunParams) => {
+  const VELODROME_POSITION_MANGER = nonfungiblePositionManagerAddress[network][
+    Dapp.VELODROMECL
+  ]!;
+
+  const USDC = CONTRACT_ADDRESS[network].USDC;
+  const WETH = CONTRACT_ADDRESS[network].WETH;
+  const USDC_WETH_CL_GAUGE =
+    CONTRACT_ADDRESS[network].VELODROME_CL_USDC_WETH_GAUGE;
+  const VELO = CONTRACT_ADDRESS[network].VELO;
+
+  let dhedge: Dhedge;
+  let pool: Pool;
+  let velodromePositionManager: ethers.Contract;
+  let tokenId: string;
+  jest.setTimeout(100000);
+
+  describe(`[${network}] veldorome CL  tests`, () => {
+    beforeAll(async () => {
+      // top up ETH (gas)
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x100000000000000"
+      ]);
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+      await setUSDCAmount({
+        amount: new BigNumber(10000).times(1e6).toFixed(0),
+        userAddress: pool.address,
+        network,
+        provider
+      });
+      await setWETHAmount({
+        amount: new BigNumber(3).times(1e18).toFixed(0),
+        userAddress: pool.address,
+        network,
+        provider
+      });
+
+      const newAssets: AssetEnabled[] = [
+        { asset: USDC, isDeposit: true },
+        { asset: WETH, isDeposit: true },
+        {
+          asset: VELODROME_POSITION_MANGER,
+          isDeposit: false
+        }
+      ];
+      await pool.changeAssets(newAssets);
+
+      velodromePositionManager = new ethers.Contract(
+        VELODROME_POSITION_MANGER,
+        INonfungiblePositionManager.abi,
+        pool.signer
+      );
+    });
+
+    beforeAfterReset({ beforeAll, afterAll, provider });
+
+    // describe("Liquidity", () => {
+    //   it("approves unlimited USDC and WETH on for Velodrome CL", async () => {
+    //     await pool.approveSpender(VELODROME_POSITION_MANGER, USDC, MAX_AMOUNT);
+    //     await pool.approveSpender(VELODROME_POSITION_MANGER, WETH, MAX_AMOUNT);
+    //     const UsdcAllowanceDelta = await allowanceDelta(
+    //       pool.address,
+    //       USDC,
+    //       VELODROME_POSITION_MANGER,
+    //       pool.signer
+    //     );
+    //     await expect(UsdcAllowanceDelta.gt(0));
+    //   });
+
+    //   it("adds USDC and WETH to a Velodrome CL (mint position)", async () => {
+    //     const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+    //     const wethBalance = await pool.utils.getBalance(WETH, pool.address);
+    //     await pool.addLiquidityUniswapV3(
+    //       Dapp.VELODROMECL,
+    //       USDC,
+    //       WETH,
+    //       usdcBalance.div(2),
+    //       wethBalance.div(2),
+    //       null,
+    //       null,
+    //       193700,
+    //       193900,
+    //       100
+    //     );
+
+    //     tokenId = (
+    //       await velodromePositionManager.tokenOfOwnerByIndex(pool.address, 0)
+    //     ).toString();
+    //     expect(tokenId).not.toBe(null);
+    //   });
+
+    //   it("increases liquidity in a CL position", async () => {
+    //     const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+    //     const wethBalance = await pool.utils.getBalance(WETH, pool.address);
+    //     const positionBefore = await velodromePositionManager.positions(
+    //       tokenId
+    //     );
+    //     await pool.increaseLiquidity(
+    //       Dapp.VELODROMECL,
+    //       tokenId,
+    //       usdcBalance.div(2),
+    //       wethBalance.div(2)
+    //     );
+    //     const positionAfter = await velodromePositionManager.positions(tokenId);
+    //     expect(positionAfter.liquidity.gt(positionBefore.liquidity));
+    //   });
+
+    //   it("decreases liquidity from a CL position", async () => {
+    //     const positionBefore = await velodromePositionManager.positions(
+    //       tokenId
+    //     );
+    //     await pool.decreaseLiquidity(Dapp.VELODROMECL, tokenId, 50);
+    //     const positionAfter = await velodromePositionManager.positions(tokenId);
+    //     expect(positionAfter.liquidity.lt(positionBefore.liquidity));
+    //   });
+
+    //   it("collects fess of a CL position", async () => {
+    //     await provider.send("evm_increaseTime", [24 * 3600 * 3]); // 1 day
+    //     await provider.send("evm_mine", []);
+    //     await pool.claimFees(Dapp.VELODROMECL, tokenId);
+    //     expect((await balanceDelta(pool.address, USDC, pool.signer)).gt(0));
+    //   });
+    // });
+    describe("Liquidity staking", () => {
+      it("stakes a CL position in gauge", async () => {
+        await pool.approveSpender(VELODROME_POSITION_MANGER, USDC, MAX_AMOUNT);
+        await pool.approveSpender(VELODROME_POSITION_MANGER, WETH, MAX_AMOUNT);
+        const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+        const wethBalance = await pool.utils.getBalance(WETH, pool.address);
+        await pool.addLiquidityUniswapV3(
+          Dapp.VELODROMECL,
+          USDC,
+          WETH,
+          usdcBalance.div(2),
+          wethBalance.div(2),
+          null,
+          null,
+          193700,
+          193900,
+          100
+        );
+
+        tokenId = (
+          await velodromePositionManager.tokenOfOwnerByIndex(pool.address, 0)
+        ).toString();
+        await pool.approveSpenderNFT(
+          USDC_WETH_CL_GAUGE,
+          VELODROME_POSITION_MANGER,
+          tokenId
+        );
+        await pool.stakeInGauge(Dapp.VELODROMECL, USDC_WETH_CL_GAUGE, tokenId);
+        expect(await velodromePositionManager.ownerOf(tokenId)).toBe(
+          USDC_WETH_CL_GAUGE
+        );
+      });
+
+      it("decreases liquidity from a staked CL position", async () => {
+        const positionBefore = await velodromePositionManager.positions(
+          tokenId
+        );
+        await pool.decreaseLiquidity(Dapp.VELODROMECL, tokenId, 50);
+        const positionAfter = await velodromePositionManager.positions(tokenId);
+        expect(positionAfter.liquidity.lt(positionBefore.liquidity));
+      });
+
+      it("increases liquidity in a staked CL position", async () => {
+        const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+        const wethBalance = await pool.utils.getBalance(WETH, pool.address);
+        const positionBefore = await velodromePositionManager.positions(
+          tokenId
+        );
+        await pool.approveSpender(USDC_WETH_CL_GAUGE, USDC, MAX_AMOUNT);
+        await pool.approveSpender(USDC_WETH_CL_GAUGE, WETH, MAX_AMOUNT);
+        await pool.increaseLiquidity(
+          Dapp.VELODROMECL,
+          tokenId,
+          usdcBalance.div(2),
+          wethBalance.div(2)
+        );
+        const positionAfter = await velodromePositionManager.positions(tokenId);
+        expect(positionAfter.liquidity.gt(positionBefore.liquidity));
+      });
+
+      it("collects fess of a staked CL position", async () => {
+        await provider.send("evm_increaseTime", [24 * 3600]); // 1 day
+        await provider.send("evm_mine", []);
+        await pool.claimFees(Dapp.VELODROMECL, tokenId);
+        expect((await balanceDelta(pool.address, VELO, pool.signer)).gt(0));
+      });
+
+      it("unstakes a CL position from a gauge", async () => {
+        await pool.unstakeFromGauge(USDC_WETH_CL_GAUGE, tokenId);
+        expect(
+          (await velodromePositionManager.ownerOf(tokenId)).toLowerCase()
+        ).toBe(pool.address.toLowerCase());
+      });
+    });
+  });
+};
+
+testingHelper({
+  network: Network.OPTIMISM,
+  testingRun: testVelodromeCL
+});

package/src/test/wallet.ts

@@ -38,12 +38,15 @@ export const getWalletData = (
 ): {
   wallet: ethers.Wallet;
   provider: ethers.providers.JsonRpcProvider;
+  rpcUrl: string;
 } => {
   const provider = new ethers.providers.JsonRpcProvider(
     `http://127.0.0.1:${networkPortMap[network]}/`
   );
+  const rpcUrl = process.env[`${network.toUpperCase()}_URL`] || "";
   return {
     wallet: new ethers.Wallet(process.env.PRIVATE_KEY as string, provider),
-    provider
+    provider,
+    rpcUrl
   };
 };

package/src/types.ts

@@ -21,6 +21,7 @@ export enum Dapp {
   TOROS = "toros",
   VELODROME = "velodrome",
   VELODROMEV2 = "velodromeV2",
+  VELODROMECL = "velodromeCL",
   LYRA = "lyra",
   ZEROEX = "0x",
   RAMSES = "ramses",

package/dist/services/uniswap/types.d.ts

@@ -1,3 +0,0 @@
-import { FeeAmount } from "@uniswap/v3-sdk";
-import { ethers } from "ethers";
-export declare type UniswapV3MintParams = [string, string, FeeAmount, number, number, ethers.BigNumber | string, ethers.BigNumber | string, ethers.BigNumber | string, ethers.BigNumber | string, string, number];

package/src/services/uniswap/types.ts

@@ -1,16 +0,0 @@
-import { FeeAmount } from "@uniswap/v3-sdk";
-import { ethers } from "ethers";
-
-export type UniswapV3MintParams = [
-  string,
-  string,
-  FeeAmount,
-  number,
-  number,
-  ethers.BigNumber | string,
-  ethers.BigNumber | string,
-  ethers.BigNumber | string,
-  ethers.BigNumber | string,
-  string,
-  number
-];