@dhedge/v2-sdk 2.1.8 → 2.2.0

package/src/test/hyperliquid.test.ts

@@ -1,107 +0,0 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-
-import { Dhedge, Pool } from "..";
-
-import { Network } from "../types";
-import { TEST_POOL } from "./constants";
-
-import { TestingRunParams, testingHelper } from "./utils/testingHelper";
-
-// import { balanceDelta } from "./utils/token";
-
-const testHyperliquid = ({ wallet, network }: TestingRunParams) => {
-  let dhedge: Dhedge;
-  let pool: Pool;
-  jest.setTimeout(100000);
-
-  describe(`pool on ${network}`, () => {
-    beforeAll(async () => {
-      dhedge = new Dhedge(wallet, network);
-      pool = await dhedge.loadPool(TEST_POOL[network]);
-      // // top up gas
-      // await provider.send("hardhat_setBalance", [
-      //   wallet.address,
-      //   "0x10000000000000000"
-      // ]);
-      // await provider.send("evm
-      // _mine", []);
-      // // top up USDC
-      // await setUSDCAmount({
-      //   amount: new BigNumber(2).times(1e6).toFixed(0),
-      //   userAddress: pool.address,
-      //   network,
-      //   provider
-      // });
-    });
-
-    // it("approves unlimited USDC on Hyperliquid Core Wallet", async () => {
-    //   await pool.approve(
-    //     Dapp.HYPERLIQUID,
-    //     USDC,
-    //     MAX_AMOUNT,
-    //     await getTxOptions(network)
-    //   );
-    //   const usdcAllowanceDelta = await allowanceDelta(
-    //     pool.address,
-    //     USDC,
-    //     routerAddress[network][Dapp.HYPERLIQUID]!,
-    //     pool.signer
-    //   );
-    //   await expect(usdcAllowanceDelta.gt(0));
-    // });
-
-    // it("deposits USDC into Hyperliquid Core Wallet", async () => {
-    //   await pool.depositHyperliquid(
-    //     "30000000", // 5 USDC with 6 decimals,
-    //     4294967295
-    //   );
-    //   expect(
-    //     (await balanceDelta(pool.address, USDC, pool.signer)).eq("-20000000")
-    //   ).toBe(true);
-    // });
-
-    // it("move 5 USDC from Perp to Spot Wallet", async () => {
-    //   const tx = await pool.perpToSpotHyperliquid(
-    //     0,
-    //     "5000000" // 5 USDC with 6 decimals
-    //   );
-    //   expect(tx).toBeDefined();
-    // });
-
-    // it("withdraws USDC from Hyperliquid Spot Wallet", async () => {
-    //   const tx = await pool.withdrawHyperliquid(
-    //     "784577548" // 5 USDC with 6 decimals
-    //   );
-    //   expect(tx).toBeDefined();
-    // });
-
-    // it("sets up a BTC_USDC buy order", async () => {
-    //   const tx = await pool.openMarketOrderHyperliquid(
-    //     10182, // HYPE SPOT
-    //     true, // is long
-    //     25, // 25 USD value of BTC,
-    //     1, // 0.5% slippage,
-    //     null,
-    //     true
-    //   );
-    //   expect(tx).toBeDefined();
-    // });
-
-    it("closes a position on Hyperliquid", async () => {
-      const tx = await pool.closePositionHyperliquid(
-        1, // ETH Perp,
-        50, // percentage to close
-        1, // 0.5% slippage,
-        null,
-        true
-      );
-      expect(tx).toBeDefined();
-    });
-  });
-};
-
-testingHelper({
-  network: Network.HYPERLIQUID,
-  testingRun: testHyperliquid,
-  onFork: false
-});

package/src/test/ramses.test.ts

