@dhedge/v2-sdk 1.9.0 → 1.9.1

package/package.json

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

package/src/abi/IVelodromeGaugeV2.json

@@ -0,0 +1,191 @@
+{
+  "abi": [
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "user",
+          "type": "address"
+        }
+      ],
+      "name": "balanceOf",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "_amount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "_recipient",
+          "type": "address"
+        }
+      ],
+      "name": "deposit",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "_amount",
+          "type": "uint256"
+        }
+      ],
+      "name": "deposit",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "_account",
+          "type": "address"
+        }
+      ],
+      "name": "earned",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "_earned",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "_account",
+          "type": "address"
+        }
+      ],
+      "name": "getReward",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "isPool",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "_isPool",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "lastTimeRewardApplicable",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "_time",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "left",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "_left",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        }
+      ],
+      "name": "notifyRewardAmount",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "rewardPerToken",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "_rewardPerToken",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "rewardToken",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "_token",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "stakingToken",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "_pool",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "_amount",
+          "type": "uint256"
+        }
+      ],
+      "name": "withdraw",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ]
+  
+}

package/src/config.ts

@@ -29,7 +29,8 @@ export const routerAddress: AddressDappNetworkMap = {
     [Dapp.BALANCER]: "0xBA12222222228d8Ba445958a75a0704d566BF2C8",
     [Dapp.UNISWAPV3]: "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
     [Dapp.ARRAKIS]: "0xc73fb100a995b33f9fa181d420f4c8d74506df66",
-    [Dapp.TOROS]: "0xB2F1498983bf9c9442c35F772e6C1AdE66a8DeDE"
+    [Dapp.TOROS]: "0xB2F1498983bf9c9442c35F772e6C1AdE66a8DeDE",
+    [Dapp.ZEROEX]: "0xdef1c0ded9bec7f1a1670819833240f027b25eff"
   },
   [Network.OPTIMISM]: {
     [Dapp.UNISWAPV3]: "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
@@ -38,8 +39,10 @@ export const routerAddress: AddressDappNetworkMap = {
     [Dapp.ONEINCH]: "0x1111111254EEB25477B68fb85Ed929f73A960582",
     [Dapp.TOROS]: "0x3988513793bCE39f0167064A9F7fC3617FaF35AB",
     [Dapp.VELODROME]: "0x9c12939390052919aF3155f41Bf4160Fd3666A6f",
+    [Dapp.VELODROMEV2]: "0xa062ae8a9c5e11aaa026fc2670b0d65ccc8b2858",
     [Dapp.LYRA]: "0xCCE7819d65f348c64B7Beb205BA367b3fE33763B",
-    [Dapp.ARRAKIS]: "0x9ce88a56d120300061593eF7AD074A1B710094d5"
+    [Dapp.ARRAKIS]: "0x9ce88a56d120300061593eF7AD074A1B710094d5",
+    [Dapp.ZEROEX]: "0xdef1abe32c034e558cdd535791643c58a13acc10"
   },
   [Network.ARBITRUM]: {
     [Dapp.ONEINCH]: "0x1111111254EEB25477B68fb85Ed929f73A960582",

package/src/entities/pool.ts

@@ -60,6 +60,8 @@ import {
   getFuturesChangeMarginTxData
 } from "../services/futures";
 import { getFuturesCancelOrderTxData } from "../services/futures/trade";
+import { getZeroExTradeTxData } from "../services/zeroEx/zeroExTrade";
+import { ApiError } from "../errors";
 
 export class Pool {
   public readonly poolLogic: Contract;
@@ -286,6 +288,16 @@ export class Pool {
   ): Promise<any> {
     let swapTxData: string;
     switch (dapp) {
+      case Dapp.ZEROEX:
+        swapTxData = await getZeroExTradeTxData(
+          this.network,
+          assetFrom,
+          assetTo,
+          amountIn,
+          slippage,
+          this.address
+        );
+        break;
       case Dapp.ONEINCH:
         const chainId = networkChainIdMap[this.network];
         const protocols = await getOneInchProtocols(chainId);
@@ -298,8 +310,13 @@ export class Pool {
         }&destReceiver=${
           this.address
         }&slippage=${slippage.toString()}&disableEstimate=true${protocols}`;
-        const response = await axios.get(apiUrl);
-        swapTxData = response.data.tx.data;
+        try {
+          const response = await axios.get(apiUrl);
+          swapTxData = response.data.tx.data;
+        } catch (e) {
+          throw new ApiError("Swap api request of 1inch failed");
+        }
+
         break;
       case Dapp.BALANCER:
         swapTxData = await this.utils.getBalancerSwapTx(
@@ -483,7 +500,10 @@ export class Pool {
         ]);
         break;
       case Dapp.VELODROME:
-        stakeTxData = getVelodromeStakeTxData(amount);
+        stakeTxData = getVelodromeStakeTxData(amount, false);
+        break;
+      case Dapp.VELODROMEV2:
+        stakeTxData = getVelodromeStakeTxData(amount, true);
         break;
       default:
         throw new Error("dapp not supported");
@@ -526,7 +546,7 @@ export class Pool {
   }
 
   /**
-   * Unstake liquidity pool tokens from gauge contract
+   * Unstake liquidity pool tokens from Velodrome or Balancer gauge
    * @param {string} gauge Gauge contract address
    * @param {BigNumber | string} amount Amount of liquidity pool tokens
    * @param {any} options Transaction options
@@ -1051,7 +1071,11 @@ export class Pool {
         break;
       case Dapp.VELODROME:
         contractAddress = tokenId;
-        txData = getVelodromeClaimTxData(this, tokenId);
+        txData = getVelodromeClaimTxData(this, tokenId, false);
+        break;
+      case Dapp.VELODROMEV2:
+        contractAddress = tokenId;
+        txData = getVelodromeClaimTxData(this, tokenId, true);
         break;
       default:
         throw new Error("dapp not supported");
@@ -1162,6 +1186,69 @@ export class Pool {
     return tx;
   }
 
+  /**
+   * Add liquidity to Velodrome V2 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 addLiquidityVelodromeV2(
+    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.VELODROMEV2],
+      await getVelodromeAddLiquidityTxData(
+        this,
+        assetA,
+        assetB,
+        amountA,
+        amountB,
+        isStable
+      ),
+      options
+    );
+    return tx;
+  }
+
+  /**
+   * Remove liquidity from Velodrome V2 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 removeLiquidityVelodromeV2(
+    assetA: string,
+    assetB: string,
+    amount: BigNumber | string,
+    isStable: boolean,
+    options: any = null
+  ): Promise<any> {
+    const tx = await this.poolLogic.execTransaction(
+      routerAddress[this.network][Dapp.VELODROMEV2],
+      await getVelodromeRemoveLiquidityTxData(
+        this,
+        assetA,
+        assetB,
+        amount,
+        isStable
+      ),
+      options
+    );
+    return tx;
+  }
+
   /**
    * Trade options on lyra
    * @param {LyraOptionMarket} market Underlying market e.g. eth

package/src/errors.ts

@@ -0,0 +1,10 @@
+// see https://stackoverflow.com/a/41102306
+const CAN_SET_PROTOTYPE = "setPrototypeOf" in Object;
+
+export class ApiError extends Error {
+  public constructor(message?: string) {
+    super(message ?? "Api request failed");
+    this.name = this.constructor.name;
+    if (CAN_SET_PROTOTYPE) Object.setPrototypeOf(this, new.target.prototype);
+  }
+}

package/src/index.ts

@@ -1,3 +1,4 @@
 export * from "./entities";
 export * from "./types";
+export * from "./errors";
 export { ethers } from "ethers";

package/src/services/velodrome/staking.ts

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

package/src/services/zeroEx/zeroExTrade.ts

@@ -0,0 +1,52 @@
+import axios from "axios";
+import { BigNumber } from "ethers";
+import { Network } from "../../types";
+import { ApiError } from "../../errors";
+
+// slippage of 0x is different from that of 1Inch
+// in 0x, e.g. 0.03 for 3% slippage allowed
+// 1inch slippage 0.5% represented by 0.5
+// 0x slippage 0.5% represented by 0.005
+const getZeroExSlippage = (slippage: number): number => {
+  return Number(slippage) / 100;
+};
+
+export const getZeroExTradeTxData = async (
+  network: Network,
+  assetFrom: string,
+  assetTo: string,
+  amountIn: BigNumber | string,
+  slippage = 0.5,
+  takerAddress: string
+): Promise<string> => {
+  if (!process.env.ZEROEX_API_KEY)
+    throw new Error("ZEROEX_API_KEY not configured in .env file");
+  try {
+    const slippagePercentage = getZeroExSlippage(slippage);
+    const params = {
+      buyToken: assetTo,
+      sellToken: assetFrom,
+      sellAmount: amountIn.toString(),
+      // necessary to skip quote validation is that in which the takerAddress refers to a smart contract
+      skipValidation: true,
+      // Used to enable RFQ-T liquidity
+      intentOnFilling: true,
+      takerAddress,
+      slippagePercentage
+      // excludedSourcesParam
+    };
+    const response = await axios.get(
+      `https://${network}.api.0x.org/swap/v1/quote`,
+      {
+        params,
+        headers: {
+          "0x-api-key": process.env.ZEROEX_API_KEY
+        }
+      }
+    );
+
+    return response.data.data;
+  } catch (e) {
+    throw new ApiError("Swap api request of 0x failed");
+  }
+};

package/src/test/txOptions.ts

@@ -5,7 +5,7 @@ import { Network } from "../types";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const getTxOptions = async (network: Network): Promise<any> => {
   if (network === Network.POLYGON) {
-    const result = await axios("https://gasstation-mainnet.matic.network/v2");
+    const result = await axios("https://gasstation.polygon.technology/v2");
     return {
       gasLimit: "3000000",
       maxPriorityFeePerGas: new BigNumber(result.data.fast.maxPriorityFee)

package/src/test/velodromeV2.test.ts

@@ -0,0 +1,114 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Dhedge, Pool } from "..";
+import { routerAddress } from "../config";
+import { Dapp, Network } from "../types";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import { allowanceDelta, balanceDelta } from "./utils/token";
+
+import { wallet } from "./wallet";
+
+const USDC_SUSD_Lp = "0x6d5BA400640226e24b50214d2bBb3D4Db8e6e15a";
+const USDC_SUSD_Gauge = "0x55a272304456355242f6690863b5c8d5c512ff71";
+const network = Network.OPTIMISM;
+const SUSD = CONTRACT_ADDRESS[network].SUSD;
+const USDC = CONTRACT_ADDRESS[network].USDC;
+
+let dhedge: Dhedge;
+let pool: Pool;
+jest.setTimeout(100000);
+
+describe("pool", () => {
+  beforeAll(async () => {
+    dhedge = new Dhedge(wallet, network);
+    pool = await dhedge.loadPool(TEST_POOL[network]);
+  });
+
+  it("approves unlimited sUSD and USDC on for Velodrome", async () => {
+    await pool.approve(Dapp.VELODROMEV2, SUSD, MAX_AMOUNT);
+    await pool.approve(Dapp.VELODROMEV2, USDC, MAX_AMOUNT);
+    const UsdcAllowanceDelta = await allowanceDelta(
+      pool.address,
+      USDC,
+      routerAddress[network].velodromeV2!,
+      pool.signer
+    );
+    await expect(UsdcAllowanceDelta.gt(0));
+  });
+
+  it("adds USDC and SUSD to a Velodrome stable pool", async () => {
+    await pool.addLiquidityVelodromeV2(
+      USDC,
+      SUSD,
+      (5 * 1e6).toString(),
+      (5 * 1e18).toString(),
+      true
+    );
+
+    const lpTokenDelta = await balanceDelta(
+      pool.address,
+      USDC_SUSD_Lp,
+      pool.signer
+    );
+    expect(lpTokenDelta.gt(0));
+  });
+
+  it("should stake USDC-sUSD LP in a gauge", async () => {
+    const balance = await dhedge.utils.getBalance(USDC_SUSD_Lp, pool.address);
+    await pool.approveSpender(USDC_SUSD_Gauge, USDC_SUSD_Lp, MAX_AMOUNT);
+    await pool.stakeInGauge(Dapp.VELODROMEV2, USDC_SUSD_Gauge, balance);
+    const gaugeBalance = await balanceDelta(
+      pool.address,
+      USDC_SUSD_Lp,
+      pool.signer
+    );
+    expect(gaugeBalance.gt(0));
+  });
+
+  it("should claim rewards from Gauge", async () => {
+    const tx = await pool.claimFees(Dapp.VELODROMEV2, USDC_SUSD_Gauge);
+    expect(tx).not.toBe(null);
+  });
+
+  it("should unStake USDC-sUSD LP from a gauge", async () => {
+    const gaugeBalance = await dhedge.utils.getBalance(
+      USDC_SUSD_Gauge,
+      pool.address
+    );
+    await pool.unstakeFromGauge(USDC_SUSD_Gauge, gaugeBalance);
+    const lpTokenDelta = await balanceDelta(
+      pool.address,
+      USDC_SUSD_Lp,
+      pool.signer
+    );
+    expect(lpTokenDelta.gt(0));
+  });
+
+  it("approves unlimited wETH/stwETH LP for Velodrome", async () => {
+    await pool.approve(Dapp.VELODROMEV2, USDC_SUSD_Lp, MAX_AMOUNT);
+    const lpAllowanceDelta = await allowanceDelta(
+      pool.address,
+      USDC_SUSD_Lp,
+      routerAddress[network].velodrome!,
+      pool.signer
+    );
+    expect(lpAllowanceDelta.gt(0));
+  });
+
+  it("should remove all liquidity from an existing pool ", async () => {
+    const balance = await dhedge.utils.getBalance(USDC_SUSD_Lp, pool.address);
+    await pool.removeLiquidityVelodromeV2(USDC, SUSD, balance, true);
+    const usdcBalanceDelta = await balanceDelta(
+      pool.address,
+      USDC,
+      pool.signer
+    );
+    const susdBalanceDelta = await balanceDelta(
+      pool.address,
+      SUSD,
+      pool.signer
+    );
+    expect(usdcBalanceDelta.gt(0));
+    expect(susdBalanceDelta.gt(0));
+  });
+});

package/src/test/zeroEx.test.ts

@@ -0,0 +1,46 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { Dhedge, Pool } from "..";
+import { routerAddress } from "../config";
+import { Dapp, Network } from "../types";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import { allowanceDelta, balanceDelta } from "./utils/token";
+
+import { wallet } from "./wallet";
+
+//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);
+
+describe("pool", () => {
+  beforeAll(async () => {
+    dhedge = new Dhedge(wallet, network);
+    pool = await dhedge.loadPool(TEST_POOL[network]);
+  });
+
+  it("approves unlimited USDC on 0x", async () => {
+    await pool.approve(Dapp.ZEROEX, USDC, MAX_AMOUNT);
+    const usdcAllowanceDelta = await allowanceDelta(
+      pool.address,
+      USDC,
+      routerAddress[network]["0x"]!,
+      pool.signer
+    );
+    await expect(usdcAllowanceDelta.gt(0));
+  });
+
+  it("trades 2 USDC into WETH on 0x", async () => {
+    await pool.trade(Dapp.ZEROEX, USDC, WETH, "2000000", 0.5);
+    const wethBalanceDelta = await balanceDelta(
+      pool.address,
+      WETH,
+      pool.signer
+    );
+    expect(wethBalanceDelta.gt(0));
+  });
+});

package/src/types.ts

@@ -19,7 +19,9 @@ export enum Dapp {
   ARRAKIS = "arrakis",
   TOROS = "toros",
   VELODROME = "velodrome",
-  LYRA = "lyra"
+  VELODROMEV2 = "velodromeV2",
+  LYRA = "lyra",
+  ZEROEX = "0x"
 }
 
 export enum Transaction {