@dhedge/v2-sdk 2.1.8 → 2.2.0

package/src/test/balancer.test.ts

@@ -4,123 +4,131 @@ import { Dhedge, Pool } from "..";
 import { routerAddress } from "../config";
 import { Dapp, Network } from "../types";
 import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import {
+  TestingRunParams,
+  testingHelper
+} from "./utils/testingHelper";
 import { allowanceDelta, balanceDelta } from "./utils/token";
 
-import { wallet } from "./wallet";
+const testBalancer = ({ wallet, network }: TestingRunParams) => {
+  const USDC = CONTRACT_ADDRESS[network].USDC;
+  const WETH = CONTRACT_ADDRESS[network].WETH;
+  const WSTETH = CONTRACT_ADDRESS[network].WSTETH;
+  const BALANCER_POOL = CONTRACT_ADDRESS[network].BALANCER_WSTETH_WETH_POOL;
+  const BLANCER_GAUGE = CONTRACT_ADDRESS[network].BALANCER_WSTETH_WETH_GAUGE;
 
-const network = Network.ARBITRUM;
-const USDC = CONTRACT_ADDRESS[network].USDC;
-const WETH = CONTRACT_ADDRESS[network].WETH;
-const WSTETH = CONTRACT_ADDRESS[network].WSTETH;
-const BALANCER_POOL = CONTRACT_ADDRESS[network].BALANCER_WSTETH_WETH_POOL;
-const BLANCER_GAUGE = CONTRACT_ADDRESS[network].BALANCER_WSTETH_WETH_GAUGE;
+  let dhedge: Dhedge;
+  let pool: Pool;
+  jest.setTimeout(100000);
 
-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]);
+      await pool.approve(Dapp.ONEINCH, USDC, MAX_AMOUNT);
+      await pool.trade(Dapp.ONEINCH, USDC, WETH, "1000000", 0.5);
+      await pool.trade(Dapp.ONEINCH, USDC, WSTETH, "1000000", 0.5);
+    });
 
