@dhedge/v2-sdk 2.1.7 → 2.2.0

package/src/services/toros/swapData.ts

@@ -1,141 +1,55 @@
-import axios from "axios";
 import BigNumber from "bignumber.js";
-import { ethers } from "ethers";
-import { odosBaseUrl, SwapReferralInfo, SwapTokenInfo } from "../odos";
-import { networkChainIdMap, OdosSwapFeeRecipient } from "../../config";
-import OdosRouterV3Abi from "../../abi/odos/OdosRouterV3.json";
+import { Pool } from "../..";
+import { getKyberSwapTxData } from "../kyberSwap";
+import { getOneInchSwapTxData } from "../oneInch";
 
-export const SWAPPER_ADDERSS = "0x4F754e0F0924afD74980886b0B479Fa1D7C58D0D";
+export const SWAPPER_ADDRESS = "0x4F754e0F0924afD74980886b0B479Fa1D7C58D0D";
 
-export interface SwapParams {
-  srcAsset: string; // Source asset address
-  srcAmount: string; // Amount to swap (use string for big numbers)
-  dstAsset: string; // Destination asset address
-  chainId: number; // Chain ID
-  from: string; // Sender address
-  receiver: string; // Receiver address
-  slippage: number; // Slippage tolerance in basis points (100 = 1%)
-}
+// Order matters: routers are tried in sequence by init/completeWithdrawal.
+// KyberSwap is the primary route; 1inch is the fallback.
+export const ROUTER_KEYS = ["KYBER_SWAP_V2", "ONE_INCH"] as const;
 
