@dhedge/v2-sdk 2.1.7 → 2.2.0

package/src/test/torosLimitOrder.test.ts

@@ -1,79 +1,125 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 
-// import { ethers } from "ethers";
+import BigNumber from "bignumber.js";
+import { ethers } from "ethers";
 import { Dhedge, Pool } from "..";
-// import { limitOrderAddress } from "../config";
+import { limitOrderAddress, routerAddress } from "../config";
+
+import { Dapp, Network } from "../types";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import {
+  fixOracleAggregatorStaleness,
+  runWithImpersonateAccount,
+  setChainlinkTimeout,
+  setUSDCAmount,
+  testingHelper,
+  TestingRunParams
+} from "./utils/testingHelper";
+
+const TOROS_BTCBEAR2X = "0x3e63f81b3aa4e821392fccdabdd7d0c960c0235e";
+const BTC_PRICING_ASSET = "0x2f2a2543b76a4166549f7aab2e75bef0aefc5b0f"; // WBTC
+
+const testTorosLimitOrder = ({
+  wallet,
+  network,
+  provider
+}: TestingRunParams) => {
+  const ORDER_AMOUNT = ethers.utils.parseEther("0.001");
+  const STOP_LOSS = ethers.utils.parseEther("50000");
+  const TAKE_PROFIT = ethers.utils.parseEther("200000");
 
-import { Network } from "../types";
-// import { MAX_AMOUNT } from "./constants";
-import { testingHelper, TestingRunParams } from "./utils/testingHelper";
-
-// import { allowanceDelta } from "./utils/token";
-
-// cspell:ignore goldbull
-const TOROS_GOLDBULL2X = "0xc8e7e840ca82804c14061a27aaca1b97a5a592ab";
-// const GOLD_PRICING_ASSET = "0x7624cccCc59361D583F28BEC40D37e7771d2ef5D";
-
-const testTorosLimitOrder = ({ wallet, network }: TestingRunParams) => {
-  // const ORDER_AMOUNT = ethers.utils.parseEther("0.001");
-  // const STOP_LOSS = ethers.utils.parseEther("3000");
-  // const TAKE_PROFIT = ethers.utils.parseEther("6000");
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   let dhedge: Dhedge;
   let pool: Pool;
   jest.setTimeout(100000);
 
   describe(`toros limit order on ${network}`, () => {
     beforeAll(async () => {
+      // Top up gas
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x10000000000000000"
+      ]);
+      await provider.send("evm_mine", []);
+
       dhedge = new Dhedge(wallet, network);
-      pool = await dhedge.loadPool(
-        "0xdd3d575fae102a12aaa086d97c7a8814eff42ebc" // MCP test pool (with GOLDBULL2X)
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+
+      await setChainlinkTimeout({ pool, provider }, 86400 * 365);
+      await fixOracleAggregatorStaleness({ pool, provider });
+
+      // Impersonate pool manager to set trader and enable BTCBEAR2X asset
+      await runWithImpersonateAccount(
+        { provider, account: await pool.managerLogic.manager() },
+        async ({ signer }) => {
+          await pool.managerLogic.connect(signer).setTrader(wallet.address);
+          const USDC = CONTRACT_ADDRESS[network].USDC;
+          const easySwapperV2 = routerAddress[network][Dapp.TOROS]!;
+          await pool.managerLogic.connect(signer).changeAssets(
+            [
+              [TOROS_BTCBEAR2X, false],
+              [USDC, true],
+              [easySwapperV2, false]
+            ],
+            []
+          );
+        }
       );
+
+      // Fund pool with USDC and trade into BTCBEAR2X
+      const USDC = CONTRACT_ADDRESS[network].USDC;
+      const usdcAmount = new BigNumber(100).times(1e6).toFixed(0);
+      await setUSDCAmount({
+        amount: usdcAmount,
+        userAddress: pool.address,
+        network,
+        provider
+      });
+      await pool.approve(Dapp.TOROS, USDC, MAX_AMOUNT);
+      await pool.trade(Dapp.TOROS, USDC, TOROS_BTCBEAR2X, usdcAmount, 1.5);
     });
 
     it("approves Toros vault token for LimitOrderManager", async () => {
-      const tx = await pool.approveTorosLimitOrder(
-        TOROS_GOLDBULL2X,
-        MAX_AMOUNT
-      );
+      const tx = await pool.approveTorosLimitOrder(TOROS_BTCBEAR2X, MAX_AMOUNT);
       await tx.wait(1);
-      const delta = await allowanceDelta(
-        pool.address,
-        TOROS_GOLDBULL2X,
-        limitOrderAddress[network],
+      const iERC20 = new ethers.Contract(
+        TOROS_BTCBEAR2X,
+        ["function allowance(address,address) view returns (uint256)"],
         pool.signer
       );
-      expect(delta.gt(0)).toBe(true);
+      const allowance = await iERC20.allowance(
+        pool.address,
+        limitOrderAddress[network]
+      );
+      expect(allowance.gt(0)).toBe(true);
     });
 
     it("creates a limit order", async () => {
       const tx = await pool.createTorosLimitOrder(
-        TOROS_GOLDBULL2X,
+        TOROS_BTCBEAR2X,
         ORDER_AMOUNT,
         STOP_LOSS,
         TAKE_PROFIT,
-        GOLD_PRICING_ASSET
+        BTC_PRICING_ASSET
       );
       await tx.wait(1);
       const order = await pool.getTorosLimitOrder(
         pool.address,
-        TOROS_GOLDBULL2X
+        TOROS_BTCBEAR2X
       );
       expect(order).not.toBeNull();
       expect(order!.amount.eq(ORDER_AMOUNT)).toBe(true);
       expect(order!.stopLossPriceD18.eq(STOP_LOSS)).toBe(true);
       expect(order!.takeProfitPriceD18.eq(TAKE_PROFIT)).toBe(true);
-      expect(order!.pool.toLowerCase()).toBe(TOROS_GOLDBULL2X.toLowerCase());
+      expect(order!.pool.toLowerCase()).toBe(TOROS_BTCBEAR2X.toLowerCase());
       expect(order!.pricingAsset.toLowerCase()).toBe(
-        GOLD_PRICING_ASSET.toLowerCase()
+        BTC_PRICING_ASSET.toLowerCase()
       );
     });
 
     it("modifies a toros limit order", async () => {
       const order = await pool.getTorosLimitOrder(
         pool.address,
-        TOROS_GOLDBULL2X
+        TOROS_BTCBEAR2X
       );
       if (!order) throw new Error("No existing order found");
 
@@ -87,7 +133,7 @@ const testTorosLimitOrder = ({ wallet, network }: TestingRunParams) => {
         .toString();
 
       const tx = await pool.modifyTorosLimitOrder(
-        TOROS_GOLDBULL2X,
+        TOROS_BTCBEAR2X,
         order.amount,
         newStopLoss,
         newTakeProfit,
@@ -97,7 +143,7 @@ const testTorosLimitOrder = ({ wallet, network }: TestingRunParams) => {
 
       const modifiedOrder = await pool.getTorosLimitOrder(
         pool.address,
-        TOROS_GOLDBULL2X
+        TOROS_BTCBEAR2X
       );
       expect(modifiedOrder).not.toBeNull();
       expect(modifiedOrder!.stopLossPriceD18.toString()).toBe(newStopLoss);
@@ -107,16 +153,16 @@ const testTorosLimitOrder = ({ wallet, network }: TestingRunParams) => {
     it("deletes a toros limit order", async () => {
       const order = await pool.getTorosLimitOrder(
         pool.address,
-        TOROS_GOLDBULL2X
+        TOROS_BTCBEAR2X
       );
       if (!order) throw new Error("No existing order found");
 
-      const tx = await pool.deleteTorosLimitOrder(TOROS_GOLDBULL2X);
+      const tx = await pool.deleteTorosLimitOrder(TOROS_BTCBEAR2X);
       await tx.wait(1);
 
       const deletedOrder = await pool.getTorosLimitOrder(
         pool.address,
-        TOROS_GOLDBULL2X
+        TOROS_BTCBEAR2X
       );
       expect(deletedOrder).toBeNull();
     });
@@ -125,6 +171,5 @@ const testTorosLimitOrder = ({ wallet, network }: TestingRunParams) => {
 
 testingHelper({
   network: Network.ARBITRUM,
-  testingRun: testTorosLimitOrder,
-  onFork: false
+  testingRun: testTorosLimitOrder
 });

package/src/test/uniswap.test.ts

@@ -1,11 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Dhedge, ethers, Pool } from "..";
-import { routerAddress } from "../config";
-import { AssetEnabled, Dapp, Network } from "../types";
+import { nonfungiblePositionManagerAddress } from "../config";
+import { Dapp, Network } from "../types";
 import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
-import { allowanceDelta, balanceDelta } from "./utils/token";
 import {
   setUSDCAmount,
+  setWETHAmount,
+  runWithImpersonateAccount,
   testingHelper,
   TestingRunParams
 } from "./utils/testingHelper";
@@ -30,22 +31,37 @@ const testUniswapV3 = ({ wallet, network, provider }: TestingRunParams) => {
         "0x10000000000000000"
       ]);
       await provider.send("evm_mine", []);
+
+      // Fund pool with USDC and WETH
       await setUSDCAmount({
-        amount: new BigNumber(1000000).times(1e6).toFixed(0),
+        amount: new BigNumber(10000).times(1e6).toFixed(0),
+        userAddress: pool.address,
+        network,
+        provider
+      });
+      await setWETHAmount({
+        amount: new BigNumber(5).times(1e18).toFixed(0),
         userAddress: pool.address,
         network,
         provider
       });
 
-      const newAssets: AssetEnabled[] = [
-        { asset: CONTRACT_ADDRESS[network].USDC, isDeposit: true },
-        { asset: CONTRACT_ADDRESS[network].WETH, isDeposit: true },
-        {
-          asset: CONTRACT_ADDRESS[network].uniswapV3.nonfungiblePositionManager,
-          isDeposit: false
+      // Impersonate the 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 = [
+            [CONTRACT_ADDRESS[network].USDC, true],
+            [CONTRACT_ADDRESS[network].WETH, true],
+            [
+              CONTRACT_ADDRESS[network].uniswapV3.nonfungiblePositionManager,
+              false
+            ]
+          ];
+          await pool.managerLogic.connect(signer).changeAssets(newAssets, []);
         }
-      ];
-      await pool.changeAssets(newAssets);
+      );
 
       nonfungiblePositionManager = new ethers.Contract(
         CONTRACT_ADDRESS[network].uniswapV3.nonfungiblePositionManager,
@@ -54,60 +70,42 @@ const testUniswapV3 = ({ wallet, network, provider }: TestingRunParams) => {
       );
     });
 
-    it("approves unlimited USDC on for trading on UniswapV3", async () => {
-      await pool.approve(
-        Dapp.UNISWAPV3,
-        CONTRACT_ADDRESS[network].USDC,
-        ethers.constants.MaxUint256
-      );
-      const UsdcAllowanceDelta = await allowanceDelta(
-        pool.address,
-        CONTRACT_ADDRESS[network].USDC,
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        routerAddress[network].uniswapV3!,
-        pool.signer
-      );
-      expect(UsdcAllowanceDelta.gte(0));
-    });
+    // Note: tradeUniswapV3 (UniswapV3RouterGuard) is deprecated on all chains.
+    // Swap tests removed. Use Dapp.ONEINCH or Dapp.KYBERSWAP for trading instead.
 
-    it("should swap 5000 USDC into WETH on UniswapV3", async () => {
-      await pool.tradeUniswapV3(
-        CONTRACT_ADDRESS[network].USDC,
-        CONTRACT_ADDRESS[network].WETH,
-        new BigNumber(5000).times(1e6).toFixed(0),
-        500,
-        0.5
-      );
-
-      const wethAllowanceDelta = await balanceDelta(
-        pool.address,
-        CONTRACT_ADDRESS[network].WETH,
-        pool.signer
-      );
-      expect(wethAllowanceDelta.gt(0));
-    });
-
-    it("approves unlimited WETH on for UniswapV3 LP", async () => {
-      await pool.approveUniswapV3Liquidity(
+    it("approves unlimited USDC and WETH for UniswapV3 LP", async () => {
+      const usdcTx = await pool.approveUniswapV3Liquidity(
         CONTRACT_ADDRESS[network].USDC,
         ethers.constants.MaxInt256
       );
-      await pool.approveUniswapV3Liquidity(
+      await usdcTx.wait(1);
+      const wethTx = await pool.approveUniswapV3Liquidity(
         CONTRACT_ADDRESS[network].WETH,
         ethers.constants.MaxInt256
       );
-      const UsdcAllowanceDelta = await allowanceDelta(
-        pool.address,
+      await wethTx.wait(1);
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const positionManager = nonfungiblePositionManagerAddress[network][
+        Dapp.UNISWAPV3
+      ]!;
+      const allowanceAbi = [
+        "function allowance(address,address) view returns (uint256)"
+      ];
+      const usdcAllowance = await new ethers.Contract(
         CONTRACT_ADDRESS[network].USDC,
-        pool.address,
+        allowanceAbi,
         pool.signer
-      );
-
-      expect(UsdcAllowanceDelta).not.toBe(null);
+      ).allowance(pool.address, positionManager);
+      const wethAllowance = await new ethers.Contract(
+        CONTRACT_ADDRESS[network].WETH,
+        allowanceAbi,
+        pool.signer
+      ).allowance(pool.address, positionManager);
+      expect(usdcAllowance.gt(0)).toBe(true);
+      expect(wethAllowance.gt(0)).toBe(true);
     });
 
     it("adds WETH and USDC to a new V3 pool", async () => {
-      let result = null;
       const pool = await dhedge.loadPool(TEST_POOL[network]);
       const usdcBalance = await dhedge.utils.getBalance(
         CONTRACT_ADDRESS[network].USDC,
@@ -118,39 +116,33 @@ const testUniswapV3 = ({ wallet, network, provider }: TestingRunParams) => {
         pool.address
       );
 
-      try {
-        result = await pool.addLiquidityUniswapV3(
-          Dapp.UNISWAPV3,
-          CONTRACT_ADDRESS[network].WETH,
-          CONTRACT_ADDRESS[network].USDC,
-          wethBalance,
-          usdcBalance,
-          3500,
-          4000,
-          null,
-          null,
-          500
-          // options
-        );
-        await result.wait(1);
-
-        tokenId = await nonfungiblePositionManager.tokenOfOwnerByIndex(
-          pool.address,
-          0
-        );
-      } catch (e) {
-        console.log("e", e);
-      }
+      const result = await pool.addLiquidityUniswapV3(
+        Dapp.UNISWAPV3,
+        CONTRACT_ADDRESS[network].WETH,
+        CONTRACT_ADDRESS[network].USDC,
+        wethBalance,
+        usdcBalance,
+        3500,
+        4000,
+        null,
+        null,
+        500
+      );
+      await result.wait(1);
+
+      tokenId = await nonfungiblePositionManager.tokenOfOwnerByIndex(
+        pool.address,
+        0
+      );
       expect(result).not.toBe(null);
     });
 
-    it("should remove liquidity from an existing pool ", async () => {
+    it("should remove 50% liquidity from an existing pool", async () => {
       const result = await pool.decreaseLiquidity(
         Dapp.UNISWAPV3,
         tokenId.toString(),
-        50 // precent
+        50 // percent
       );
-      // console.log("result", result);
       expect(result).not.toBe(null);
     });
 
@@ -168,63 +160,20 @@ const testUniswapV3 = ({ wallet, network, provider }: TestingRunParams) => {
         Dapp.UNISWAPV3,
         tokenId.toString(),
         wethBalance,
-        usdcBalance // eth
+        usdcBalance
       );
-      // console.log("result", result);
       expect(result).not.toBe(null);
     });
 
-    it("should claim fees an existing pool", async () => {
+    it("should claim fees from an existing pool", async () => {
       const result = await pool.claimFees(Dapp.UNISWAPV3, tokenId.toString());
-      // console.log("result", result);
       expect(result).not.toBe(null);
     });
-
-    // it("approves unlimited USDC to swap on UniswapV3", async () => {
-    //   let result;
-    //   const pool = await dhedge.loadPool(TEST_POOL);
-    //   try {
-    //     result = await pool.approve(
-    //       Dapp.UNISWAPV3,
-    //       USDC,
-    //       ethers.constants.MaxInt256,
-    //       options
-    //     );
-    //     console.log(result);
-    //   } catch (e) {
-    //     console.log(e);
-    //   }
-    //   expect(result).not.toBe(null);
-    // });
-
-    // it("should swap USDC into WETH on UniswapV3 pool", async () => {
-    //   const pool = await dhedge.loadPool(TEST_POOL);
-    //   const result = await pool.tradeUniswapV3(
-    //     USDC,
-    //     WETH,
-    //     "1000000",
-    //     FeeAmount.LOW,
-    //     1,
-    //     options
-    //   );
-
-    //   console.log(result);
-    //   expect(result).not.toBe(null);
-    // });
   });
 };
 
 testingHelper({
-  network: Network.OPTIMISM,
-  testingRun: testUniswapV3
+  network: Network.ARBITRUM,
+  testingRun: testUniswapV3,
+  onFork: true
 });
-
-// testingHelper({
-//   network: Network.POLYGON,
-//   testingRun: testUniswapV3
-// });
-
-// testingHelper({
-//   network: Network.ARBITRUM,
-//   testingRun: testUniswapV3
-// });

package/src/test/utils/testingHelper.ts

@@ -9,6 +9,8 @@ import {
 } from "../constants";
 import { Pool } from "../../entities";
 import AssetHandler from "../../abi/AssetHandler.json";
+import PoolLogicAbi from "../../abi/PoolLogic.json";
+import PoolManagerLogicAbi from "../../abi/PoolManagerLogic.json";
 
 export type TestingRunParams = {
   network: Network;
@@ -146,6 +148,124 @@ export const runWithImpersonateAccount = async (
   await provider.send("hardhat_stopImpersonatingAccount", [account]);
 };
 
+// Fixes oracle staleness reverts on hardhat forks for ChainlinkPythPriceAggregator and PythPriceAggregator.
+// These aggregators have their own maxAge staleness checks separate from the AssetHandler's chainlinkTimeout.
+// This function dynamically finds all such aggregators for a pool's supported assets and overrides
+// their maxAge fields to max uint32 (0xffffffff, ~136 years).
+//
+// Slot layouts below are written in big-endian hex order (high-order bytes first), matching the 64-char
+// string returned by eth_getStorageAt. Within a packed slot, Solidity lays fields out from the low-order
+// end in declaration order — so the first declared field ends up on the right side of the hex string.
+//
+// ChainlinkPythPriceAggregator storage layout:
+//   slot 0: asset (address)
+//   slot 1: oracleData.onchainOracle = [8 bytes padding][4 bytes maxAge][20 bytes oracleContract]
+//           → maxAge at hex offset 16
+//   slot 2: oracleData.offchainOracle.priceId (bytes32)
+//   slot 3: oracleData.offchainOracle = [24 bytes padding][4 bytes maxAge][4 bytes minConfidenceRatio]
+//           → maxAge at hex offset 48
+//
+// PythPriceAggregator storage layout:
+//   slot 0: asset (address)
+//   slot 1: oracleData.priceId (bytes32)
+//   slot 2: oracleData = [24 bytes padding][4 bytes maxAge][4 bytes minConfidenceRatio]
+//           → maxAge at hex offset 48
+const MAX_UINT32_HEX = "ffffffff";
+
+const overrideMaxAgeInSlot = async (
+  provider: ethers.providers.JsonRpcProvider,
+  contractAddress: string,
+  slotIndex: string,
+  maxAgeHexOffset: number // character offset of maxAge within the 64-char hex string
+): Promise<void> => {
+  const slot: string = await provider.send("eth_getStorageAt", [
+    contractAddress,
+    slotIndex,
+    "latest"
+  ]);
+  const hex = slot.slice(2); // remove 0x
+  const newHex =
+    hex.slice(0, maxAgeHexOffset) +
+    MAX_UINT32_HEX +
+    hex.slice(maxAgeHexOffset + 8);
+  await provider.send("hardhat_setStorageAt", [
+    contractAddress,
+    slotIndex,
+    "0x" + newHex
+  ]);
+};
+
+export const fixOracleAggregatorStaleness = async ({
+  pool,
+  provider
+}: {
+  pool: Pool;
+  provider: ethers.providers.JsonRpcProvider;
+}): Promise<void> => {
+  const assetHandlerAddress = await pool.factory.callStatic.getAssetHandler();
+  const assetHandlerContract = new Contract(
+    assetHandlerAddress,
+    AssetHandler.abi,
+    provider
+  );
+
+  // Resolve managerLogic from poolLogic to support both isDhedge=true and isDhedge=false pools
+  const poolLogic = new Contract(pool.address, PoolLogicAbi.abi, provider);
+  const managerLogicAddress: string = await poolLogic.poolManagerLogic();
+  const managerLogic = new Contract(
+    managerLogicAddress,
+    PoolManagerLogicAbi.abi,
+    provider
+  );
+  const supportedAssets: {
+    asset: string;
+  }[] = await managerLogic.getSupportedAssets();
+
+  // ABI fragments to detect aggregator type
+  const chainlinkPythAbi = [
+    "function oracleData() view returns (address oracleContract, uint32 maxAge)"
+  ];
+  const pythAbi = [
+    "function oracleData() view returns (bytes32 priceId, uint32 maxAge, uint32 minConfidenceRatio)"
+  ];
+
+  for (const { asset } of supportedAssets) {
+    try {
+      const aggregatorAddress: string = await assetHandlerContract.priceAggregators(
+        asset
+      );
+      if (aggregatorAddress === ethers.constants.AddressZero) continue;
+
+      // Try ChainlinkPythPriceAggregator first (has onchainOracle + offchainOracle)
+      const agg = new Contract(aggregatorAddress, chainlinkPythAbi, provider);
+      try {
+        await agg.oracleData();
+        // ChainlinkPythPriceAggregator detected.
+        // Slot 1 layout: [8 bytes padding][4 bytes maxAge][20 bytes oracleContract] → maxAge at offset 16
+        await overrideMaxAgeInSlot(provider, aggregatorAddress, "0x1", 16);
+        // Slot 3 layout: [24 bytes padding][4 bytes maxAge][4 bytes minConfidenceRatio] → maxAge at offset 48
+        await overrideMaxAgeInSlot(provider, aggregatorAddress, "0x3", 48);
+        continue;
+      } catch {
+        // Not a ChainlinkPythPriceAggregator
+      }
+
+      // Try PythPriceAggregator (has only offchainOracle)
+      const pythAgg = new Contract(aggregatorAddress, pythAbi, provider);
+      try {
+        await pythAgg.oracleData();
+        // PythPriceAggregator detected.
+        // Slot 2 layout: [24 bytes padding][4 bytes maxAge][4 bytes minConfidenceRatio] → maxAge at offset 48
+        await overrideMaxAgeInSlot(provider, aggregatorAddress, "0x2", 48);
+      } catch {
+        // Not a PythPriceAggregator either — skip
+      }
+    } catch {
+      // No aggregator set for this asset — skip
+    }
+  }
+};
+
 export const setChainlinkTimeout = async (
   {
     pool,