@dhedge/v2-sdk 1.9.7 → 1.9.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dhedge/v2-sdk",
-  "version": "1.9.7",
+  "version": "1.9.8",
   "license": "MIT",
   "description": "🛠 An SDK for building applications on top of dHEDGE V2",
   "main": "dist/index.js",

package/src/config.ts

@@ -54,7 +54,9 @@ export const routerAddress: AddressDappNetworkMap = {
   },
   [Network.BASE]: {
     [Dapp.ONEINCH]: "0x1111111254EEB25477B68fb85Ed929f73A960582",
-    [Dapp.ZEROEX]: "0xdef1c0ded9bec7f1a1670819833240f027b25eff"
+    [Dapp.ZEROEX]: "0xdef1c0ded9bec7f1a1670819833240f027b25eff",
+    [Dapp.AERODROME]: "0xcF77a3Ba9A5CA399B7c97c74d54e5b1Beb874E43",
+    [Dapp.AAVEV3]: "0xA238Dd80C259a72e81d7e4664a9801593F98d1c5"
   }
 };
 

package/src/entities/pool.ts

@@ -531,6 +531,7 @@ export class Pool {
         stakeTxData = getVelodromeStakeTxData(amount, false);
         break;
       case Dapp.VELODROMEV2:
+      case Dapp.AERODROME:
         stakeTxData = getVelodromeStakeTxData(amount, true);
         break;
       default:
@@ -1153,6 +1154,7 @@ export class Pool {
         txData = getVelodromeClaimTxData(this, tokenId, false);
         break;
       case Dapp.VELODROMEV2:
+      case Dapp.AERODROME:
         contractAddress = tokenId;
         txData = getVelodromeClaimTxData(this, tokenId, true);
         break;
@@ -1356,7 +1358,7 @@ export class Pool {
 
   /**
    * Add liquidity to Velodrome V2 or Ramses pool
-   * @param {Dapp} dapp VelodromeV2 or Ramses
+   * @param {Dapp} dapp VelodromeV2, Ramses or Aerodrome
    * @param {string} assetA First asset
    * @param {string} assetB Second asset
    * @param {BigNumber | string} amountA Amount first asset
@@ -1367,7 +1369,7 @@ export class Pool {
    * @returns {Promise<any>} Transaction
    */
   async addLiquidityV2(
-    dapp: Dapp.VELODROMEV2 | Dapp.RAMSES,
+    dapp: Dapp.VELODROMEV2 | Dapp.RAMSES | Dapp.AERODROME,
     assetA: string,
     assetB: string,
     amountA: BigNumber | string,
@@ -1397,7 +1399,7 @@ export class Pool {
 
   /**
    * Remove liquidity from Velodrome V2 or Ramses pool
-   * @param {Dapp} dapp VelodromeV2 or Ramses
+   * @param {Dapp} dapp VelodromeV2, Ramses or Aerodrome
    * @param {string} assetA First asset
    * @param {string} assetB Second asset
    * @param {BigNumber | string} amount Amount of LP tokens
@@ -1407,7 +1409,7 @@ export class Pool {
    * @returns {Promise<any>} Transaction
    */
   async removeLiquidityV2(
-    dapp: Dapp.VELODROMEV2 | Dapp.RAMSES,
+    dapp: Dapp.VELODROMEV2 | Dapp.RAMSES | Dapp.AERODROME,
     assetA: string,
     assetB: string,
     amount: BigNumber | string,

package/src/test/aerodrome.test.ts

@@ -0,0 +1,154 @@
+/* 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 { routerAddress } from "../config";
+import { Dapp, Network } from "../types";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import {
+  TestingRunParams,
+  beforeAfterReset,
+  setUSDCAmount,
+  testingHelper
+} from "./utils/testingHelper";
+import { allowanceDelta, balanceDelta } from "./utils/token";
+import { getWalletData } from "./wallet";
+
+const testAerodrome = ({ network, provider }: TestingRunParams) => {
+  const WETH_USDC_Lp = "0xcDAC0d6c6C59727a65F871236188350531885C43";
+  const WETH_USDC__Gauge = "0x519BBD1Dd8C6A94C46080E24f316c14Ee758C025";
+
+  const USDC = CONTRACT_ADDRESS[network].USDC;
+  const WETH = CONTRACT_ADDRESS[network].WETH;
+  const AERO = "0x940181a94A35A4569E4529A3CDfB74e38FD98631";
+
+  let dhedge: Dhedge;
+  let pool: Pool;
+  jest.setTimeout(100000);
+
+  describe(`[${network}] aerodrome 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 setUSDCAmount({
+        amount: new BigNumber(10).times(1e6).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());
+    });
+    beforeAfterReset({ beforeAll, afterAll, provider });
+
+    it("approves unlimited USDC and swETH on 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,
+        USDC,
+        routerAddress[network].aerodrome!,
+        pool.signer
+      );
+      await expect(UsdcAllowanceDelta.gt(0));
+    });
+
+    it("adds USDC and WETH to a 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(
+        Dapp.AERODROME,
+        WETH,
+        USDC,
+        wethBalance,
+        usdcBalance,
+        false
+      );
+
+      const lpTokenDelta = await balanceDelta(
+        pool.address,
+        WETH_USDC_Lp,
+        pool.signer
+      );
+      expect(lpTokenDelta.gt(0));
+    });
+
+    it("should stake WETH-USDC LP in a gauge", async () => {
+      const balance = await dhedge.utils.getBalance(WETH_USDC_Lp, pool.address);
+      await pool.approveSpender(WETH_USDC__Gauge, WETH_USDC_Lp, MAX_AMOUNT);
+      await pool.stakeInGauge(Dapp.AERODROME, WETH_USDC__Gauge, balance);
+      const gaugeBalance = await balanceDelta(
+        pool.address,
+        WETH_USDC__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.AERODROME, WETH_USDC__Gauge);
+      expect(claimTx).not.toBe(null);
+      const aeroBalanceDelta = await balanceDelta(
+        pool.address,
+        AERO,
+        pool.signer
+      );
+      expect(aeroBalanceDelta.gt(0));
+    });
+
+    it("should unStakeWETH-USDC LP from a gauge", async () => {
+      const gaugeBalance = await dhedge.utils.getBalance(
+        WETH_USDC__Gauge,
+        pool.address
+      );
+      await pool.unstakeFromGauge(WETH_USDC__Gauge, gaugeBalance);
+      const lpTokenDelta = await balanceDelta(
+        pool.address,
+        WETH_USDC_Lp,
+        pool.signer
+      );
+      expect(lpTokenDelta.gt(0));
+    });
+
+    it("approves unlimited WETH-USDC LP for Aerodrome", async () => {
+      await pool.approve(Dapp.AERODROME, WETH_USDC_Lp, MAX_AMOUNT);
+      const lpAllowanceDelta = await allowanceDelta(
+        pool.address,
+        WETH_USDC_Lp,
+        routerAddress[network].aerodrome!,
+        pool.signer
+      );
+      expect(lpAllowanceDelta.gt(0));
+    });
+
+    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(
+        pool.address,
+        USDC,
+        pool.signer
+      );
+      const wethBalanceDelta = await balanceDelta(
+        pool.address,
+        WETH,
+        pool.signer
+      );
+      expect(usdcBalanceDelta.gt(0));
+      expect(wethBalanceDelta.gt(0));
+    });
+  });
+};
+
+testingHelper({
+  network: Network.BASE,
+  testingRun: testAerodrome
+});

package/src/types.ts

@@ -23,7 +23,8 @@ export enum Dapp {
   VELODROMEV2 = "velodromeV2",
   LYRA = "lyra",
   ZEROEX = "0x",
-  RAMSES = "ramses"
+  RAMSES = "ramses",
+  AERODROME = "aerodrome"
 }
 
 export enum Transaction {