@dhedge/v2-sdk 1.10.3 → 1.10.5

package/src/entities/pool.ts

@@ -64,7 +64,8 @@ import { getZeroExTradeTxData } from "../services/zeroEx/zeroExTrade";
 import { getOneInchSwapTxData } from "../services/oneInch";
 import {
   getCreateVestTxData,
-  getExitVestTxData
+  getExitVestTxData,
+  getRewardsTxDta
 } from "../services/ramses/vesting";
 import { getPoolTxOrGasEstimate } from "../utils/contract";
 import {
@@ -72,6 +73,10 @@ import {
   mintUnitViaFlatMoney,
   redeemUnitViaFlatMoney
 } from "../services/flatmoney/stableLp";
+import {
+  getCompoundV3LendTxData,
+  getCompoundV3WithdrawTxData
+} from "../services/compound/lending";
 
 export class Pool {
   public readonly poolLogic: Contract;
@@ -666,6 +671,7 @@ export class Pool {
       this.address,
       referralCode
     ]);
+
     const tx = await getPoolTxOrGasEstimate(
       this,
       [routerAddress[this.network][dapp], depositTxData, options],
@@ -674,6 +680,32 @@ export class Pool {
     return tx;
   }
 
+  /**
+   * Lend asset to a Compound V3 style lending pool
+   * @param {string} market Address of market e.g cUSDCv3 address
+   * @param {string} asset Asset
+   * @param {BigNumber | string} amount Amount of asset to lend
+   * @param {any} options Transaction options
+   * @param {boolean} estimateGas Simulate/estimate gas
+   * @returns {Promise<any>} Transaction
+   */
+  async lendCompoundV3(
+    market: string,
+    asset: string,
+    amount: BigNumber | string,
+    options: any = null,
+    estimateGas = false
+  ): Promise<any> {
+    const supplyTxData = getCompoundV3LendTxData(asset, amount);
+
+    const tx = await getPoolTxOrGasEstimate(
+      this,
+      [market, supplyTxData, options],
+      estimateGas
+    );
+    return tx;
+  }
+
   /**
    * Witdraw asset from a lending pool
    * @param {Dapp} dapp Platform like Aave
@@ -695,6 +727,7 @@ export class Pool {
       Transaction.WITHDRAW,
       [asset, amount, this.address]
     );
+
     const tx = await getPoolTxOrGasEstimate(
       this,
       [routerAddress[this.network][dapp], withdrawTxData, options],
@@ -703,6 +736,32 @@ export class Pool {
     return tx;
   }
 
+  /**
+   * Witdraw asset from a COmpound V3 style lending pool
+   * @param {string} market Address of market e.g cUSDCv3 address
+   * @param {string} asset Asset
+   * @param  {BigNumber | string} amount Amount of asset to withdraw
+   * @param {any} options Transaction options
+   * @param {boolean} estimateGas Simulate/estimate gas
+   * @returns {Promise<any>} Transaction
+   */
+  async withdrawCompoundV3(
+    market: string,
+    asset: string,
+    amount: BigNumber | string,
+    options: any = null,
+    estimateGas = false
+  ): Promise<any> {
+    const withdrawTxData = getCompoundV3WithdrawTxData(asset, amount);
+
+    const tx = await getPoolTxOrGasEstimate(
+      this,
+      [market, withdrawTxData, options],
+      estimateGas
+    );
+    return tx;
+  }
+
   /**
    * Borrow asset from a lending pool
    * @param {Dapp} dapp Platform like Aave
@@ -980,7 +1039,7 @@ export class Pool {
 
   /**
    * Create UniswapV3 liquidity pool
-   * @param {dapp} Platform UniswapV3, VelodromeCL or AerodromeCL
+   * @param {dapp} Platform UniswapV3, VelodromeCL, AerodromeCL or RamesesCL
    * @param {string} assetA First asset
    * @param {string} assetB Second asset
    * @param {BigNumber | string} amountA Amount first asset
@@ -995,7 +1054,7 @@ export class Pool {
    * @returns {Promise<any>} Transaction
    */
   async addLiquidityUniswapV3(
-    dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL | Dapp.AERODROMECL,
+    dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL | Dapp.AERODROMECL | Dapp.RAMSESCL,
     assetA: string,
     assetB: string,
     amountA: BigNumber | string,
@@ -1063,6 +1122,7 @@ export class Pool {
     let txData;
     switch (dapp) {
       case Dapp.UNISWAPV3:
+      case Dapp.RAMSESCL:
         dappAddress = nonfungiblePositionManagerAddress[this.network][dapp];
         break;
       case Dapp.VELODROMECL:
@@ -1120,6 +1180,7 @@ export class Pool {
     let txData;
     switch (dapp) {
       case Dapp.UNISWAPV3:
+      case Dapp.RAMSESCL:
         dappAddress = nonfungiblePositionManagerAddress[this.network][dapp];
         break;
       case Dapp.VELODROMECL:
@@ -1181,6 +1242,7 @@ export class Pool {
     );
     switch (dapp) {
       case Dapp.UNISWAPV3:
+      case Dapp.RAMSESCL:
         contractAddress = nonfungiblePositionManagerAddress[this.network][dapp];
         txData = iNonfungiblePositionManager.encodeFunctionData(
           Transaction.COLLECT,
@@ -1230,6 +1292,34 @@ export class Pool {
     return tx;
   }
 
+  /**
+   * Get rewards of an NFT position
+   * @param {Dapp} dapp Platform e.g. Ramses CL
+   * @param {string} tokenId Token Id
+   * @param {string[]} rewards Reward tokens
+   * @param {any} options Transaction option
+   * @param {boolean} estimateGas Simulate/estimate gas
+   * @returns {Promise<any>} Transaction
+   */
+  async getRewards(
+    dapp: Dapp,
+    tokenId: string,
+    rewards: string[],
+    options: any = null,
+    estimateGas = false
+  ): Promise<any> {
+    const tx = await getPoolTxOrGasEstimate(
+      this,
+      [
+        nonfungiblePositionManagerAddress[this.network][dapp],
+        getRewardsTxDta(tokenId, rewards),
+        options
+      ],
+      estimateGas
+    );
+    return tx;
+  }
+
   /**
    * Trade an asset into another asset
    * @param {Dapp} dapp Platform like Sushiswap or Uniswap

package/src/services/compound/lending.ts

@@ -0,0 +1,20 @@
+import { ethers } from "../..";
+import ICompoundV3Comet from "../../abi/compound/ICompoundV3Comet.json";
+
+export function getCompoundV3LendTxData(
+  asset: string,
+  amount: ethers.BigNumber | string
+): string {
+  return new ethers.utils.Interface(
+    ICompoundV3Comet
+  ).encodeFunctionData("supply", [asset, amount]);
+}
+
+export function getCompoundV3WithdrawTxData(
+  asset: string,
+  amount: ethers.BigNumber | string
+): string {
+  return new ethers.utils.Interface(
+    ICompoundV3Comet
+  ).encodeFunctionData("withdraw", [asset, amount]);
+}

package/src/services/ramses/vesting.ts

@@ -1,8 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { BigNumber, ethers } from "ethers";
 import IXRam from "../../abi/IXRam.json";
+import IRamsesNonfungiblePositionManager from "../../abi/IRamsesNonfungiblePositionManager.json";
 
 const iXRam = new ethers.utils.Interface(IXRam.abi);
+const iRamsesNonfungiblePositionManager = new ethers.utils.Interface(
+  IRamsesNonfungiblePositionManager
+);
 
 export function getCreateVestTxData(amount: BigNumber | string): string {
   return iXRam.encodeFunctionData("createVest", [amount]);
@@ -11,3 +15,10 @@ export function getCreateVestTxData(amount: BigNumber | string): string {
 export function getExitVestTxData(vestId: number): string {
   return iXRam.encodeFunctionData("exitVest", [vestId, false]);
 }
+
+export function getRewardsTxDta(tokenId: string, rewards: string[]): string {
+  return iRamsesNonfungiblePositionManager.encodeFunctionData("getReward", [
+    tokenId,
+    rewards
+  ]);
+}

package/src/services/uniswap/V3Liquidity.ts

@@ -19,6 +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 { getDeadline } from "../../utils/deadline";
 import BigNumber from "bignumber.js";
@@ -70,7 +71,7 @@ export function tryParseTick(
 }
 
 export async function getUniswapV3MintTxData(
-  dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL | Dapp.AERODROMECL,
+  dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL | Dapp.AERODROMECL | Dapp.RAMSESCL,
   pool: Pool,
   assetA: string,
   assetB: string,
@@ -154,6 +155,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
   ]);
@@ -162,7 +170,7 @@ export async function getUniswapV3MintTxData(
 }
 
 export async function getUniswapV3Liquidity(
-  dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL | Dapp.AERODROMECL,
+  dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL | Dapp.AERODROMECL | Dapp.RAMSESCL,
   tokenId: string,
   pool: Pool
 ): Promise<BigNumber> {
@@ -187,7 +195,8 @@ export async function getIncreaseLiquidityTxData(
   if (
     dapp === Dapp.UNISWAPV3 ||
     dapp === Dapp.VELODROMECL ||
-    dapp === Dapp.AERODROMECL
+    dapp === Dapp.AERODROMECL ||
+    dapp === Dapp.RAMSESCL
   ) {
     const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
     txData = abi.encodeFunctionData(Transaction.INCREASE_LIQUIDITY, [
@@ -221,7 +230,8 @@ export async function getDecreaseLiquidityTxData(
   if (
     dapp === Dapp.UNISWAPV3 ||
     dapp === Dapp.VELODROMECL ||
-    dapp === Dapp.AERODROMECL
+    dapp === Dapp.AERODROMECL ||
+    dapp === Dapp.RAMSESCL
   ) {
     const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
     const liquidity = (await getUniswapV3Liquidity(dapp, tokenId, pool))

package/src/test/compoundV3.test.ts

@@ -0,0 +1,90 @@
+/* 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 { AssetEnabled, Network } from "../types";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import {
+  TestingRunParams,
+  beforeAfterReset,
+  setWETHAmount,
+  testingHelper
+} from "./utils/testingHelper";
+import { allowanceDelta, balanceDelta } from "./utils/token";
+import { getWalletData } from "./wallet";
+
+const testCompoundV3 = ({ network, provider }: TestingRunParams) => {
+  const WETH = CONTRACT_ADDRESS[network].WETH;
+  const COMPOUNDV3_WETH = CONTRACT_ADDRESS[network].COMPOUNDV3_WETH;
+
+  let dhedge: Dhedge;
+  let pool: Pool;
+  jest.setTimeout(100000);
+
+  describe(`[${network}] compound V3 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 setWETHAmount({
+        amount: new BigNumber(1e18).toFixed(0),
+        userAddress: pool.address,
+        network,
+        provider
+      });
+
+      const newAssets: AssetEnabled[] = [
+        { asset: WETH, isDeposit: true },
+        {
+          asset: COMPOUNDV3_WETH,
+          isDeposit: false
+        }
+      ];
+      await pool.managerLogic.changeAssets(newAssets, []);
+    });
+    beforeAfterReset({ beforeAll, afterAll, provider });
+
+    it("approves unlimited WETH for cWETHv3 market", async () => {
+      await pool.approveSpender(COMPOUNDV3_WETH, WETH, MAX_AMOUNT);
+      const UsdcAllowanceDelta = await allowanceDelta(
+        pool.address,
+        WETH,
+        COMPOUNDV3_WETH,
+        pool.signer
+      );
+      await expect(UsdcAllowanceDelta.gt(0));
+    });
+
+    it("lends WETH to CompundV3 WETH market", async () => {
+      const wethBalance = await pool.utils.getBalance(WETH, pool.address);
+      await pool.lendCompoundV3(COMPOUNDV3_WETH, WETH, wethBalance);
+
+      const cWETHTokenDelta = await balanceDelta(
+        pool.address,
+        COMPOUNDV3_WETH,
+        pool.signer
+      );
+      expect(cWETHTokenDelta.gt(0));
+    });
+
+    it("withdraw WETH from CompundV3 WETH market", async () => {
+      const cWETHBalance = await pool.utils.getBalance(
+        COMPOUNDV3_WETH,
+        pool.address
+      );
+      await pool.withdrawCompoundV3(COMPOUNDV3_WETH, WETH, cWETHBalance);
+      const wethBalance = await balanceDelta(pool.address, WETH, pool.signer);
+      expect(wethBalance.gt(0));
+    });
+  });
+};
+
+testingHelper({
+  network: Network.ARBITRUM,
+  testingRun: testCompoundV3
+});

package/src/test/constants.ts

@@ -41,7 +41,7 @@ export const KWENTA_ETH_PERP_V2 = "0x2b3bb4c683bfc5239b029131eef3b1d214478d93";
 export const TEST_POOL = {
   [Network.POLYGON]: "0x699fd4d6eadb216704c7e355cfa0a12f51813163",
   [Network.OPTIMISM]: "0x12573bfdf764ab9d52aca20e2827497a66829716",
-  [Network.ARBITRUM]: "0x2dc2f936c8b6619facc69355d65dd93d2f4cc2bd",
+  [Network.ARBITRUM]: "0x0b5f6591c8eb23e5a68102d3d39ebbb464ee5c14",
   [Network.BASE]: "0x4842b42F68524383F609aa46eAfc18c1459cE3cD"
 };
 
@@ -59,7 +59,8 @@ export const CONTRACT_ADDRESS = {
       nonfungiblePositionManager: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88"
     },
     VELODROME_CL_USDC_WETH_GAUGE: "",
-    VELO: ""
+    VELO: "",
+    COMPOUNDV3_WETH: ""
   },
 
   [Network.OPTIMISM]: {
@@ -79,7 +80,8 @@ export const CONTRACT_ADDRESS = {
     ARRAKIS_USDC_WETH_GAUGE: "",
     ARRAKIS_USDC_WETH_LP: "",
     VELODROME_CL_USDC_WETH_GAUGE: "0xa75127121d28a9BF848F3B70e7Eea26570aa7700",
-    VELO: "0x9560e827aF36c94D2Ac33a39bCE1Fe78631088Db"
+    VELO: "0x9560e827aF36c94D2Ac33a39bCE1Fe78631088Db",
+    COMPOUNDV3_WETH: ""
   },
   [Network.ARBITRUM]: {
     USDC: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
@@ -100,7 +102,8 @@ export const CONTRACT_ADDRESS = {
     ARRAKIS_USDC_WETH_LP: "",
     WMATIC: "",
     VELODROME_CL_USDC_WETH_GAUGE: "",
-    VELO: ""
+    VELO: "",
+    COMPOUNDV3_WETH: "0x6f7D514bbD4aFf3BcD1140B7344b32f063dEe486"
   },
   [Network.BASE]: {
     USDC: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
@@ -116,7 +119,8 @@ export const CONTRACT_ADDRESS = {
     ARRAKIS_USDC_WETH_LP: "",
     WMATIC: "",
     VELODROME_CL_USDC_WETH_GAUGE: "0xF33a96b5932D9E9B9A0eDA447AbD8C9d48d2e0c8",
-    VELO: "0x940181a94A35A4569E4529A3CDfB74e38FD98631"
+    VELO: "0x940181a94A35A4569E4529A3CDfB74e38FD98631",
+    COMPOUNDV3_WETH: ""
   }
 };
 

package/src/test/ramsesCL.test.ts

@@ -0,0 +1,155 @@
+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 testRamsesCL = ({ wallet, network, provider }: TestingRunParams) => {
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const RAMSES_POSITION_MANGER = nonfungiblePositionManagerAddress[network][
+    Dapp.RAMSESCL
+  ]!;
+
+  const USDC = CONTRACT_ADDRESS[network].USDC;
+  const WETH = CONTRACT_ADDRESS[network].WETH;
+  //if other chains then define per network
+  const RAM = "0xaaa6c1e32c55a7bfa8066a6fae9b42650f262418";
+  const ARB = "0x912ce59144191c1204e64559fe8253a0e49e6548";
+
+  let dhedge: Dhedge;
+  let pool: Pool;
+  let ramsesPositionManager: ethers.Contract;
+  let tokenId: string;
+  jest.setTimeout(100000);
+
+  describe(`[${network}] Ramses 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: WETH, isDeposit: true },
+        {
+          asset: RAMSES_POSITION_MANGER,
+          isDeposit: false
+        },
+        {
+          asset: ARB,
+          isDeposit: false
+        }
+      ];
+      await pool.changeAssets(newAssets);
+      await pool.approve(Dapp.ONEINCH, USDC, MAX_AMOUNT);
+      await pool.trade(Dapp.ONEINCH, USDC, WETH, (2.5 * 1e6).toString());
+
+      ramsesPositionManager = new ethers.Contract(
+        RAMSES_POSITION_MANGER,
+        INonfungiblePositionManager.abi,
+        pool.signer
+      );
+    });
+
+    beforeAfterReset({ beforeAll, afterAll, provider });
+
+    describe("Liquidity", () => {
+      it("approves unlimited USDC and WETH on for Velodrome CL", async () => {
+        await pool.approveSpender(RAMSES_POSITION_MANGER, USDC, MAX_AMOUNT);
+        await pool.approveSpender(RAMSES_POSITION_MANGER, WETH, MAX_AMOUNT);
+        const UsdcAllowanceDelta = await allowanceDelta(
+          pool.address,
+          USDC,
+          RAMSES_POSITION_MANGER,
+          pool.signer
+        );
+        await expect(UsdcAllowanceDelta.gt(0));
+      });
+
+      it("adds USDC and WETH to a Velodrome CL (mint position)", async () => {
+        const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+        const wethBalance = await pool.utils.getBalance(WETH, pool.address);
+        await pool.addLiquidityUniswapV3(
+          Dapp.RAMSESCL,
+          WETH,
+          USDC,
+          usdcBalance.div(2),
+          wethBalance.div(2),
+          null,
+          null,
+          -204460,
+          -193470,
+          500
+        );
+
+        tokenId = (
+          await ramsesPositionManager.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 wethBalance = await pool.utils.getBalance(WETH, pool.address);
+        const positionBefore = await ramsesPositionManager.positions(tokenId);
+        await pool.increaseLiquidity(
+          Dapp.RAMSESCL,
+          tokenId,
+          usdcBalance.div(2),
+          wethBalance.div(2)
+        );
+        const positionAfter = await ramsesPositionManager.positions(tokenId);
+        expect(positionAfter.liquidity.gt(positionBefore.liquidity));
+      });
+
+      it("decreases liquidity from a CL position", async () => {
+        const positionBefore = await ramsesPositionManager.positions(tokenId);
+        await pool.decreaseLiquidity(Dapp.RAMSESCL, tokenId, 50);
+        const positionAfter = await ramsesPositionManager.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.RAMSESCL, tokenId);
+        expect((await balanceDelta(pool.address, USDC, pool.signer)).gt(0));
+      });
+
+      it("get rewards of a CL position", async () => {
+        await provider.send("evm_increaseTime", [24 * 3600 * 3]); // 1 day
+        await provider.send("evm_mine", []);
+        await pool.getRewards(Dapp.RAMSESCL, tokenId, [RAM]);
+        expect((await balanceDelta(pool.address, RAM, pool.signer)).gt(0));
+      });
+
+      it("decreases 100% liquidity and burns a CL position", async () => {
+        await pool.decreaseLiquidity(Dapp.RAMSESCL, tokenId, 100);
+        const positionAfter = await ramsesPositionManager.balanceOf(
+          pool.address
+        );
+        expect(positionAfter.eq(0));
+      });
+    });
+  });
+};
+
+testingHelper({
+  network: Network.ARBITRUM,
+  testingRun: testRamsesCL
+});

package/src/types.ts

@@ -26,7 +26,8 @@ export enum Dapp {
   ZEROEX = "0x",
   RAMSES = "ramses",
   AERODROME = "aerodrome",
-  AERODROMECL = "aerodromeCL"
+  AERODROMECL = "aerodromeCL",
+  RAMSESCL = "ramsesCL"
 }
 
 export enum Transaction {