@@ -1,190 +0,0 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Dhedge, Pool } from "..";
-import { routerAddress } from "../config";
-import { Dapp, Network } from "../types";
-import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
-import {
-  TestingRunParams,
-  beforeAfterReset,
-  testingHelper
-} from "./utils/testingHelper";
-import { allowanceDelta, balanceDelta } from "./utils/token";
-import { getWalletData } from "./wallet";
-
-const testRamses = ({ network, provider }: TestingRunParams) => {
-  const USDC_swETH_Lp = "0xf1a5444a7ed5f24962a118512b076a015b0e6c0b";
-  const USDC_swETH_Gauge = "0x9765cdaec6395b04737edc22c5b3e7d85677328a";
-  const RAM = "0xaaa6c1e32c55a7bfa8066a6fae9b42650f262418";
-  const xoRAM = "0xaaa1ee8dc1864ae49185c368e8c64dd780a50fb7";
-
-  const USDC = CONTRACT_ADDRESS[network].USDC;
-  const SWETH = CONTRACT_ADDRESS[network].SWETH;
-
-  let dhedge: Dhedge;
-  let pool: Pool;
-  jest.setTimeout(100000);
-
-  describe(`[${network}] ramses tests`, () => {
-    beforeAll(async () => {
-      const { wallet } = getWalletData(network);
-      // 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 pool.trade(Dapp.ONEINCH, USDC, SWETH, (5 * 1e6).toString());
-    });
-    beforeAfterReset({ beforeAll, afterAll, provider });
-
-    it("approves unlimited USDC and swETH on for Ramses", async () => {
-      await pool.approve(Dapp.RAMSES, USDC, MAX_AMOUNT);
-      await pool.approve(Dapp.RAMSES, SWETH, MAX_AMOUNT);
-      const UsdcAllowanceDelta = await allowanceDelta(
-        pool.address,
-        USDC,
-        routerAddress[network].ramses!,
-        pool.signer
-      );
-      await expect(UsdcAllowanceDelta.gt(0));
-    });
-
-    it("adds USDC and swETH to a Ramses volatile pool", async () => {
-      const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
-      const swethBalance = await pool.utils.getBalance(SWETH, pool.address);
-      await pool.addLiquidityV2(
-        Dapp.RAMSES,
-        USDC,
-        SWETH,
-        usdcBalance,
-        swethBalance,
-        false
-      );
-
-      const lpTokenDelta = await balanceDelta(
-        pool.address,
-        USDC_swETH_Lp,
-        pool.signer
-      );
-      expect(lpTokenDelta.gt(0));
-    });
-
-    it("should stake USDC-swETH LP in a gauge", async () => {
-      const balance = await dhedge.utils.getBalance(
-        USDC_swETH_Lp,
-        pool.address
-      );
-      await pool.approveSpender(USDC_swETH_Gauge, USDC_swETH_Lp, MAX_AMOUNT);
-      await pool.stakeInGauge(Dapp.RAMSES, USDC_swETH_Gauge, balance);
-      const gaugeBalance = await balanceDelta(
-        pool.address,
-        USDC_swETH_Gauge,
-        pool.signer
-      );
-      expect(gaugeBalance.gt(0));
-    });
-
-    it("should claim rewards from Gauge", async () => {
-      await provider.send("evm_increaseTime", [24 * 60 * 60]); // 1 day
-      await provider.send("evm_mine", []);
-      const claimTx = await pool.claimFees(Dapp.RAMSES, USDC_swETH_Gauge);
-      expect(claimTx).not.toBe(null);
-      const ramBalanceDelta = await balanceDelta(
-        pool.address,
-        RAM,
-        pool.signer
-      );
-      const xoRamBalanceDelta = await balanceDelta(
-        pool.address,
-        xoRAM,
-        pool.signer
-      );
-      expect(ramBalanceDelta.gt(0));
-      expect(xoRamBalanceDelta.gt(0));
-    });
-
-    it("createVest for xoRAM", async () => {
-      const xoRAMBalanceBefore = await dhedge.utils.getBalance(
-        xoRAM,
-        pool.address
-      );
-      expect(xoRAMBalanceBefore.gt(0));
-      const vestTx = await pool.vestTokens(xoRAM, xoRAMBalanceBefore);
-      expect(vestTx).not.toBe(null);
-      const xoRAMBalanceAfter = await dhedge.utils.getBalance(
-        xoRAM,
-        pool.address
-      );
-      expect(xoRAMBalanceAfter.eq(0));
-    });
-
-    it("exitVest for xoRAM", async () => {
-      await provider.send("evm_increaseTime", [3600 * 24 * 90]); // 90 days
-      await provider.send("evm_mine", []);
-
-      const ramBalanceBefore = await dhedge.utils.getBalance(RAM, pool.address);
-
-      const exitvestTx = await pool.exitVestedToken(xoRAM, 0);
-      const xoRAMBalanceAfter = await dhedge.utils.getBalance(
-        USDC_swETH_Gauge,
-        pool.address
-      );
-      expect(exitvestTx).not.toBe(null);
-      const ramBalanceAfter = await dhedge.utils.getBalance(RAM, pool.address);
-      expect(xoRAMBalanceAfter.eq(0));
-      expect(ramBalanceAfter.gt(ramBalanceBefore));
-    });
-
-    it("should unStake USDC-swETH LP from a gauge", async () => {
-      const gaugeBalance = await dhedge.utils.getBalance(
-        USDC_swETH_Gauge,
-        pool.address
-      );
-      await pool.unstakeFromGauge(USDC_swETH_Gauge, gaugeBalance);
-      const lpTokenDelta = await balanceDelta(
-        pool.address,
-        USDC_swETH_Lp,
-        pool.signer
-      );
-      expect(lpTokenDelta.gt(0));
-    });
-
-    it("approves unlimited USDC/swETH LP for Ramses", async () => {
-      await pool.approve(Dapp.RAMSES, USDC_swETH_Lp, MAX_AMOUNT);
-      const lpAllowanceDelta = await allowanceDelta(
-        pool.address,
-        USDC_swETH_Lp,
-        routerAddress[network].ramses!,
-        pool.signer
-      );
-      expect(lpAllowanceDelta.gt(0));
-    });
-
-    it("should remove all liquidity from an existing pool ", async () => {
-      const balance = await dhedge.utils.getBalance(
-        USDC_swETH_Lp,
-        pool.address
-      );
-      await pool.removeLiquidityV2(Dapp.RAMSES, USDC, SWETH, balance, false);
-      const usdcBalanceDelta = await balanceDelta(
-        pool.address,
-        USDC,
-        pool.signer
-      );
-      const swETHBalanceDelta = await balanceDelta(
-        pool.address,
-        SWETH,
-        pool.signer
-      );
-      expect(usdcBalanceDelta.gt(0));
-      expect(swETHBalanceDelta.gt(0));
-    });
-  });
-};
-
-testingHelper({
-  network: Network.ARBITRUM,
-  testingRun: testRamses
-});

