@dhedge/v2-sdk 1.5.3 → 1.5.4

package/src/entities/pool.ts

@@ -43,6 +43,14 @@ import { getUniswapV3SwapTxData } from "../services/uniswap/V3Trade";
 import { getEasySwapperTxData } from "../services/toros/easySwapper";
 import { getOneInchProtocols } from "../services/oneInch/protocols";
 import { getAaveV3ClaimTxData } from "../services/aave/incentives";
+import {
+  getVelodromeAddLiquidityTxData,
+  getVelodromeRemoveLiquidityTxData
+} from "../services/velodrome/liquidity";
+import {
+  getVelodromeClaimTxData,
+  getVelodromeStakeTxData
+} from "../services/velodrome/staking";
 
 export class Pool {
   public readonly poolLogic: Contract;
@@ -430,20 +438,34 @@ export class Pool {
 
   /**
    * Stake liquidity pool tokens in gauge contract
+   * @param {Dapp} dapp Platform like Balancer or Velodrome
    * @param {string} gauge Gauge contract address
    * @param {BigNumber | string} amount Amount of liquidity pool tokens
    * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
   async stakeInGauge(
+    dapp: Dapp,
     gauge: string,
     amount: BigNumber | string,
     options: any = null
   ): Promise<any> {
-    const rewardsGauge = new ethers.utils.Interface(IBalancerRewardsGauge.abi);
-    const stakeTxData = rewardsGauge.encodeFunctionData("deposit(uint256)", [
-      amount
-    ]);
+    let stakeTxData;
+    switch (dapp) {
+      case Dapp.BALANCER:
+        const rewardsGauge = new ethers.utils.Interface(
+          IBalancerRewardsGauge.abi
+        );
+        stakeTxData = rewardsGauge.encodeFunctionData("deposit(uint256)", [
+          amount
+        ]);
+        break;
+      case Dapp.VELODROME:
+        stakeTxData = getVelodromeStakeTxData(amount);
+        break;
+      default:
+        throw new Error("dapp not supported");
+    }
     const tx = await this.poolLogic.execTransaction(
       gauge,
       stakeTxData,
@@ -1020,21 +1042,29 @@ export class Pool {
   ): Promise<any> {
     let txData;
     let contractAddress;
-    if (dapp === Dapp.UNISWAPV3) {
-      contractAddress = nonfungiblePositionManagerAddress[this.network];
-      const iNonfungiblePositionManager = new ethers.utils.Interface(
-        INonfungiblePositionManager.abi
-      );
-      txData = iNonfungiblePositionManager.encodeFunctionData(
-        Transaction.COLLECT,
-        [[tokenId, this.address, MaxUint128, MaxUint128]]
-      );
-    } else if (dapp === Dapp.ARRAKIS || dapp === Dapp.BALANCER) {
-      contractAddress = tokenId;
-      const abi = new ethers.utils.Interface(ILiquidityGaugeV4.abi);
-      txData = abi.encodeFunctionData("claim_rewards()", []);
-    } else {
-      throw new Error("dapp not supported");
+    switch (dapp) {
+      case Dapp.UNISWAPV3:
+        contractAddress = nonfungiblePositionManagerAddress[this.network];
+        const iNonfungiblePositionManager = new ethers.utils.Interface(
+          INonfungiblePositionManager.abi
+        );
+        txData = iNonfungiblePositionManager.encodeFunctionData(
+          Transaction.COLLECT,
+          [[tokenId, this.address, MaxUint128, MaxUint128]]
+        );
+        break;
+      case Dapp.ARRAKIS:
+      case Dapp.BALANCER:
+        contractAddress = tokenId;
+        const abi = new ethers.utils.Interface(ILiquidityGaugeV4.abi);
+        txData = abi.encodeFunctionData("claim_rewards()", []);
+        break;
+      case Dapp.VELODROME:
+        contractAddress = tokenId;
+        txData = getVelodromeClaimTxData(this, tokenId);
+        break;
+      default:
+        throw new Error("dapp not supported");
     }
     const tx = await this.poolLogic.execTransaction(
       contractAddress,
@@ -1078,4 +1108,61 @@ export class Pool {
     );
     return tx;
   }
+
+  /**
+   * Add liquidity to Velodrome pool
+   * @param {string} assetA First asset
+   * @param {string} assetB Second asset
+   * @param {BigNumber | string} amountA Amount first asset
+   * @param {BigNumber | string} amountB Amount second asset
+   * @param { boolean } isStable Is stable pool
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async addLiquidityVelodrome(
+    assetA: string,
+    assetB: string,
+    amountA: BigNumber | string,
+    amountB: BigNumber | string,
+    isStable: boolean,
+    options: any = null
+  ): Promise<any> {
+    const tx = await this.poolLogic.execTransaction(
+      routerAddress[this.network][Dapp.VELODROME],
+      getVelodromeAddLiquidityTxData(
+        this,
+        assetA,
+        assetB,
+        amountA,
+        amountB,
+        isStable
+      ),
+      options
+    );
+    return tx;
+  }
+
+  /**
+   * Remove liquidity from Velodrome pool
+   * @param {string} assetA First asset
+   * @param {string} assetB Second asset
+   * @param {BigNumber | string} amount Amount of LP tokens
+   * @param { boolean } isStable Is stable pool
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async removeLiquidityVelodrome(
+    assetA: string,
+    assetB: string,
+    amount: BigNumber | string,
+    isStable: boolean,
+    options: any = null
+  ): Promise<any> {
+    const tx = await this.poolLogic.execTransaction(
+      routerAddress[this.network][Dapp.VELODROME],
+      getVelodromeRemoveLiquidityTxData(this, assetA, assetB, amount, isStable),
+      options
+    );
+    return tx;
+  }
 }

package/src/services/velodrome/liquidity.ts

@@ -0,0 +1,48 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { BigNumber, ethers } from "ethers";
+import IVelodromeRouter from "../../abi/IVeldodromeRouter.json";
+import { deadline } from "../../config";
+import { Pool } from "../../entities";
+import { Transaction } from "../../types";
+
+export function getVelodromeAddLiquidityTxData(
+  pool: Pool,
+  assetA: string,
+  assetB: string,
+  amountA: BigNumber | string,
+  amountB: BigNumber | string,
+  isStable: boolean
+): any {
+  const iVelodromeRouter = new ethers.utils.Interface(IVelodromeRouter.abi);
+  return iVelodromeRouter.encodeFunctionData(Transaction.ADD_LIQUIDITY, [
+    assetA,
+    assetB,
+    isStable,
+    amountA,
+    amountB,
+    "0",
+    "0",
+    pool.address,
+    deadline
+  ]);
+}
+
+export function getVelodromeRemoveLiquidityTxData(
+  pool: Pool,
+  assetA: string,
+  assetB: string,
+  amount: BigNumber | string,
+  isStable: boolean
+): any {
+  const iVelodromeRouter = new ethers.utils.Interface(IVelodromeRouter.abi);
+  return iVelodromeRouter.encodeFunctionData(Transaction.REMOVE_LIQUIDITY, [
+    assetA,
+    assetB,
+    isStable,
+    amount,
+    "0",
+    "0",
+    pool.address,
+    deadline
+  ]);
+}

package/src/services/velodrome/staking.ts

@@ -0,0 +1,31 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { BigNumber, ethers } from "ethers";
+import IVelodromeGauge from "../../abi/IVelodromeGauge.json";
+import { Pool } from "../../entities";
+import { Transaction } from "../../types";
+import { call } from "../../utils/contract";
+const iVelodromeGauge = new ethers.utils.Interface(IVelodromeGauge.abi);
+
+export function getVelodromeStakeTxData(amount: BigNumber | string): any {
+  return iVelodromeGauge.encodeFunctionData(Transaction.DEPOSIT, [amount, "0"]);
+}
+
+export async function getVelodromeClaimTxData(
+  pool: Pool,
+  gauge: string
+): Promise<any> {
+  const rewardAssetCount = await call(pool.signer, IVelodromeGauge.abi, [
+    gauge,
+    "rewardsListLength",
+    []
+  ]);
+  const rewardAssets = await Promise.all(
+    Array.from(Array(rewardAssetCount.toNumber()).keys()).map(e =>
+      call(pool.signer, IVelodromeGauge.abi, [gauge, "rewards", [e]])
+    )
+  );
+  return iVelodromeGauge.encodeFunctionData("getReward", [
+    pool.address,
+    rewardAssets
+  ]);
+}

package/src/test/constants.ts

@@ -26,5 +26,7 @@ export const DAI = "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1";
 export const USDy = "0x1ec50880101022c11530a069690f5446d1464592";
 export const WBTC = "0x68f180fcCe6836688e9084f035309E29Bf0A2095";
 export const OP = "4200000000000000000000000000000000000042";
+export const WSTETH = "0x1F32b1c2345538c0c6f582fCB022739c4A194Ebb";
+export const VEL = "0x3c8B650257cFb5f272f799F5e2b4e65093a11a05";
 
 export const TEST_POOL = "TEST_POOL";

package/src/test/velodrome.test.ts

@@ -0,0 +1,141 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Dhedge, ethers } from "..";
+import { Dapp, Network } from "../types";
+import { TEST_POOL, WETH, WSTETH } from "./constants";
+import { getTxOptions } from "./txOptions";
+
+import { wallet } from "./wallet";
+
+const wETHwstETHLp = "0xBf205335De602ac38244F112d712ab04CB59A498";
+const wETHwstETHGauge = "0x131Ae347E654248671Afc885F0767cB605C065d7";
+
+let dhedge: Dhedge;
+let options: any;
+jest.setTimeout(100000);
+
+describe("pool", () => {
+  beforeAll(async () => {
+    dhedge = new Dhedge(wallet, Network.OPTIMISM);
+    options = await getTxOptions(Network.OPTIMISM);
+  });
+
+  it("approves unlimited WETH on for Velodrome", async () => {
+    let result;
+    const pool = await dhedge.loadPool(TEST_POOL);
+    try {
+      result = await pool.approve(
+        Dapp.VELODROME,
+        WSTETH,
+        ethers.constants.MaxInt256,
+        options
+      );
+      console.log(result);
+    } catch (e) {
+      console.log(e);
+    }
+    expect(result).not.toBe(null);
+  });
+
+  it("adds WETH and wstETH to a Velodrome stable pool", async () => {
+    const pool = await dhedge.loadPool(TEST_POOL);
+    const wethBalance = await dhedge.utils.getBalance(WETH, pool.address);
+    const stwethBalance = await dhedge.utils.getBalance(WSTETH, pool.address);
+
+    const result = await pool.addLiquidityVelodrome(
+      WETH,
+      WSTETH,
+      wethBalance,
+      stwethBalance,
+      true,
+      options
+    );
+
+    result.wait(1);
+    const lpBalance = await dhedge.utils.getBalance(wETHwstETHLp, pool.address);
+    expect(lpBalance.gt(0));
+  });
+
+  it("should stake wETH/wStETH LP in a gauge", async () => {
+    const pool = await dhedge.loadPool(TEST_POOL);
+    const balance = await dhedge.utils.getBalance(wETHwstETHLp, pool.address);
+    const result = await pool.stakeInGauge(
+      Dapp.VELODROME,
+      wETHwstETHGauge,
+      balance,
+      options
+    );
+    result.wait(1);
+    const gaugeBalance = await dhedge.utils.getBalance(
+      wETHwstETHGauge,
+      pool.address
+    );
+    expect(gaugeBalance.gt(0));
+  });
+
+  it("should claim rewards from Gauge", async () => {
+    const pool = await dhedge.loadPool(TEST_POOL);
+    const result = await pool.claimFees(
+      Dapp.VELODROME,
+      wETHwstETHGauge,
+      options
+    );
+    result.wait(1);
+    const velBalance = await dhedge.utils.getBalance(VEL, pool.address);
+    expect(velBalance.gt(0));
+  });
+
+  it("should unStake wETH/wStETH LP from a gauge", async () => {
+    const pool = await dhedge.loadPool(TEST_POOL);
+    const gaugeBalance = await dhedge.utils.getBalance(
+      wETHwstETHGauge,
+      pool.address
+    );
+    const result = await pool.unstakeFromGauge(
+      wETHwstETHGauge,
+      gaugeBalance,
+      options
+    );
+    result.wait(1);
+    const lpBalance = await dhedge.utils.getBalance(wETHwstETHLp, pool.address);
+    expect(lpBalance.gt(0));
+    const gaugeBalanceAfter = await dhedge.utils.getBalance(
+      wETHwstETHGauge,
+      pool.address
+    );
+    expect(gaugeBalanceAfter.eq(0));
+  });
+
+  it("approves unlimited wETH/stwETH LP for Velodrome", async () => {
+    let result;
+    const pool = await dhedge.loadPool(TEST_POOL);
+    try {
+      result = await pool.approve(
+        Dapp.VELODROME,
+        wETHwstETHLp,
+        ethers.constants.MaxInt256,
+        options
+      );
+      console.log(result);
+    } catch (e) {
+      console.log(e);
+    }
+    expect(result).not.toBe(null);
+  });
+
+  it("should remove all liquidity from an existing pool ", async () => {
+    const pool = await dhedge.loadPool(TEST_POOL);
+    const balance = await dhedge.utils.getBalance(wETHwstETHLp, pool.address);
+    const result = await pool.removeLiquidityVelodrome(
+      WETH,
+      WSTETH,
+      balance,
+      options
+    );
+    result.wait(1);
+    const balanceAfter = await dhedge.utils.getBalance(
+      wETHwstETHLp,
+      pool.address
+    );
+    expect(balanceAfter.eq(0));
+  });
+});

package/src/types.ts

@@ -15,7 +15,8 @@ export enum Dapp {
   SYNTHETIX = "synthetix",
   AAVEV3 = "aavev3",
   ARRAKIS = "arrakis",
-  TOROS = "toros"
+  TOROS = "toros",
+  VELODROME = "velodrome"
 }
 
 export enum Transaction {