-export const getSwapDataViaOdos = async ({
-  srcAsset,
-  srcAmount,
-  dstAsset,
-  chainId,
-  from,
-  slippage
-}: SwapParams): Promise<string> => {
-  if (!process.env.ODOS_API_KEY) {
-    throw new Error("ODOS_API_KEY is not set");
-  }
-  const ODOS_API_KEY = process.env.ODOS_API_KEY;
-  const network = (Object.keys(networkChainIdMap) as Array<
-    keyof typeof networkChainIdMap
-  >).find(key => networkChainIdMap[key] === chainId);
-  if (!network) {
-    throw new Error(`Unsupported chainId: ${chainId}`);
-  }
+export type RouterKey = typeof ROUTER_KEYS[number];
 
-  const referralFeeBips = 2; // 2 basis points = 0.02%
+export interface SwapParams {
+  srcAsset: string;
+  srcAmount: string;
+  dstAsset: string;
+  slippage: number; // in basis points (100 = 1%)
+}
 
-  const quoteParams = {
-    chainId: chainId,
-    inputTokens: [
-      {
-        tokenAddress: srcAsset,
-        amount: srcAmount
-      }
-    ],
-    outputTokens: [
-      {
-        tokenAddress: dstAsset,
-        proportion: 1
-      }
-    ],
-    slippageLimitPercent: new BigNumber(slippage).div(100).toString(), // Convert basis points to percentage
-    userAddr: from,
-    referralFee: referralFeeBips, // 0.02% fee
-    referralFeeRecipient: OdosSwapFeeRecipient[network],
-    compact: false
-  };
-  try {
-    const quoteResult = await axios.post(
-      `${odosBaseUrl}/quote/v3`,
-      quoteParams,
-      {
-        headers: {
-          "Content-Type": "application/json",
-          "x-api-key": ODOS_API_KEY
-        }
-      }
+export const getSwapData = async (
+  pool: Pool,
+  params: SwapParams,
+  routerKeyString: RouterKey
+): Promise<string> => {
+  const { srcAsset, srcAmount, dstAsset, slippage } = params;
+  // Convert basis points to percentage for aggregator APIs
+  const slippagePercent = new BigNumber(slippage).div(100).toNumber();
+
+  if (routerKeyString === "KYBER_SWAP_V2") {
+    const { swapTxData } = await getKyberSwapTxData(
+      pool,
+      srcAsset,
+      dstAsset,
+      srcAmount,
+      slippagePercent,
+      SWAPPER_ADDRESS,
+      SWAPPER_ADDRESS
     );
-
-    const assembleParams = {
-      pathId: quoteResult.data.pathId,
-      userAddr: from
-    };
-
-    const assembleResult = await axios.post(
-      `${odosBaseUrl}/assemble`,
-      assembleParams,
-      {
-        headers: {
-          "Content-Type": "application/json",
-          "x-api-key": ODOS_API_KEY
-        }
-      }
+    return swapTxData;
+  } else if (routerKeyString === "ONE_INCH") {
+    const { swapTxData } = await getOneInchSwapTxData(
+      pool,
+      srcAsset,
+      dstAsset,
+      srcAmount,
+      slippagePercent,
+      SWAPPER_ADDRESS,
+      SWAPPER_ADDRESS
     );
-
-    const txData = assembleResult.data.transaction.data;
-
-    // Decode the transaction data
-    const iface = new ethers.utils.Interface(OdosRouterV3Abi.abi);
-    const decodedData = iface.parseTransaction({ data: txData });
-
-    const tokenInfo = decodedData.args[0] as SwapTokenInfo;
-    const pathDefinition = decodedData.args[1] as string;
-    const executor = decodedData.args[2] as string;
-    const referralInfo = decodedData.args[3] as SwapReferralInfo;
-
-    if (
-      referralInfo.fee.lte(
-        ethers.BigNumber.from((referralFeeBips * 1e18) / 10000)
-      )
-    ) {
-      // Referral fee is already correct, return original txData
-      return txData;
-    }
-
-    const FEE_DENOM = new BigNumber(1e18);
-    const correctedFee = new BigNumber((referralFeeBips * 1e18) / 10000);
-    const factor = 1.1;
-    const correctedOutputQuote = new BigNumber(tokenInfo.outputQuote.toString())
-      .times(
-        FEE_DENOM.minus(correctedFee).div(
-          FEE_DENOM.minus(referralInfo.fee.toString())
-        )
-      )
-      .times(factor);
-
-    // example referralInfo.fee could be 0.0005 * 1e18 = 500000000000000, which is 0.05%
-    // Create corrected referral info
-    const correctedTxData = iface.encodeFunctionData(decodedData.name, [
-      {
-        ...tokenInfo,
-        outputQuote: correctedOutputQuote.toFixed(0)
-      },
-      pathDefinition,
-      executor,
-      {
-        code: referralInfo.code,
-        fee: correctedFee.toFixed(0), // align with referralFeeBips
-        feeRecipient: referralInfo.feeRecipient
-      }
-    ]);
-
-    return correctedTxData;
-  } catch (e) {
-    console.error("Error in Odos API request:", e);
-    throw new Error("Swap api request of Odos failed");
+    return swapTxData;
+  } else {
+    throw new Error(`Unsupported router: ${routerKeyString}`);
   }
 };

package/src/services/uniswap/V3Liquidity.ts

@@ -19,7 +19,7 @@ import {
 } from "../../config";
 import INonfungiblePositionManager from "../../abi/INonfungiblePositionManager.json";
 import IVeldodromePositionManager from "../../abi/IVelodromeNonfungiblePositionManager.json";
-import IRamsesPositionManager from "../../abi/IRamsesNonfungiblePositionManager.json";
+
 import IArrakisV1RouterStaking from "../../abi/IArrakisV1RouterStaking.json";
 import IPancakeMasterChef from "../../abi/IPancakeMasterChefV3.json";
 import { getDeadline } from "../../utils/deadline";
@@ -72,12 +72,7 @@ export function tryParseTick(
 }
 
 export async function getUniswapV3MintTxData(
-  dapp:
-    | Dapp.UNISWAPV3
-    | Dapp.VELODROMECL
-    | Dapp.AERODROMECL
-    | Dapp.RAMSESCL
-    | Dapp.PANCAKECL,
+  dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL | Dapp.AERODROMECL | Dapp.PANCAKECL,
 
   pool: Pool,
   assetA: string,
@@ -162,27 +157,13 @@ export async function getUniswapV3MintTxData(
     mintParams.push(0);
   }
 
-  if (dapp === Dapp.RAMSESCL) {
-    iNonfungiblePositionManager = new ethers.utils.Interface(
-      IRamsesPositionManager
-    );
-    mintParams.push(0);
-  }
-
   return iNonfungiblePositionManager.encodeFunctionData(Transaction.MINT, [
     mintParams
   ]);
-
-  return;
 }
 
 export async function getUniswapV3Liquidity(
-  dapp:
-    | Dapp.UNISWAPV3
-    | Dapp.VELODROMECL
-    | Dapp.AERODROMECL
-    | Dapp.RAMSESCL
-    | Dapp,
+  dapp: Dapp,
   tokenId: string,
   pool: Pool
 ): Promise<BigNumber> {
@@ -208,7 +189,6 @@ export async function getIncreaseLiquidityTxData(
     dapp === Dapp.UNISWAPV3 ||
     dapp === Dapp.VELODROMECL ||
     dapp === Dapp.AERODROMECL ||
-    dapp === Dapp.RAMSESCL ||
     dapp === Dapp.PANCAKECL
   ) {
     const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
@@ -245,7 +225,6 @@ export async function getDecreaseLiquidityTxData(
     dapp === Dapp.UNISWAPV3 ||
     dapp === Dapp.VELODROMECL ||
     dapp === Dapp.AERODROMECL ||
-    dapp === Dapp.RAMSESCL ||
     dapp === Dapp.PANCAKECL
   ) {
     const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);

package/src/services/velodrome/liquidity.ts

@@ -7,6 +7,7 @@ import { getDeadline } from "../../utils/deadline";
 import { nonfungiblePositionManagerAddress } from "../../config";
 import INonfungiblePositionManager from "../../abi/INonfungiblePositionManager.json";
 
+/** Encode Velodrome router calldata to add liquidity to a stable or volatile pair. */
 export async function getVelodromeAddLiquidityTxData(
   pool: Pool,
   assetA: string,
@@ -29,6 +30,7 @@ export async function getVelodromeAddLiquidityTxData(
   ]);
 }
 
+/** Encode Velodrome router calldata to remove liquidity from a stable or volatile pair. */
 export async function getVelodromeRemoveLiquidityTxData(
   pool: Pool,
   assetA: string,
@@ -49,6 +51,7 @@ export async function getVelodromeRemoveLiquidityTxData(
   ]);
 }
 
+/** Read the current owner of a Velodrome/Aerodrome/Pancake CL position NFT. */
 export async function getClOwner(
   pool: Pool,
   dapp: Dapp.VELODROMECL | Dapp.AERODROMECL | Dapp.PANCAKECL,

package/src/test/aave.test.ts

@@ -1,87 +1,116 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
+import BigNumber from "bignumber.js";
 import { Dhedge, Pool } from "..";
 import { routerAddress } from "../config";
 import { Dapp, Network } from "../types";
-import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import { CONTRACT_ADDRESS, MAX_AMOUNT } from "./constants";
+import {
+  TestingRunParams,
+  fixOracleAggregatorStaleness,
+  setChainlinkTimeout,
+  setUSDCAmount,
+  testingHelper
+} from "./utils/testingHelper";
 import { allowanceDelta, balanceDelta } from "./utils/token";
 
-import { wallet } from "./wallet";
+const testAave = ({ wallet, network, provider }: TestingRunParams) => {
+  const USDC = CONTRACT_ADDRESS[network].USDC;
+  const WBTC = CONTRACT_ADDRESS[network].WBTC;
 
-// const network = Network.OPTIMISM;
-// const network = Network.POLYGON;
-const network = Network.ARBITRUM;
-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(`[${network}] aave v3 tests`, () => {
+    beforeAll(async () => {
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x10000000000000000"
+      ]);
+      dhedge = new Dhedge(wallet, network);
 
-describe("pool", () => {
-  beforeAll(async () => {
-    dhedge = new Dhedge(wallet, network);
-    pool = await dhedge.loadPool(TEST_POOL[network]);
-  });
+      pool = await dhedge.createPool("Test Manager", "Aave Test", "AT", [
+        [USDC, true],
+        [WBTC, false],
+        [routerAddress[network][Dapp.AAVEV3]!, false]
+      ]);
 
-  it("approves unlimited USDC on Aave Lending pool", async () => {
-    await pool.approve(Dapp.AAVEV3, USDC, MAX_AMOUNT);
-    const usdcAllowanceDelta = await allowanceDelta(
-      pool.address,
-      USDC,
-      routerAddress[network]["aavev3"]!,
-      pool.signer
-    );
-    await expect(usdcAllowanceDelta.gt(0));
-  });
+      await setChainlinkTimeout({ pool, provider }, 86400 * 365);
+      await fixOracleAggregatorStaleness({ pool, provider });
 
-  it("approves unlimited WETH on Aave Lending pool", async () => {
-    await pool.approve(Dapp.AAVEV3, WETH, MAX_AMOUNT);
-    const wethAllowanceDelta = await allowanceDelta(
-      pool.address,
-      USDC,
-      routerAddress[network]["aavev3"]!,
-      pool.signer
-    );
-    await expect(wethAllowanceDelta.gt(0));
-  });
+      await setUSDCAmount({
+        amount: new BigNumber(1000).times(1e6).toFixed(0),
+        userAddress: pool.address,
+        network,
+        provider
+      });
+    });
 
-  it("lends 5 USDC into Aave lending pool", async () => {
-    await pool.lend(Dapp.AAVEV3, USDC, "5000000");
-    const usdcBalanceDelta = await balanceDelta(
-      pool.address,
-      USDC,
-      pool.signer
-    );
-    expect(usdcBalanceDelta.eq("-5000000"));
-  });
+    it("approves unlimited USDC on Aave Lending pool", async () => {
+      await pool.approve(Dapp.AAVEV3, USDC, MAX_AMOUNT);
+      const usdcAllowanceDelta = await allowanceDelta(
+        pool.address,
+        USDC,
+        routerAddress[network][Dapp.AAVEV3]!,
+        pool.signer
+      );
+      expect(usdcAllowanceDelta.gt(0)).toBe(true);
+    });
 
-  it("it borrows 0.001 WETH from Aave lending pool", async () => {
-    await pool.borrow(Dapp.AAVEV3, WETH, "1000000000000000");
-    const wethBalanceDelta = await balanceDelta(
-      pool.address,
-      WETH,
-      pool.signer
-    );
-    expect(wethBalanceDelta.eq("1000000000000000"));
-  });
+    it("approves unlimited WBTC on Aave Lending pool", async () => {
+      await pool.approve(Dapp.AAVEV3, WBTC, MAX_AMOUNT);
+      const wbtcAllowanceDelta = await allowanceDelta(
+        pool.address,
+        WBTC,
+        routerAddress[network][Dapp.AAVEV3]!,
+        pool.signer
+      );
+      expect(wbtcAllowanceDelta.gt(0)).toBe(true);
+    });
 
-  it("it repays 0.001 WETH to Aave lending pool", async () => {
-    await pool.repay(Dapp.AAVEV3, WETH, "1000000000000000");
-    const wethBalanceDelta = await balanceDelta(
-      pool.address,
-      WETH,
-      pool.signer
-    );
-    expect(wethBalanceDelta.eq("-1000000000000000"));
-  });
+    it("lends 500 USDC into Aave lending pool", async () => {
+      await pool.lend(Dapp.AAVEV3, USDC, "500000000");
+      const usdcBalanceDelta = await balanceDelta(
+        pool.address,
+        USDC,
+        pool.signer
+      );
+      expect(usdcBalanceDelta.eq("-500000000")).toBe(true);
+    });
+
+    it("borrows 0.0001 WBTC from Aave lending pool", async () => {
+      await pool.borrow(Dapp.AAVEV3, WBTC, "10000");
+      const wbtcBalanceDelta = await balanceDelta(
+        pool.address,
+        WBTC,
+        pool.signer
+      );
+      expect(wbtcBalanceDelta.eq("10000")).toBe(true);
+    });
 
-  it("it withdraws 4 USDC from Aave lending pool", async () => {
-    await pool.withdrawDeposit(Dapp.AAVEV3, USDC, "4000000");
-    const usdcBalanceDelta = await balanceDelta(
-      pool.address,
-      WETH,
-      pool.signer
-    );
-    expect(usdcBalanceDelta.eq("4000000"));
+    it("repays 0.0001 WBTC to Aave lending pool", async () => {
+      await pool.repay(Dapp.AAVEV3, WBTC, "10000");
+      const wbtcBalanceDelta = await balanceDelta(
+        pool.address,
+        WBTC,
+        pool.signer
+      );
+      expect(wbtcBalanceDelta.eq("-10000")).toBe(true);
+    });
+
+    it("withdraws 400 USDC from Aave lending pool", async () => {
+      await pool.withdrawDeposit(Dapp.AAVEV3, USDC, "400000000");
+      const usdcBalanceDelta = await balanceDelta(
+        pool.address,
+        USDC,
+        pool.signer
+      );
+      expect(usdcBalanceDelta.eq("400000000")).toBe(true);
+    });
   });
+};
+
+testingHelper({
+  network: Network.ARBITRUM,
+  testingRun: testAave
 });

package/src/test/aerodrome.test.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import BigNumber from "bignumber.js";
-import { Dhedge, Pool } from "..";
+import { Dhedge, ethers, Pool } from "..";
 import { routerAddress } from "../config";
 import { Dapp, Network } from "../types";
 import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
@@ -9,12 +9,13 @@ import {
   TestingRunParams,
   beforeAfterReset,
   setUSDCAmount,
+  setWETHAmount,
+  runWithImpersonateAccount,
   testingHelper
 } from "./utils/testingHelper";
 import { allowanceDelta, balanceDelta } from "./utils/token";
-import { getWalletData } from "./wallet";
 
-const testAerodrome = ({ network, provider }: TestingRunParams) => {
+const testAerodrome = ({ wallet, network, provider }: TestingRunParams) => {
   const WETH_USDC_Lp = "0xcDAC0d6c6C59727a65F871236188350531885C43";
   const WETH_USDC__Gauge = "0x519BBD1Dd8C6A94C46080E24f316c14Ee758C025";
 
@@ -28,38 +29,66 @@ const testAerodrome = ({ network, provider }: TestingRunParams) => {
 
   describe(`[${network}] aerodrome 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]);
+
+      // Fund pool with USDC and WETH
       await setUSDCAmount({
-        amount: new BigNumber(10).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
       });
-      await pool.approve(Dapp.ONEINCH, USDC, MAX_AMOUNT);
-      await pool.trade(Dapp.ONEINCH, USDC, WETH, (5 * 1e6).toString());
+
+      // 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 = [
+            [USDC, true],
+            [WETH, true],
+            [WETH_USDC_Lp, false],
+            [AERO, false]
+          ];
+          await pool.managerLogic.connect(signer).changeAssets(newAssets, []);
+        }
+      );
     });
     beforeAfterReset({ beforeAll, afterAll, provider });
 
-    it("approves unlimited USDC and swETH on for Aerodrome", async () => {
+    it("approves unlimited USDC and WETH for Aerodrome", async () => {
       await pool.approve(Dapp.AERODROME, USDC, MAX_AMOUNT);
       await pool.approve(Dapp.AERODROME, WETH, MAX_AMOUNT);
-      const UsdcAllowanceDelta = await allowanceDelta(
-        pool.address,
+      const allowanceAbi = [
+        "function allowance(address,address) view returns (uint256)"
+      ];
+      const usdcAllowance = await new ethers.Contract(
         USDC,
-        routerAddress[network].aerodrome!,
+        allowanceAbi,
         pool.signer
-      );
-      await expect(UsdcAllowanceDelta.gt(0));
+      ).allowance(pool.address, routerAddress[network].aerodrome!);
+      const wethAllowance = await new ethers.Contract(
+        WETH,
+        allowanceAbi,
+        pool.signer
+      ).allowance(pool.address, routerAddress[network].aerodrome!);
+      expect(usdcAllowance.gt(0)).toBe(true);
+      expect(wethAllowance.gt(0)).toBe(true);
     });
 
-    it("adds USDC and WETH to a Aerodrome volatile pool", async () => {
+    it("adds USDC and WETH to an Aerodrome volatile pool", async () => {
       const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
       const wethBalance = await pool.utils.getBalance(WETH, pool.address);
       await pool.addLiquidityV2(
@@ -76,7 +105,7 @@ const testAerodrome = ({ network, provider }: TestingRunParams) => {
         WETH_USDC_Lp,
         pool.signer
       );
-      expect(lpTokenDelta.gt(0));
+      expect(lpTokenDelta.gt(0)).toBe(true);
     });
 
     it("should stake WETH-USDC LP in a gauge", async () => {
@@ -88,7 +117,7 @@ const testAerodrome = ({ network, provider }: TestingRunParams) => {
         WETH_USDC__Gauge,
         pool.signer
       );
-      expect(gaugeBalance.gt(0));
+      expect(gaugeBalance.gt(0)).toBe(true);
     });
 
     it("should claim rewards from Gauge", async () => {
@@ -101,10 +130,10 @@ const testAerodrome = ({ network, provider }: TestingRunParams) => {
         AERO,
         pool.signer
       );
-      expect(aeroBalanceDelta.gt(0));
+      expect(aeroBalanceDelta.gt(0)).toBe(true);
     });
 
-    it("should unStakeWETH-USDC LP from a gauge", async () => {
+    it("should unstake WETH-USDC LP from a gauge", async () => {
       const gaugeBalance = await dhedge.utils.getBalance(
         WETH_USDC__Gauge,
         pool.address
@@ -115,7 +144,7 @@ const testAerodrome = ({ network, provider }: TestingRunParams) => {
         WETH_USDC_Lp,
         pool.signer
       );
-      expect(lpTokenDelta.gt(0));
+      expect(lpTokenDelta.gt(0)).toBe(true);
     });
 
     it("approves unlimited WETH-USDC LP for Aerodrome", async () => {
@@ -126,10 +155,10 @@ const testAerodrome = ({ network, provider }: TestingRunParams) => {
         routerAddress[network].aerodrome!,
         pool.signer
       );
-      expect(lpAllowanceDelta.gt(0));
+      expect(lpAllowanceDelta.gt(0)).toBe(true);
     });
 
-    it("should remove all liquidity from an existing pool ", async () => {
+    it("should remove all liquidity from an existing pool", async () => {
       const balance = await dhedge.utils.getBalance(WETH_USDC_Lp, pool.address);
       await pool.removeLiquidityV2(Dapp.AERODROME, WETH, USDC, balance, false);
       const usdcBalanceDelta = await balanceDelta(
@@ -142,8 +171,8 @@ const testAerodrome = ({ network, provider }: TestingRunParams) => {
         WETH,
         pool.signer
       );
-      expect(usdcBalanceDelta.gt(0));
-      expect(wethBalanceDelta.gt(0));
+      expect(usdcBalanceDelta.gt(0)).toBe(true);
+      expect(wethBalanceDelta.gt(0)).toBe(true);
     });
   });
 };