package/src/test/ramsesCL.test.ts

@@ -1,155 +0,0 @@
-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,
-  setChainlinkTimeout,
-  testingHelper
-} from "./utils/testingHelper";
-import { allowanceDelta, balanceDelta } from "./utils/token";
-import INonfungiblePositionManager from "../abi/INonfungiblePositionManager.json";
-
-const testRamsesCL = ({ wallet, network, provider }: TestingRunParams) => {
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  const RAMSES_POSITION_MANGER = nonfungiblePositionManagerAddress[network][
-    Dapp.RAMSESCL
-  ]!;
-
-  const USDC = CONTRACT_ADDRESS[network].USDC;
-  const WETH = CONTRACT_ADDRESS[network].WETH;
-  //if other chains then define per network
-  const RAM = "0xaaa6c1e32c55a7bfa8066a6fae9b42650f262418";
-  const ARB = "0x912ce59144191c1204e64559fe8253a0e49e6548";
-
-  let dhedge: Dhedge;
-  let pool: Pool;
-  let ramsesPositionManager: ethers.Contract;
-  let tokenId: string;
-  jest.setTimeout(100000);
-
-  describe(`[${network}] Ramses 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]);
-
-      // setChainlinkTimeout
-      await setChainlinkTimeout({ pool, provider }, 86400 * 365);
-
-      const newAssets: AssetEnabled[] = [
-        { asset: USDC, isDeposit: true },
-        { asset: WETH, isDeposit: true },
-        {
-          asset: RAMSES_POSITION_MANGER,
-          isDeposit: false
-        },
-        {
-          asset: ARB,
-          isDeposit: false
-        }
-      ];
-      await pool.changeAssets(newAssets);
-      await pool.approve(Dapp.ONEINCH, USDC, MAX_AMOUNT);
-      await pool.trade(Dapp.ONEINCH, USDC, WETH, (2.5 * 1e6).toString());
-
-      ramsesPositionManager = new ethers.Contract(
-        RAMSES_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(RAMSES_POSITION_MANGER, USDC, MAX_AMOUNT);
-        await pool.approveSpender(RAMSES_POSITION_MANGER, WETH, MAX_AMOUNT);
-        const UsdcAllowanceDelta = await allowanceDelta(
-          pool.address,
-          USDC,
-          RAMSES_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.RAMSESCL,
-          WETH,
-          USDC,
-          usdcBalance.div(2),
-          wethBalance.div(2),
-          null,
-          null,
-          -204460,
-          -193470,
-          500
-        );
-
-        tokenId = (
-          await ramsesPositionManager.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 ramsesPositionManager.positions(tokenId);
-        await pool.increaseLiquidity(
-          Dapp.RAMSESCL,
-          tokenId,
-          usdcBalance.div(2),
-          wethBalance.div(2)
-        );
-        const positionAfter = await ramsesPositionManager.positions(tokenId);
-        expect(positionAfter.liquidity.gt(positionBefore.liquidity));
-      });
-
-      it("decreases liquidity from a CL position", async () => {
-        const positionBefore = await ramsesPositionManager.positions(tokenId);
-        await pool.decreaseLiquidity(Dapp.RAMSESCL, tokenId, 50);
-        const positionAfter = await ramsesPositionManager.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.RAMSESCL, tokenId);
-        expect((await balanceDelta(pool.address, USDC, pool.signer)).gt(0));
-      });
-
-      it("get rewards of a CL position", async () => {
-        await provider.send("evm_increaseTime", [24 * 3600 * 3]); // 1 day
-        await provider.send("evm_mine", []);
-        await pool.getRewards(Dapp.RAMSESCL, tokenId, [RAM]);
-        expect((await balanceDelta(pool.address, RAM, pool.signer)).gt(0));
-      });
-
-      it("decreases 100% liquidity and burns a CL position", async () => {
-        await pool.decreaseLiquidity(Dapp.RAMSESCL, tokenId, 100);
-        const positionAfter = await ramsesPositionManager.balanceOf(
-          pool.address
-        );
-        expect(positionAfter.eq(0));
-      });
-    });
-  });
-};
-
-testingHelper({
-  network: Network.ARBITRUM,
-  testingRun: testRamsesCL
-});

package/src/test/synthetix.test.ts

@@ -1,36 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Dhedge } from "..";
-import { Dapp, Network } from "../types";
-import { TEST_POOL } from "./constants";
-//import { getTxOptions } from "./txOptions";
-
-import { wallet } from "./wallet";
-
-const TEST_POOL_OP = TEST_POOL.optimism;
-
-let dhedge: Dhedge;
-let options: any;
-jest.setTimeout(100000);
-
-describe("pool", () => {
-  beforeAll(async () => {
-    dhedge = new Dhedge(wallet, Network.OPTIMISM);
-    //options = await getTxOptions();
-    options = { gasLimit: "3000000" };
-  });
-
-  it("should swap sETH into sUSD on Synthetix", async () => {
-    const pool = await dhedge.loadPool(TEST_POOL_OP);
-    const result = await pool.trade(
-      Dapp.SYNTHETIX,
-      "sETH",
-      "sUSD",
-      "1000000000000000",
-      undefined,
-      options
-    );
-
-    console.log(result);
-    expect(result).not.toBe(null);
-  });
-});

package/src/test/utils/futures.ts

@@ -1,14 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Pool, ethers } from "../..";
-import ISynthetixFuturesMarketV2 from "../../abi/ISynthetixFuturesMarketV2.json";
-export async function getDelayedOrders(
-  market: string,
-  pool: Pool
-): Promise<any> {
-  const futuresMarket = new ethers.Contract(
-    market,
-    ISynthetixFuturesMarketV2.abi,
-    pool.signer
-  );
-  return await futuresMarket.delayedOrders(pool.address);
-}