@dhedge/v2-sdk 2.1.8 → 2.2.0

package/src/test/velodromeV2.test.ts

@@ -1,114 +1,172 @@
 /* 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 { routerAddress } from "../config";
 import { Dapp, Network } from "../types";
 import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
-import { allowanceDelta, balanceDelta } from "./utils/token";
+import {
+  TestingRunParams,
+  fixOracleAggregatorStaleness,
+  runWithImpersonateAccount,
+  setChainlinkTimeout,
+  setUSDCAmount,
+  setWETHAmount,
+  testingHelper
+} from "./utils/testingHelper";
+import { balanceDelta } from "./utils/token";
 
-import { wallet } from "./wallet";
+// Velodrome V2 VARIABLE USDC/WETH pool (native USDC)
+const USDC_WETH_Lp = "0xF4F2657AE744354bAcA871E56775e5083F7276Ab";
+const USDC_WETH_Gauge = "0xBde5E1592AEb3D8396b90c4B4ba274E5Ae31e552";
 
-const USDC_SUSD_Lp = "0x6d5BA400640226e24b50214d2bBb3D4Db8e6e15a";
-const USDC_SUSD_Gauge = "0x55a272304456355242f6690863b5c8d5c512ff71";
-const network = Network.OPTIMISM;
-const SUSD = CONTRACT_ADDRESS[network].SUSD;
-const USDC = CONTRACT_ADDRESS[network].USDC;
+const testVelodromeV2 = ({ wallet, network, provider }: TestingRunParams) => {
+  const USDC = CONTRACT_ADDRESS[network].USDC;
+  const WETH = CONTRACT_ADDRESS[network].WETH;
 
-let dhedge: Dhedge;
-let pool: Pool;
-jest.setTimeout(100000);
+  let dhedge: Dhedge;
+  let pool: Pool;
+  jest.setTimeout(100000);
 
-describe("pool", () => {
-  beforeAll(async () => {
-    dhedge = new Dhedge(wallet, network);
-    pool = await dhedge.loadPool(TEST_POOL[network]);
-  });
+  describe(`pool on ${network}`, () => {
+    beforeAll(async () => {
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x10000000000000000"
+      ]);
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
 
-  it("approves unlimited sUSD and USDC on for Velodrome", async () => {
-    await pool.approve(Dapp.VELODROMEV2, SUSD, MAX_AMOUNT);
-    await pool.approve(Dapp.VELODROMEV2, USDC, MAX_AMOUNT);
-    const UsdcAllowanceDelta = await allowanceDelta(
-      pool.address,
-      USDC,
-      routerAddress[network].velodromeV2!,
-      pool.signer
-    );
-    await expect(UsdcAllowanceDelta.gt(0));
-  });
+      await setChainlinkTimeout({ pool, provider }, 86400 * 365);
+      await fixOracleAggregatorStaleness({ pool, provider });
 
-  it("adds USDC and SUSD to a Velodrome stable pool", async () => {
-    await pool.addLiquidityVelodromeV2(
-      USDC,
-      SUSD,
-      (5 * 1e6).toString(),
-      (5 * 1e18).toString(),
-      true
-    );
-
-    const lpTokenDelta = await balanceDelta(
-      pool.address,
-      USDC_SUSD_Lp,
-      pool.signer
-    );
-    expect(lpTokenDelta.gt(0));
-  });
+      await runWithImpersonateAccount(
+        { provider, account: await pool.managerLogic.manager() },
+        async ({ signer }) => {
+          await pool.managerLogic.connect(signer).setTrader(wallet.address);
+          await pool.managerLogic.connect(signer).changeAssets(
+            [
+              [USDC, true],
+              [WETH, true],
+              [USDC_WETH_Lp, false]
+            ],
+            []
+          );
+        }
+      );
 
-  it("should stake USDC-sUSD LP in a gauge", async () => {
-    const balance = await dhedge.utils.getBalance(USDC_SUSD_Lp, pool.address);
-    await pool.approveSpender(USDC_SUSD_Gauge, USDC_SUSD_Lp, MAX_AMOUNT);
-    await pool.stakeInGauge(Dapp.VELODROMEV2, USDC_SUSD_Gauge, balance);
-    const gaugeBalance = await balanceDelta(
-      pool.address,
-      USDC_SUSD_Lp,
-      pool.signer
-    );
-    expect(gaugeBalance.gt(0));
-  });
+      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
+      });
+    });
 
-  it("should claim rewards from Gauge", async () => {
-    const tx = await pool.claimFees(Dapp.VELODROMEV2, USDC_SUSD_Gauge);
-    expect(tx).not.toBe(null);
-  });
+    it("approves unlimited WETH and USDC on for Velodrome", async () => {
+      await pool.approve(Dapp.VELODROMEV2, WETH, MAX_AMOUNT);
+      await pool.approve(Dapp.VELODROMEV2, USDC, MAX_AMOUNT);
+      const iERC20 = new ethers.Contract(
+        USDC,
+        ["function allowance(address,address) view returns (uint256)"],
+        pool.signer
+      );
+      const usdcAllowance = await iERC20.allowance(
+        pool.address,
+        routerAddress[network].velodromeV2!
+      );
+      expect(usdcAllowance.gt(0)).toBe(true);
+    });
 
-  it("should unStake USDC-sUSD LP from a gauge", async () => {
-    const gaugeBalance = await dhedge.utils.getBalance(
-      USDC_SUSD_Gauge,
-      pool.address
-    );
-    await pool.unstakeFromGauge(USDC_SUSD_Gauge, gaugeBalance);
-    const lpTokenDelta = await balanceDelta(
-      pool.address,
-      USDC_SUSD_Lp,
-      pool.signer
-    );
-    expect(lpTokenDelta.gt(0));
-  });
+    it("adds USDC and WETH to a Velodrome volatile pool", async () => {
+      await pool.addLiquidityVelodromeV2(
+        USDC,
+        WETH,
+        new BigNumber(100).times(1e6).toFixed(0),
+        new BigNumber(0.05).times(1e18).toFixed(0),
+        false
+      );
 
-  it("approves unlimited wETH/stwETH LP for Velodrome", async () => {
-    await pool.approve(Dapp.VELODROMEV2, USDC_SUSD_Lp, MAX_AMOUNT);
-    const lpAllowanceDelta = await allowanceDelta(
-      pool.address,
-      USDC_SUSD_Lp,
-      routerAddress[network].velodrome!,
-      pool.signer
-    );
-    expect(lpAllowanceDelta.gt(0));
-  });
+      const lpTokenDelta = await balanceDelta(
+        pool.address,
+        USDC_WETH_Lp,
+        pool.signer
+      );
+      expect(lpTokenDelta.gt(0)).toBe(true);
+    });
+
+    it("should stake USDC-WETH LP in a gauge", async () => {
+      const balance = await dhedge.utils.getBalance(USDC_WETH_Lp, pool.address);
+      await pool.approveSpender(USDC_WETH_Gauge, USDC_WETH_Lp, MAX_AMOUNT);
+      await pool.stakeInGauge(Dapp.VELODROMEV2, USDC_WETH_Gauge, balance);
+      const gaugeBalance = await balanceDelta(
+        pool.address,
+        USDC_WETH_Lp,
+        pool.signer
+      );
+      expect(gaugeBalance.lt(0)).toBe(true);
+    });
+
+    it("should claim rewards from Gauge", async () => {
+      const tx = await pool.claimFees(Dapp.VELODROMEV2, USDC_WETH_Gauge);
+      expect(tx).not.toBe(null);
+    });
 
-  it("should remove all liquidity from an existing pool ", async () => {
-    const balance = await dhedge.utils.getBalance(USDC_SUSD_Lp, pool.address);
-    await pool.removeLiquidityVelodromeV2(USDC, SUSD, balance, true);
-    const usdcBalanceDelta = await balanceDelta(
-      pool.address,
-      USDC,
-      pool.signer
-    );
-    const susdBalanceDelta = await balanceDelta(
-      pool.address,
-      SUSD,
-      pool.signer
-    );
-    expect(usdcBalanceDelta.gt(0));
-    expect(susdBalanceDelta.gt(0));
+    it("should unStake USDC-WETH LP from a gauge", async () => {
+      const gaugeBalance = await dhedge.utils.getBalance(
+        USDC_WETH_Gauge,
+        pool.address
+      );
+      await pool.unstakeFromGauge(USDC_WETH_Gauge, gaugeBalance);
+      const lpTokenDelta = await balanceDelta(
+        pool.address,
+        USDC_WETH_Lp,
+        pool.signer
+      );
+      expect(lpTokenDelta.gt(0)).toBe(true);
+    });
+
+    it("approves unlimited USDC-WETH LP for Velodrome", async () => {
+      await pool.approve(Dapp.VELODROMEV2, USDC_WETH_Lp, MAX_AMOUNT);
+      const iERC20 = new ethers.Contract(
+        USDC_WETH_Lp,
+        ["function allowance(address,address) view returns (uint256)"],
+        pool.signer
+      );
+      const lpAllowance = await iERC20.allowance(
+        pool.address,
+        routerAddress[network].velodromeV2!
+      );
+      expect(lpAllowance.gt(0)).toBe(true);
+    });
+
+    it("should remove all liquidity from an existing pool ", async () => {
+      const balance = await dhedge.utils.getBalance(USDC_WETH_Lp, pool.address);
+      await pool.removeLiquidityVelodromeV2(USDC, WETH, balance, false);
+      const usdcBalanceDelta = await balanceDelta(
+        pool.address,
+        USDC,
+        pool.signer
+      );
+      const wethBalanceDelta = await balanceDelta(
+        pool.address,
+        WETH,
+        pool.signer
+      );
+      expect(usdcBalanceDelta.gt(0)).toBe(true);
+      expect(wethBalanceDelta.gt(0)).toBe(true);
+    });
   });
+};
+
+testingHelper({
+  network: Network.OPTIMISM,
+  testingRun: testVelodromeV2
 });

package/src/types.ts

@@ -1,6 +1,8 @@
 import { Deployment } from "@lyrafinance/lyra-js";
 import { BigNumber } from "ethers";
 
+/** Networks supported by the SDK. The string value matches keys in `routerAddress`,
+ * `nonfungiblePositionManagerAddress`, etc. in `config.ts`. */
 export enum Network {
   POLYGON = "polygon",
   OPTIMISM = "optimism",
@@ -11,6 +13,8 @@ export enum Network {
   HYPERLIQUID = "hyperliquid"
 }
 
+/** Identifies a target protocol/integration for `pool.trade`, `pool.approve`, etc.
+ * Each entry maps to address registries (router, factory, gauge) in `config.ts`. */
 export enum Dapp {
   SUSHISWAP = "sushiswap",
   AAVE = "aave",
@@ -18,7 +22,6 @@ export enum Dapp {
   QUICKSWAP = "quickswap",
   BALANCER = "balancer",
   UNISWAPV3 = "uniswapV3",
-  SYNTHETIX = "synthetix",
   AAVEV3 = "aavev3",
   ARRAKIS = "arrakis",
   TOROS = "toros",
@@ -26,10 +29,8 @@ export enum Dapp {
   VELODROMEV2 = "velodromeV2",
   VELODROMECL = "velodromeCL",
   LYRA = "lyra",
-  RAMSES = "ramses",
   AERODROME = "aerodrome",
   AERODROMECL = "aerodromeCL",
-  RAMSESCL = "ramsesCL",
   PANCAKECL = "pancakeCL",
   COMPOUNDV3 = "compoundV3",
   ODOS = "odos",
@@ -39,6 +40,8 @@ export enum Dapp {
   COWSWAP = "cowswap"
 }
 
+/** Function-name strings used when encoding ABI calls — keep in sync with the
+ * matching ABI files in `src/abi/`. */
 export enum Transaction {
   SWAP = "swapExactTokensForTokens",
   ADD_LIQUIDITY = "addLiquidity",
@@ -56,7 +59,6 @@ export enum Transaction {
   WITHDRAW = "withdraw",
   MINT = "mint",
   BURN = "burn",
-  SWAP_SYNTHS = "exchangeWithTracking",
   ADD_LIQUIDITY_STAKE = "addLiquidityAndStake",
   REMOVE_LIQUIDITY_UNSTAKE = "removeLiquidityAndUnstake"
 }
@@ -69,13 +71,16 @@ export type AddressDappMap = {
 
 export type AddressDappNetworkMap = Readonly<Record<Network, AddressDappMap>>;
 
+/** Tuple form `[asset, isDeposit]` accepted by the factory's `createFund`. */
 export type SupportedAsset = [string, boolean];
 
+/** Object form of a supported asset entry; preferred over `SupportedAsset` in SDK methods. */
 export type AssetEnabled = {
   asset: string;
   isDeposit: boolean;
 };
 
+/** A pool's holding of one asset returned by `pool.getComposition()`. */
 export type FundComposition = {
   asset: string;
   isDeposit: boolean;
@@ -107,14 +112,24 @@ export type LyraPosition = {
   state: number;
 };
 
+/**
+ * Options that control how SDK methods dispatch a transaction:
+ *  - `estimateGas`: simulate and return gas + minAmountOut without sending.
+ *  - `onlyGetTxData`: return the encoded calldata without sending or simulating.
+ *  - `useTraderAddressAsFrom`: send via the EOA wallet instead of the pool's
+ *    `execTransaction` (used when the SDK is acting as a non-dHEDGE caller).
+ *  - `boolean` shorthand: `true` is equivalent to `{ estimateGas: true }` (kept
+ *    for backward compatibility).
+ */
 export type SDKOptions =
   | {
       estimateGas: boolean;
       onlyGetTxData?: boolean;
       useTraderAddressAsFrom?: boolean;
     }
-  | boolean; // shorthand for { estimateGas: true/false }; for backward compatibility
+  | boolean;
 
+/** Parameters for a Toros limit order (stop-loss / take-profit) on a vault token. */
 export type LimitOrderInfo = {
   amount: BigNumber;
   stopLossPriceD18: BigNumber;

package/src/utils/contract.ts

@@ -6,6 +6,7 @@ import { multiCallAddress } from "../config";
 import { ethers, Network, Pool, SDKOptions } from "..";
 import { Signer } from "ethers";
 
+/** Single contract read: `call = [address, methodName, params?]`. */
 export async function call(
   provider: ethers.Signer,
   abi: any[],
@@ -21,6 +22,11 @@ export async function call(
   }
 }
 
+/**
+ * Batch multiple contract reads through Multicall's `tryAggregate`.
+ * Each call entry is `[address, methodName, params]`. When `requireSuccess` is false,
+ * failing calls return `null` instead of reverting the whole batch.
+ */
 export async function multicall<T>(
   network: Network,
   provider: ethers.Signer,
@@ -59,6 +65,11 @@ export async function multicall<T>(
   }
 }
 
+/**
+ * Fluent helper for building a multicall and dispatching results into a typed object.
+ * Use `.call(path, address, fn, params)` repeatedly, then `.execute()` returns the
+ * populated object with results placed at the given lodash paths.
+ */
 export class Multicaller {
   public network: Network;
   public provider: ethers.Signer;
@@ -135,6 +146,15 @@ export const isSdkOptionsBoolean = (
   return typeof sdkOptions === "boolean";
 };
 
+/**
+ * Central executor for SDK transactions. Routes a (`to`, `data`, `txOptions`) tuple
+ * through one of four paths depending on `pool.isDhedge` and `sdkOptions`:
+ *   - dHEDGE pool:    `pool.poolLogic.execTransaction(...)` (or its gas estimate)
+ *   - non-dHEDGE/EOA: `pool.signer.sendTransaction(...)` (or its gas estimate)
+ * Honours `sdkOptions.onlyGetTxData` (returns the encoded tx without sending),
+ * `estimateGas` (returns gas + minAmountOut without sending), and
+ * `useTraderAddressAsFrom` (forces the EOA path even for dHEDGE pools).
+ */
 export const getPoolTxOrGasEstimate = async (
   pool: Pool,
   args: any[],

package/dist/services/futures/constants.d.ts

@@ -1 +0,0 @@
-export declare const FUTURES_TRACKING = "DHEDGE";

package/dist/services/futures/index.d.ts

@@ -1,2 +0,0 @@
-export { getFuturesChangeMarginTxData } from "./margin";
-export { getFuturesChangePositionTxData } from "./trade";

package/dist/services/futures/margin.d.ts

@@ -1,2 +0,0 @@
-import { ethers } from "../..";
-export declare function getFuturesChangeMarginTxData(amount: ethers.BigNumber | string): string;

package/dist/services/futures/trade.d.ts

@@ -1,3 +0,0 @@
-import { Pool, ethers } from "../..";
-export declare function getFuturesChangePositionTxData(amount: ethers.BigNumber | string, market: string, pool: Pool): Promise<string>;
-export declare function getFuturesCancelOrderTxData(pool: Pool): Promise<string>;

package/dist/services/ramses/vesting.d.ts

@@ -1,4 +0,0 @@
-import { BigNumber } from "ethers";
-export declare function getCreateVestTxData(amount: BigNumber | string): string;
-export declare function getExitVestTxData(vestId: number): string;
-export declare function getRewardsTxDta(tokenId: string, rewards: string[]): string;

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

@@ -1,3 +0,0 @@
-import { ethers } from "ethers";
-import { Pool } from "../..";
-export declare function getUniswapV3SwapTxData(pool: Pool, assetA: string, assetB: string, amountIn: string | ethers.BigNumber, slippage: number, feeAmount: number): Promise<any>;

package/dist/test/utils/futures.d.ts

@@ -1,2 +0,0 @@
-import { Pool } from "../..";
-export declare function getDelayedOrders(market: string, pool: Pool): Promise<any>;