@dhedge/v2-sdk 1.10.2 → 1.10.3

package/package.json

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

package/src/config.ts

@@ -113,7 +113,8 @@ export const nonfungiblePositionManagerAddress: AddressDappNetworkMap = {
     [Dapp.UNISWAPV3]: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
   },
   [Network.BASE]: {
-    [Dapp.UNISWAPV3]: "0x03a520b32C04BF3bEEf7BEb72E919cf822Ed34f1"
+    [Dapp.UNISWAPV3]: "0x03a520b32C04BF3bEEf7BEb72E919cf822Ed34f1",
+    [Dapp.AERODROMECL]: "0x827922686190790b37229fd06084350e74485b72"
   }
 };
 

package/src/entities/pool.ts

@@ -570,6 +570,7 @@ export class Pool {
       case Dapp.VELODROMEV2:
       case Dapp.AERODROME:
       case Dapp.VELODROMECL:
+      case Dapp.AERODROMECL:
         stakeTxData = getVelodromeStakeTxData(amount, true);
         break;
       default:
@@ -979,7 +980,7 @@ export class Pool {
 
   /**
    * Create UniswapV3 liquidity pool
-   * @param {dapp} Platform either UniswapV3 or VelodromeCL
+   * @param {dapp} Platform UniswapV3, VelodromeCL or AerodromeCL
    * @param {string} assetA First asset
    * @param {string} assetB Second asset
    * @param {BigNumber | string} amountA Amount first asset
@@ -994,7 +995,7 @@ export class Pool {
    * @returns {Promise<any>} Transaction
    */
   async addLiquidityUniswapV3(
-    dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL,
+    dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL | Dapp.AERODROMECL,
     assetA: string,
     assetB: string,
     amountA: BigNumber | string,
@@ -1012,8 +1013,8 @@ export class Pool {
       (minTick === null || maxTick === null)
     )
       throw new Error("Need to provide price or tick range");
-    if ((minPrice || maxPrice) && dapp === Dapp.VELODROMECL)
-      throw new Error("no price conversion for Velodrome CL");
+    if ((minPrice || maxPrice) && dapp !== Dapp.UNISWAPV3)
+      throw new Error("no price conversion for Aerodrome/Velodrome CL");
 
     const mintTxData = await getUniswapV3MintTxData(
       dapp,
@@ -1065,7 +1066,8 @@ export class Pool {
         dappAddress = nonfungiblePositionManagerAddress[this.network][dapp];
         break;
       case Dapp.VELODROMECL:
-        const tokenIdOwner = await getVelodromeClOwner(this, tokenId);
+      case Dapp.AERODROMECL:
+        const tokenIdOwner = await getVelodromeClOwner(this, dapp, tokenId);
         if (tokenIdOwner.toLowerCase() === this.address.toLowerCase()) {
           dappAddress = nonfungiblePositionManagerAddress[this.network][dapp];
         } else {
@@ -1121,7 +1123,8 @@ export class Pool {
         dappAddress = nonfungiblePositionManagerAddress[this.network][dapp];
         break;
       case Dapp.VELODROMECL:
-        const tokenIdOwner = await getVelodromeClOwner(this, tokenId);
+      case Dapp.AERODROMECL:
+        const tokenIdOwner = await getVelodromeClOwner(this, dapp, tokenId);
         if (tokenIdOwner.toLowerCase() === this.address.toLowerCase()) {
           dappAddress = nonfungiblePositionManagerAddress[this.network][dapp];
         } else {
@@ -1201,7 +1204,8 @@ export class Pool {
         txData = getVelodromeClaimTxData(this, tokenId, true);
         break;
       case Dapp.VELODROMECL:
-        const tokenIdOwner = await getVelodromeClOwner(this, tokenId);
+      case Dapp.AERODROMECL:
+        const tokenIdOwner = await getVelodromeClOwner(this, dapp, tokenId);
         if (tokenIdOwner.toLowerCase() === this.address.toLowerCase()) {
           contractAddress =
             nonfungiblePositionManagerAddress[this.network][dapp];

package/src/services/uniswap/V3Liquidity.ts

@@ -70,7 +70,7 @@ export function tryParseTick(
 }
 
 export async function getUniswapV3MintTxData(
-  dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL,
+  dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL | Dapp.AERODROMECL,
   pool: Pool,
   assetA: string,
   assetB: string,
@@ -147,7 +147,7 @@ export async function getUniswapV3MintTxData(
     INonfungiblePositionManager.abi
   );
 
-  if (dapp === Dapp.VELODROMECL) {
+  if (dapp === Dapp.VELODROMECL || dapp === Dapp.AERODROMECL) {
     iNonfungiblePositionManager = new ethers.utils.Interface(
       IVeldodromePositionManager.abi
     );
@@ -162,7 +162,7 @@ export async function getUniswapV3MintTxData(
 }
 
 export async function getUniswapV3Liquidity(
-  dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL,
+  dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL | Dapp.AERODROMECL,
   tokenId: string,
   pool: Pool
 ): Promise<BigNumber> {
@@ -184,7 +184,11 @@ export async function getIncreaseLiquidityTxData(
   amountB: ethers.BigNumber | string
 ): Promise<any> {
   let txData;
-  if (dapp === Dapp.UNISWAPV3 || dapp === Dapp.VELODROMECL) {
+  if (
+    dapp === Dapp.UNISWAPV3 ||
+    dapp === Dapp.VELODROMECL ||
+    dapp === Dapp.AERODROMECL
+  ) {
     const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
     txData = abi.encodeFunctionData(Transaction.INCREASE_LIQUIDITY, [
       [tokenId, amountA, amountB, 0, 0, await getDeadline(pool)]
@@ -214,7 +218,11 @@ export async function getDecreaseLiquidityTxData(
   amount = 100
 ): Promise<any> {
   let txData;
-  if (dapp === Dapp.UNISWAPV3 || dapp === Dapp.VELODROMECL) {
+  if (
+    dapp === Dapp.UNISWAPV3 ||
+    dapp === Dapp.VELODROMECL ||
+    dapp === Dapp.AERODROMECL
+  ) {
     const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
     const liquidity = (await getUniswapV3Liquidity(dapp, tokenId, pool))
       .times(amount)

package/src/services/velodrome/liquidity.ts

@@ -51,11 +51,12 @@ export async function getVelodromeRemoveLiquidityTxData(
 
 export async function getVelodromeClOwner(
   pool: Pool,
+  dapp: Dapp.VELODROMECL | Dapp.AERODROMECL,
   tokenId: string
 ): Promise<string> {
   const iNonfungiblePositionManager = new ethers.Contract(
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    nonfungiblePositionManagerAddress[pool.network][Dapp.VELODROMECL]!,
+    nonfungiblePositionManagerAddress[pool.network][dapp]!,
     INonfungiblePositionManager.abi,
     pool.signer
   );

package/src/test/aerodromeCL.test.ts

@@ -0,0 +1,188 @@
+import { Dhedge, Pool, ethers } from "..";
+
+import { nonfungiblePositionManagerAddress } from "../config";
+import { AssetEnabled, Dapp, Network } from "../types";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import {
+  TestingRunParams,
+  beforeAfterReset,
+  setChainlinkTimeout,
+  testingHelper
+} from "./utils/testingHelper";
+import { allowanceDelta, balanceDelta } from "./utils/token";
+import INonfungiblePositionManager from "../abi/INonfungiblePositionManager.json";
+
+const testAerodromeCL = ({ wallet, network, provider }: TestingRunParams) => {
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const AERODROME_POSITION_MANGER = nonfungiblePositionManagerAddress[network][
+    Dapp.AERODROMECL
+  ]!;
+
+  const USDC = CONTRACT_ADDRESS[network].USDC;
+  const USDT = CONTRACT_ADDRESS[network].USDT;
+  const USDC_USDT_CL_GAUGE = "0xBd85D45f1636fCEB2359d9Dcf839f12b3cF5AF3F";
+  const AERO = CONTRACT_ADDRESS[network].VELO;
+
+  let dhedge: Dhedge;
+  let pool: Pool;
+  let velodromePositionManager: ethers.Contract;
+  let tokenId: string;
+  jest.setTimeout(100000);
+
+  describe(`[${network}] Aerodrome CL  tests`, () => {
+    beforeAll(async () => {
+      // top up ETH (gas)
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x100000000000000"
+      ]);
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+
+      // setChainlinkTimeout
+      await setChainlinkTimeout({ pool, provider }, 86400 * 365);
+
+      const newAssets: AssetEnabled[] = [
+        { asset: USDC, isDeposit: true },
+        { asset: USDT, isDeposit: true },
+        {
+          asset: AERODROME_POSITION_MANGER,
+          isDeposit: false
+        },
+        {
+          asset: AERO,
+          isDeposit: false
+        }
+      ];
+      await pool.managerLogic.changeAssets(newAssets, []);
+
+      velodromePositionManager = new ethers.Contract(
+        AERODROME_POSITION_MANGER,
+        INonfungiblePositionManager.abi,
+        pool.signer
+      );
+    });
+
+    beforeAfterReset({ beforeAll, afterAll, provider });
+
+    describe("Liquidity", () => {
+      it("approves unlimited USDC and USDT on for Aerodrome CL", async () => {
+        await pool.approveSpender(AERODROME_POSITION_MANGER, USDC, MAX_AMOUNT);
+        await pool.approveSpender(AERODROME_POSITION_MANGER, USDT, MAX_AMOUNT);
+        const UsdcAllowanceDelta = await allowanceDelta(
+          pool.address,
+          USDC,
+          AERODROME_POSITION_MANGER,
+          pool.signer
+        );
+        await expect(UsdcAllowanceDelta.gt(0));
+      });
+
+      it("adds USDC and WETH to a CL (mint position)", async () => {
+        const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+        const usdtBalance = await pool.utils.getBalance(USDT, pool.address);
+        await pool.addLiquidityUniswapV3(
+          Dapp.AERODROMECL,
+          USDC,
+          USDT,
+          usdcBalance.div(2),
+          usdtBalance.div(2),
+          null,
+          null,
+          -2,
+          4,
+          1
+        );
+
+        tokenId = (
+          await velodromePositionManager.tokenOfOwnerByIndex(pool.address, 0)
+        ).toString();
+        expect(tokenId).not.toBe(null);
+      });
+
+      it("increases liquidity in a CL position", async () => {
+        const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+        const usdtBalance = await pool.utils.getBalance(USDT, pool.address);
+        const positionBefore = await velodromePositionManager.positions(
+          tokenId
+        );
+        await pool.increaseLiquidity(
+          Dapp.AERODROMECL,
+          tokenId,
+          usdcBalance.div(2),
+          usdtBalance.div(2)
+        );
+        const positionAfter = await velodromePositionManager.positions(tokenId);
+        expect(positionAfter.liquidity.gt(positionBefore.liquidity));
+      });
+
+      it("decreases liquidity from a CL position", async () => {
+        const positionBefore = await velodromePositionManager.positions(
+          tokenId
+        );
+        await pool.decreaseLiquidity(Dapp.AERODROMECL, tokenId, 50);
+        const positionAfter = await velodromePositionManager.positions(tokenId);
+        expect(positionAfter.liquidity.lt(positionBefore.liquidity));
+      });
+
+      it("collects fess of a CL position", async () => {
+        await provider.send("evm_increaseTime", [24 * 3600 * 3]); // 1 day
+        await provider.send("evm_mine", []);
+        await pool.claimFees(Dapp.AERODROMECL, tokenId);
+        expect((await balanceDelta(pool.address, USDC, pool.signer)).gt(0));
+      });
+    });
+    describe("Liquidity staking", () => {
+      it("stakes a CL position in gauge", async () => {
+        await pool.approveSpender(AERODROME_POSITION_MANGER, USDC, MAX_AMOUNT);
+        await pool.approveSpender(AERODROME_POSITION_MANGER, USDT, MAX_AMOUNT);
+        const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+        const usdtBalance = await pool.utils.getBalance(USDT, pool.address);
+        await pool.addLiquidityUniswapV3(
+          Dapp.AERODROMECL,
+          USDC,
+          USDT,
+          usdcBalance.div(2),
+          usdtBalance.div(2),
+          null,
+          null,
+          -2,
+          4,
+          1
+        );
+
+        tokenId = (
+          await velodromePositionManager.tokenOfOwnerByIndex(pool.address, 0)
+        ).toString();
+        await pool.approveSpenderNFT(
+          USDC_USDT_CL_GAUGE,
+          AERODROME_POSITION_MANGER,
+          tokenId
+        );
+        await pool.stakeInGauge(Dapp.AERODROMECL, USDC_USDT_CL_GAUGE, tokenId);
+        expect(await velodromePositionManager.ownerOf(tokenId)).toBe(
+          USDC_USDT_CL_GAUGE
+        );
+      });
+
+      it("collects fess of a staked CL position", async () => {
+        await provider.send("evm_increaseTime", [24 * 3600]); // 1 day
+        await provider.send("evm_mine", []);
+        await pool.claimFees(Dapp.AERODROMECL, tokenId);
+        expect((await balanceDelta(pool.address, AERO, pool.signer)).gt(0));
+      });
+
+      it("unstakes a CL position from a gauge", async () => {
+        await pool.unstakeFromGauge(USDC_USDT_CL_GAUGE, tokenId);
+        expect(
+          (await velodromePositionManager.ownerOf(tokenId)).toLowerCase()
+        ).toBe(pool.address.toLowerCase());
+      });
+    });
+  });
+};
+
+testingHelper({
+  network: Network.BASE,
+  testingRun: testAerodromeCL
+});

package/src/test/constants.ts

@@ -48,6 +48,7 @@ export const TEST_POOL = {
 export const CONTRACT_ADDRESS = {
   [Network.POLYGON]: {
     USDC: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
+    USDT: "",
     SWETH: "",
     WETH: "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619",
     WBTC: "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6",
@@ -63,8 +64,9 @@ export const CONTRACT_ADDRESS = {
 
   [Network.OPTIMISM]: {
     USDC: "0x0b2c639c533813f4aa9d7837caf62653d097ff85",
-    SUSD: "0x8c6f28f2f1a3c87f0f938b96d27520d9751ec8d9",
+    USDT: "",
     SWETH: "",
+    SUSD: "0x8c6f28f2f1a3c87f0f938b96d27520d9751ec8d9",
     WETH: "0x4200000000000000000000000000000000000006",
     WBTC: "0x68f180fcCe6836688e9084f035309E29Bf0A2095",
     KWENTA_ETH_PERP_V2: "0x2b3bb4c683bfc5239b029131eef3b1d214478d93",
@@ -81,6 +83,7 @@ export const CONTRACT_ADDRESS = {
   },
   [Network.ARBITRUM]: {
     USDC: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    USDT: "",
     SWETH: "0xbc011A12Da28e8F0f528d9eE5E7039E22F91cf18",
     WETH: "0x82af49447d8a07e3bd95bd0d56f35241523fbab1",
     WBTC: "0x2f2a2543b76a4166549f7aab2e75bef0aefc5b0f",
@@ -101,6 +104,7 @@ export const CONTRACT_ADDRESS = {
   },
   [Network.BASE]: {
     USDC: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+    USDT: "0xfde4c96c8593536e31f229ea8f37b2ada2699bb2",
     WETH: "0x4200000000000000000000000000000000000006",
     WBTC: "",
     SWETH: "",
@@ -111,8 +115,8 @@ export const CONTRACT_ADDRESS = {
     ARRAKIS_USDC_WETH_GAUGE: "",
     ARRAKIS_USDC_WETH_LP: "",
     WMATIC: "",
-    VELODROME_CL_USDC_WETH_GAUGE: "",
-    VELO: ""
+    VELODROME_CL_USDC_WETH_GAUGE: "0xF33a96b5932D9E9B9A0eDA447AbD8C9d48d2e0c8",
+    VELO: "0x940181a94A35A4569E4529A3CDfB74e38FD98631"
   }
 };
 

package/src/types.ts

@@ -25,7 +25,8 @@ export enum Dapp {
   LYRA = "lyra",
   ZEROEX = "0x",
   RAMSES = "ramses",
-  AERODROME = "aerodrome"
+  AERODROME = "aerodrome",
+  AERODROMECL = "aerodromeCL"
 }
 
 export enum Transaction {