-describe("pool", () => {
-  beforeAll(async () => {
-    dhedge = new Dhedge(wallet, network);
-    pool = await dhedge.loadPool(TEST_POOL[network]);
-    await pool.approve(Dapp.ONEINCH, USDC, MAX_AMOUNT);
-    await pool.trade(Dapp.ONEINCH, USDC, WETH, "1000000", 0.5);
-    await pool.trade(Dapp.ONEINCH, USDC, WSTETH, "1000000", 0.5);
-  });
+    it("approves unlimited stWETH on Balancer", async () => {
+      await pool.approve(Dapp.BALANCER, WSTETH, MAX_AMOUNT);
+      const stWETHAllowanceDelta = await allowanceDelta(
+        pool.address,
+        WSTETH,
+        routerAddress[network].balancer!,
+        pool.signer
+      );
+      expect(stWETHAllowanceDelta.gt(0)).toBe(true);
+    });
 
-  it("approves unlimited stWETH on Balancer", async () => {
-    await pool.approve(Dapp.BALANCER, WSTETH, MAX_AMOUNT);
-    const stWETHAllowanceDelta = await allowanceDelta(
-      pool.address,
-      WSTETH,
-      routerAddress[network].balancer!,
-      pool.signer
-    );
-    await expect(stWETHAllowanceDelta.gt(0));
-  });
+    it("approves unlimited WETH on Balancer", async () => {
+      await pool.approve(Dapp.BALANCER, WETH, MAX_AMOUNT);
+      const wethAllowanceDelta = await allowanceDelta(
+        pool.address,
+        WETH,
+        routerAddress[network].balancer!,
+        pool.signer
+      );
+      expect(wethAllowanceDelta.gt(0)).toBe(true);
+    });
 
-  it("approves unlimited WETH on Balancer", async () => {
-    await pool.approve(Dapp.BALANCER, WETH, MAX_AMOUNT);
-    const wethAllowanceDelta = await allowanceDelta(
-      pool.address,
-      WETH,
-      routerAddress[network].balancer!,
-      pool.signer
-    );
-    await expect(wethAllowanceDelta.gt(0));
-  });
+    it("should add liquidity in a Balancer pool", async () => {
+      const wstETHBalance = await pool.utils.getBalance(WSTETH, pool.address);
+      const wethBalance = await pool.utils.getBalance(WETH, pool.address);
+      await pool.joinBalancerPool(
+        "0x36bf227d6bac96e2ab1ebb5492ecec69c691943f000200000000000000000316", //wstETH-WETH on Arbitrum
+        [WSTETH, WETH],
+        [wstETHBalance.toString(), wethBalance.toString()]
+      );
+      const lpBalanceDelta = await balanceDelta(
+        pool.address,
+        BALANCER_POOL,
+        pool.signer
+      );
+      expect(lpBalanceDelta.gt(0)).toBe(true);
+    });
 
-  it("should add liquidity in a Balancer pool", async () => {
-    const wstETHBalance = await pool.utils.getBalance(WSTETH, pool.address);
-    const wethBalance = await pool.utils.getBalance(WETH, pool.address);
-    await pool.joinBalancerPool(
-      "0x36bf227d6bac96e2ab1ebb5492ecec69c691943f000200000000000000000316", //wstETH-WETH on Arbitrum
-      [WSTETH, WETH],
-      [wstETHBalance.toString(), wethBalance.toString()]
-    );
-    const lpBalanceDelta = await balanceDelta(
-      pool.address,
-      BALANCER_POOL,
-      pool.signer
-    );
-    expect(lpBalanceDelta.gt(0));
-  });
+    it("approves unlimited LP Token on Balancer Vault", async () => {
+      await pool.approveSpender(BLANCER_GAUGE, BALANCER_POOL, MAX_AMOUNT);
+      const gaugeAllowanceDelta = await allowanceDelta(
+        pool.address,
+        BALANCER_POOL,
+        BLANCER_GAUGE,
+        pool.signer
+      );
+      expect(gaugeAllowanceDelta.gt(0)).toBe(true);
+    });
 
-  it("approves unlimited LP Token on Balancer Vault", async () => {
-    await pool.approveSpender(BLANCER_GAUGE, BALANCER_POOL, MAX_AMOUNT);
-    const gaugeAllowanceDelta = await allowanceDelta(
-      pool.address,
-      BALANCER_POOL,
-      BLANCER_GAUGE,
-      pool.signer
-    );
-    await expect(gaugeAllowanceDelta.gt(0));
-  });
+    it("stakes LP tokens in Balancer vault", async () => {
+      const lpTokenBalance = await pool.utils.getBalance(
+        BALANCER_POOL,
+        pool.address
+      );
+      await pool.stakeInGauge(Dapp.BALANCER, BLANCER_GAUGE, lpTokenBalance);
+      const lpBalanceDelta = await balanceDelta(
+        pool.address,
+        BALANCER_POOL,
+        pool.signer
+      );
+      expect(lpBalanceDelta.lt(0)).toBe(true);
+    });
 
-  it("stakes LP tokens in Balancer vault", async () => {
-    const lpTokenBalance = await pool.utils.getBalance(
-      BALANCER_POOL,
-      pool.address
-    );
-    await pool.stakeInGauge(Dapp.BALANCER, BLANCER_GAUGE, lpTokenBalance);
-    const lpBalanceDelta = await balanceDelta(
-      pool.address,
-      BALANCER_POOL,
-      pool.signer
-    );
-    expect(lpBalanceDelta.lt(0));
-  });
+    it("unstakes LP tokens from Balancer vault", async () => {
+      const vaultTokenBalance = await pool.utils.getBalance(
+        BLANCER_GAUGE,
+        pool.address
+      );
+      await pool.unstakeFromGauge(BLANCER_GAUGE, vaultTokenBalance);
+      const lpBalanceDelta = await balanceDelta(
+        pool.address,
+        BALANCER_POOL,
+        pool.signer
+      );
+      expect(lpBalanceDelta.gt(0)).toBe(true);
+    });
 
-  it("unstakes LP tokens from Balancer vault", async () => {
-    const vaultTokenBalance = await pool.utils.getBalance(
-      BLANCER_GAUGE,
-      pool.address
-    );
-    await pool.unstakeFromGauge(BLANCER_GAUGE, vaultTokenBalance);
-    const lpBalanceDelta = await balanceDelta(
-      pool.address,
-      BALANCER_POOL,
-      pool.signer
-    );
-    expect(lpBalanceDelta.gt(0));
+    it("should remove liquidity from an Balancer pool ", async () => {
+      const lpTokenBalance = await pool.utils.getBalance(
+        BALANCER_POOL,
+        pool.address
+      );
+      await pool.approve(Dapp.BALANCER, BALANCER_POOL, MAX_AMOUNT);
+      await pool.exitBalancerPool(
+        "0x36bf227d6bac96e2ab1ebb5492ecec69c691943f000200000000000000000316",
+        [WSTETH, WETH],
+        lpTokenBalance
+      );
+      const wethBalanceDelta = await balanceDelta(
+        pool.address,
+        WETH,
+        pool.signer
+      );
+      expect(wethBalanceDelta.gt(0)).toBe(true);
+    });
   });
+};
 
-  it("should remove liquidity from an Balancer pool ", async () => {
-    const lpTokenBalance = await pool.utils.getBalance(
-      BALANCER_POOL,
-      pool.address
-    );
-    await pool.approve(Dapp.BALANCER, BALANCER_POOL, MAX_AMOUNT);
-    await pool.exitBalancerPool(
-      "0x36bf227d6bac96e2ab1ebb5492ecec69c691943f000200000000000000000316",
-      [WSTETH, WETH],
-      lpTokenBalance
-    );
-    const wethBalanceDelta = await balanceDelta(
-      pool.address,
-      CONTRACT_ADDRESS[network].WETH,
-      pool.signer
-    );
-    expect(wethBalanceDelta.gt(0));
-  });
+testingHelper({
+  network: Network.ARBITRUM,
+  testingRun: testBalancer
 });

package/src/test/compoundV3.test.ts

@@ -1,19 +1,22 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import BigNumber from "bignumber.js";
+import { ethers } from "ethers";
 import { Dhedge, Pool } from "..";
-import { AssetEnabled, Network } from "../types";
+import { Network } from "../types";
 import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
 import {
   TestingRunParams,
   beforeAfterReset,
   setWETHAmount,
+  setChainlinkTimeout,
+  fixOracleAggregatorStaleness,
+  runWithImpersonateAccount,
   testingHelper
 } from "./utils/testingHelper";
-import { allowanceDelta, balanceDelta } from "./utils/token";
-import { getWalletData } from "./wallet";
+import { balanceDelta } from "./utils/token";
 
-const testCompoundV3 = ({ network, provider }: TestingRunParams) => {
+const testCompoundV3 = ({ wallet, network, provider }: TestingRunParams) => {
   const WETH = CONTRACT_ADDRESS[network].WETH;
   const COMPOUNDV3_WETH = CONTRACT_ADDRESS[network].COMPOUNDV3_WETH;
 
@@ -23,14 +26,13 @@ const testCompoundV3 = ({ network, provider }: TestingRunParams) => {
 
   describe(`[${network}] compound V3 tests`, () => {
     beforeAll(async () => {
-      const { wallet } = getWalletData(network);
-      // top up ETH (gas)
       await provider.send("hardhat_setBalance", [
         wallet.address,
-        "0x100000000000000"
+        "0x10000000000000000"
       ]);
       dhedge = new Dhedge(wallet, network);
       pool = await dhedge.loadPool(TEST_POOL[network]);
+
       await setWETHAmount({
         amount: new BigNumber(1e18).toFixed(0),
         userAddress: pool.address,
@@ -38,29 +40,41 @@ const testCompoundV3 = ({ network, provider }: TestingRunParams) => {
         provider
       });
 
-      const newAssets: AssetEnabled[] = [
-        { asset: WETH, isDeposit: true },
-        {
-          asset: COMPOUNDV3_WETH,
-          isDeposit: false
+      // Extend oracle timeouts so price feeds work on fork
+      await setChainlinkTimeout({ pool, provider }, 86400 * 365);
+      await fixOracleAggregatorStaleness({ pool, provider });
+
+      // Impersonate pool manager to set trader and configure assets
+      await runWithImpersonateAccount(
+        { provider, account: await pool.managerLogic.manager() },
+        async ({ signer }) => {
+          await pool.managerLogic.connect(signer).setTrader(wallet.address);
+          const newAssets = [
+            [WETH, true],
+            [COMPOUNDV3_WETH, false]
+          ];
+          await pool.managerLogic.connect(signer).changeAssets(newAssets, []);
         }
-      ];
-      await pool.managerLogic.changeAssets(newAssets, []);
+      );
     });
     beforeAfterReset({ beforeAll, afterAll, provider });
 
     it("approves unlimited WETH for cWETHv3 market", async () => {
-      await pool.approveSpender(COMPOUNDV3_WETH, WETH, MAX_AMOUNT);
-      const UsdcAllowanceDelta = await allowanceDelta(
-        pool.address,
+      const tx = await pool.approveSpender(COMPOUNDV3_WETH, WETH, MAX_AMOUNT);
+      await tx.wait(1);
+      const iERC20 = new ethers.Contract(
         WETH,
-        COMPOUNDV3_WETH,
+        ["function allowance(address,address) view returns (uint256)"],
         pool.signer
       );
-      await expect(UsdcAllowanceDelta.gt(0));
+      const wethAllowance = await iERC20.allowance(
+        pool.address,
+        COMPOUNDV3_WETH
+      );
+      expect(wethAllowance.gt(0)).toBe(true);
     });
 
-    it("lends WETH to CompundV3 WETH market", async () => {
+    it("lends WETH to CompoundV3 WETH market", async () => {
       const wethBalance = await pool.utils.getBalance(WETH, pool.address);
       await pool.lendCompoundV3(COMPOUNDV3_WETH, WETH, wethBalance);
 
@@ -69,20 +83,22 @@ const testCompoundV3 = ({ network, provider }: TestingRunParams) => {
         COMPOUNDV3_WETH,
         pool.signer
       );
-      expect(cWETHTokenDelta.gt(0));
+      expect(cWETHTokenDelta.gt(0)).toBe(true);
     });
 
-    it("withdraw WETH from CompundV3 WETH market", async () => {
-      const cWETHBalance = await pool.utils.getBalance(
-        COMPOUNDV3_WETH,
-        pool.address
+    it("withdraws WETH from CompoundV3 WETH market", async () => {
+      // Withdraw half of the originally supplied amount
+      const halfWeth = new BigNumber(1e18).div(2).toFixed(0);
+      await pool.withdrawCompoundV3(COMPOUNDV3_WETH, WETH, halfWeth);
+      const wethBalanceDelta = await balanceDelta(
+        pool.address,
+        WETH,
+        pool.signer
       );
-      await pool.withdrawCompoundV3(COMPOUNDV3_WETH, WETH, cWETHBalance);
-      const wethBalance = await balanceDelta(pool.address, WETH, pool.signer);
-      expect(wethBalance.gt(0));
+      expect(wethBalanceDelta.gt(0)).toBe(true);
     });
 
-    it("harvests rewards from CompundV3", async () => {
+    it("harvests rewards from CompoundV3", async () => {
       await pool.harvestCompoundV3Rewards(COMPOUNDV3_WETH);
     });
   });

package/src/test/constants.ts

@@ -35,8 +35,6 @@ export const SUSD = "0x8c6f28f2f1a3c87f0f938b96d27520d9751ec8d9";
 export const SETH = "0xE405de8F52ba7559f9df3C368500B6E6ae6Cee49";
 export const ARRAKIS_USDC_WETH_GAUGE =
   "0xb8888ea29e2f70ad62a3b69b1a1342720612a00d";
-export const KWENTA_ETH_PERP = "0xf86048dff23cf130107dfb4e6386f574231a5c65";
-export const KWENTA_ETH_PERP_V2 = "0x2b3bb4c683bfc5239b029131eef3b1d214478d93";
 
 export const TEST_POOL = {
   [Network.POLYGON]: "0x699fd4d6eadb216704c7e355cfa0a12f51813163",
@@ -68,7 +66,10 @@ export const CONTRACT_ADDRESS = {
     COMPOUNDV3_WETH: "",
     FLUID_WETH: "",
     TOROS: "",
-    UNIT: ""
+    UNIT: "",
+    WSTETH: "",
+    BALANCER_WSTETH_WETH_POOL: "",
+    BALANCER_WSTETH_WETH_GAUGE: ""
   },
 
   [Network.OPTIMISM]: {
@@ -79,7 +80,6 @@ export const CONTRACT_ADDRESS = {
     SUSD: "0x8c6f28f2f1a3c87f0f938b96d27520d9751ec8d9",
     WETH: "0x4200000000000000000000000000000000000006",
     WBTC: "0x68f180fcCe6836688e9084f035309E29Bf0A2095",
-    KWENTA_ETH_PERP_V2: "0x2b3bb4c683bfc5239b029131eef3b1d214478d93",
     uniswapV3: {
       nonfungiblePositionManager: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
     },
@@ -93,7 +93,10 @@ export const CONTRACT_ADDRESS = {
     VELO: "0x9560e827aF36c94D2Ac33a39bCE1Fe78631088Db",
     COMPOUNDV3_WETH: "",
     FLUID_WETH: "",
-    TOROS: "0xcacb5a722a36cff6baeb359e21c098a4acbffdfa" //ETHBEAR1X
+    TOROS: "0xcacb5a722a36cff6baeb359e21c098a4acbffdfa", //ETHBEAR1X
+    WSTETH: "",
+    BALANCER_WSTETH_WETH_POOL: "",
+    BALANCER_WSTETH_WETH_GAUGE: ""
   },
   [Network.ARBITRUM]: {
     USDC: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
@@ -121,7 +124,7 @@ export const CONTRACT_ADDRESS = {
     VELO: "",
     COMPOUNDV3_WETH: "0x6f7D514bbD4aFf3BcD1140B7344b32f063dEe486",
     FLUID_WETH: "0x45df0656f8adf017590009d2f1898eeca4f0a205",
-    TOROS: ""
+    TOROS: "0xA6711f8a184E352c5A0714a48912cD33ca4a16A0" //DYTMT
   },
   [Network.BASE]: {
     USDC: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
@@ -143,7 +146,10 @@ export const CONTRACT_ADDRESS = {
     VELO: "0x940181a94A35A4569E4529A3CDfB74e38FD98631",
     COMPOUNDV3_WETH: "",
     FLUID_WETH: "",
-    TOROS: ""
+    TOROS: "",
+    WSTETH: "",
+    BALANCER_WSTETH_WETH_POOL: "",
+    BALANCER_WSTETH_WETH_GAUGE: ""
   },
   [Network.ETHEREUM]: {
     USDC: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
@@ -165,17 +171,56 @@ export const CONTRACT_ADDRESS = {
     COMPOUNDV3_WETH: "",
     FLUID_WETH: "",
     TOROS: "",
-    UNIT: ""
+    UNIT: "",
+    WSTETH: "",
+    BALANCER_WSTETH_WETH_POOL: "",
+    BALANCER_WSTETH_WETH_GAUGE: ""
   },
   [Network.PLASMA]: {
     USDC: "",
     WETH: "0x9895d81bb462a195b4922ed7de0e3acd007c32cb",
+    WBTC: "",
     USDT: "0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb",
-    USDE: "0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34"
+    USDE: "0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34",
+    VELO: "",
+    uniswapV3: {
+      nonfungiblePositionManager: ""
+    },
+    COMPOUNDV3_WETH: "",
+    FLUID_WETH: "",
+    UNIT: "",
+    TOROS: "",
+    SUSD: "",
+    VELODROME_CL_USDC_WETH_GAUGE: "",
+    ARRAKIS_USDC_WETH_GAUGE: "",
+    ARRAKIS_USDC_WETH_LP: "",
+    WMATIC: "",
+    WSTETH: "",
+    BALANCER_WSTETH_WETH_POOL: "",
+    BALANCER_WSTETH_WETH_GAUGE: ""
   },
   [Network.HYPERLIQUID]: {
     USDC: "0xb88339cb7199b77e23db6e890353e22632ba630f",
-    WETH: ""
+    USDT: "",
+    USDE: "",
+    WETH: "",
+    WBTC: "",
+    VELO: "",
+    uniswapV3: {
+      nonfungiblePositionManager: ""
+    },
+    COMPOUNDV3_WETH: "",
+    FLUID_WETH: "",
+    UNIT: "",
+    TOROS: "",
+    SUSD: "",
+    VELODROME_CL_USDC_WETH_GAUGE: "",
+    ARRAKIS_USDC_WETH_GAUGE: "",
+    ARRAKIS_USDC_WETH_LP: "",
+    WMATIC: "",
+    WSTETH: "",
+    BALANCER_WSTETH_WETH_POOL: "",
+    BALANCER_WSTETH_WETH_GAUGE: ""
   }
 };
 
@@ -195,7 +240,7 @@ export const WETH_BALANCEOF_SLOT = {
   [Network.OPTIMISM]: 3,
   [Network.ARBITRUM]: 51,
   [Network.POLYGON]: 0,
-  [Network.BASE]: 0,
+  [Network.BASE]: 3,
   [Network.ETHEREUM]: 3,
   [Network.PLASMA]: 1,
   [Network.HYPERLIQUID]: 1

package/src/test/cowswap.test.ts

@@ -1,12 +1,26 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 
+/**
+ * CowSwap tests require a live chain connection (onFork: false).
+ * CowSwap orders are settled off-chain by solvers, so they cannot
+ * be tested on a Hardhat fork. Run with a funded wallet and
+ * PRIVATE_KEY + POLYGON_URL set in .env.
+ *
+ * Flow: approve CoW vault relayer → trade
+ * Note: estimateGas and onlyGetTxData are not supported for CowSwap
+ * because it requires two sequential transactions (submit + preSign).
+ */
+
 import { Dhedge, Pool } from "..";
 
 import { Dapp, Network } from "../types";
-import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
 import { getTxOptions } from "./txOptions";
 import { TestingRunParams, testingHelper } from "./utils/testingHelper";
-import { balanceDelta } from "./utils/token";
+import { allowanceDelta, balanceDelta } from "./utils/token";
+
+// CoW Protocol Vault Relayer — must be approved before CowSwap trades
+const COWSWAP_VAULT_RELAYER = "0xC92E8bdf79f0507f65a392b0ab4667716BFE0110";
 
 const testCowswap = ({ wallet, network }: TestingRunParams) => {
   const USDC = CONTRACT_ADDRESS[network].USDC;
@@ -16,44 +30,27 @@ const testCowswap = ({ wallet, network }: TestingRunParams) => {
   let pool: Pool;
   jest.setTimeout(100000);
 
-  describe(`pool on ${network}`, () => {
+  describe(`[${network}] cowswap tests`, () => {
     beforeAll(async () => {
       dhedge = new Dhedge(wallet, network);
       pool = await dhedge.loadPool(TEST_POOL[network]);
     });
 
-    // it("approves unlimited USDC on Cowswap", async () => {
-    //   await pool.approveSpender(
-    //     "0xC92E8bdf79f0507f65a392b0ab4667716BFE0110", //Vault relayer
-    //     USDC,
-    //     MAX_AMOUNT,
-    //     await getTxOptions(network)
-    //   );
-    //   const usdcAllowanceDelta = await allowanceDelta(
-    //     pool.address,
-    //     USDC,
-    //     "0xC92E8bdf79f0507f65a392b0ab4667716BFE0110", //Vault relayer
-    //     pool.signer
-    //   );
-    //   await expect(usdcAllowanceDelta.gt(0).toBe(true));
-    // });
-
-    // it("gets gas estimation for 2 USDC into WETH on Cowswap", async () => {
-    //   const gasEstimate = await pool.trade(
-    //     Dapp.COWSWAP,
-    //     USDC,
-    //     WETH,
-    //     "2000000",
-    //     1,
-    //     await getTxOptions(network),
-    //     true
-    //   );
-    //   console.log(
-    //     "Gas estimate for trading 2 USDC to WETH on Cowswap:",
-    //     gasEstimate
-    //   );
-    //   expect(gasEstimate.minAmountOut).not.toBeNull();
-    // });
+    it("approves unlimited USDC on Cowswap vault relayer", async () => {
+      await pool.approveSpender(
+        COWSWAP_VAULT_RELAYER,
+        USDC,
+        MAX_AMOUNT,
+        await getTxOptions(network)
+      );
+      const usdcAllowanceDelta = await allowanceDelta(
+        pool.address,
+        USDC,
+        COWSWAP_VAULT_RELAYER,
+        pool.signer
+      );
+      expect(usdcAllowanceDelta.gt(0)).toBe(true);
+    });
 
     it("trades 2 USDC into WETH on Cowswap", async () => {
       await pool.trade(
@@ -74,6 +71,7 @@ const testCowswap = ({ wallet, network }: TestingRunParams) => {
   });
 };
 
+// CowSwap requires live chain — cannot run on fork
 testingHelper({
   network: Network.POLYGON,
   testingRun: testCowswap,

package/src/test/dhedge.test.ts

@@ -1,32 +1,65 @@
 import { Dhedge } from "..";
 import { Network } from "../types";
+import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
+import {
+  testingHelper,
+  TestingRunParams,
+  beforeAfterReset
+} from "./utils/testingHelper";
 
-import { testingHelper, TestingRunParams } from "./utils/testingHelper";
-
-const testDhedge = ({ wallet, network }: TestingRunParams) => {
+const testDhedge = ({ wallet, network, provider }: TestingRunParams) => {
   let dhedge: Dhedge;
 
   jest.setTimeout(200000);
 
   describe(`dHEDGE on ${network}`, () => {
     beforeAll(async () => {
+      // Fund the test wallet with gas
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x10000000000000000"
+      ]);
       dhedge = new Dhedge(wallet, network);
     });
 
-    it("create a pool", async () => {
-      const pool = await dhedge.createPool("Test", "Test", "TEST", [
-        ["0x5d3a1ff2b6bab83b63cd9ad0787074081a52ef34", true],
-        ["0xB8CE59FC3717ada4C02eaDF9682A9e934F625ebb", false],
-        ["0x925a2A7214Ed92428B5b1B090F80b25700095e12", false]
-      ]);
-      console.log(pool.address);
+    beforeAfterReset({ beforeAll, afterAll, provider });
+
+    it("creates a pool with USDC and WETH", async () => {
+      const pool = await dhedge.createPool(
+        "Test Manager",
+        "Test Fund",
+        "TEST",
+        [
+          [CONTRACT_ADDRESS[network].USDC, true],
+          [CONTRACT_ADDRESS[network].WETH, false]
+        ]
+      );
+      expect(pool.address).toBeDefined();
       expect(pool.poolLogic.address).toBe(pool.address);
     });
+
+    it("loads an existing pool", async () => {
+      const pool = await dhedge.loadPool(TEST_POOL[network]);
+      expect(pool.address).toBe(TEST_POOL[network]);
+      expect(pool.poolLogic.address).toBe(TEST_POOL[network]);
+    });
+
+    it("validates a real pool address", async () => {
+      const isValid = await dhedge.validatePool(TEST_POOL[network]);
+      expect(isValid).toBe(true);
+    });
+
+    it("rejects an invalid pool address", async () => {
+      const isValid = await dhedge.validatePool(
+        "0x0000000000000000000000000000000000000001"
+      );
+      expect(isValid).toBe(false);
+    });
   });
 };
 
 testingHelper({
-  network: Network.PLASMA,
-  onFork: false,
+  network: Network.ARBITRUM,
+  onFork: true,
   testingRun: testDhedge
 });