@dhedge/v2-sdk 1.2.1 → 1.3.0

package/src/entities/pool.ts

@@ -6,10 +6,19 @@ import { Contract, ethers, Wallet, BigNumber } from "ethers";
 import IERC20 from "../abi/IERC20.json";
 import IMiniChefV2 from "../abi/IMiniChefV2.json";
 import ILendingPool from "../abi/ILendingPool.json";
+import ISynthetix from "../abi/ISynthetix.json";
 import IUniswapV2Router from "../abi/IUniswapV2Router.json";
+import INonfungiblePositionManager from "../abi/INonfungiblePositionManager.json";
 import IBalancerMerkleOrchard from "../abi/IBalancerMerkleOrchard.json";
 import IAaveIncentivesController from "../abi/IAaveIncentivesController.json";
-import { routerAddress, stakingAddress } from "../config";
+import {
+  deadline,
+  MaxUint128,
+  nonfungiblePositionManagerAddress,
+  routerAddress,
+  stakingAddress,
+  SYNTHETIX_TRACKING_CODE
+} from "../config";
 import {
   Dapp,
   Transaction,
@@ -20,10 +29,17 @@ import {
 
 import { Utils } from "./utils";
 import { ClaimService } from "../services/claim-balancer/claim.service";
+import {
+  getUniswapV3Liquidity,
+  getUniswapV3MintParams
+} from "../services/uniswap/V3Liquidity";
+import { FeeAmount } from "@uniswap/v3-sdk";
+import { getUniswapV3SwapTxData } from "../services/uniswap/V3Trade";
 
 export class Pool {
   public readonly poolLogic: Contract;
   public readonly managerLogic: Contract;
+  public readonly factory: Contract;
   public readonly signer: Wallet;
   public readonly address: string;
   public readonly utils: Utils;
@@ -34,7 +50,8 @@ export class Pool {
     signer: Wallet,
     poolLogic: Contract,
     mangerLogic: Contract,
-    utils: Utils
+    utils: Utils,
+    factory: Contract
   ) {
     this.network = network;
     this.poolLogic = poolLogic;
@@ -42,6 +59,7 @@ export class Pool {
     this.managerLogic = mangerLogic;
     this.signer = signer;
     this.utils = utils;
+    this.factory = factory;
   }
 
   /**
@@ -170,13 +188,39 @@ export class Pool {
     return tx;
   }
 
+  /**
+   * Approve the liquidity pool token for staking
+   * @param {Dapp} dapp Platform like Sushiswap or Uniswap
+   * @param {string} asset Address of liquidity pool token
+   * @param {BigNumber | string} amount Aamount to be approved
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async approveUniswapV3Liquidity(
+    asset: string,
+    amount: BigNumber | string,
+    options: any = null
+  ): Promise<any> {
+    const iERC20 = new ethers.utils.Interface(IERC20.abi);
+    const approveTxData = iERC20.encodeFunctionData("approve", [
+      nonfungiblePositionManagerAddress[this.network],
+      amount
+    ]);
+    const tx = await this.poolLogic.execTransaction(
+      asset,
+      approveTxData,
+      options
+    );
+    return tx;
+  }
+
   /**
    * Trade an asset into another asset
    * @param {Dapp} dapp Platform like Sushiswap or Uniswap
    * @param {string} assetFrom Asset to trade from
    * @param {string} assetTo Asset to trade into
    * @param {BigNumber | string} amountIn Amount
-   * @param {BigNumber | string} minAmountOut Minumum amount to receive
+   * @param {number} slippage Slippage tolerance in %
    * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
@@ -205,6 +249,19 @@ export class Pool {
         amountIn,
         slippage
       );
+    } else if (dapp === Dapp.SYNTHETIX) {
+      const iSynthetix = new ethers.utils.Interface(ISynthetix.abi);
+      const assets = [assetFrom, assetTo].map(asset =>
+        ethers.utils.formatBytes32String(asset)
+      );
+      const daoAddress = await this.factory.owner();
+      swapTxData = iSynthetix.encodeFunctionData(Transaction.SWAP_SYNTHS, [
+        assets[0],
+        amountIn,
+        assets[1],
+        daoAddress,
+        SYNTHETIX_TRACKING_CODE
+      ]);
     } else {
       const iUniswapV2Router = new ethers.utils.Interface(IUniswapV2Router.abi);
       const minAmountOut = await this.utils.getMinAmountOut(
@@ -219,7 +276,7 @@ export class Pool {
         minAmountOut,
         [assetFrom, assetTo],
         this.address,
-        Math.floor(Date.now() / 1000) + 60 * 20 // 20 minutes from the current Unix time
+        deadline
       ]);
     }
     const tx = await this.poolLogic.execTransaction(
@@ -251,16 +308,7 @@ export class Pool {
     const iUniswapV2Router = new ethers.utils.Interface(IUniswapV2Router.abi);
     const addLiquidityTxData = iUniswapV2Router.encodeFunctionData(
       Transaction.ADD_LIQUIDITY,
-      [
-        assetA,
-        assetB,
-        amountA,
-        amountB,
-        0,
-        0,
-        this.address,
-        Math.floor(Date.now() / 1000) + 60 * 20 // 20 minutes from the current Unix time
-      ]
+      [assetA, assetB, amountA, amountB, 0, 0, this.address, deadline]
     );
     const tx = await this.poolLogic.execTransaction(
       routerAddress[this.network][dapp],
@@ -289,15 +337,7 @@ export class Pool {
     const iUniswapV2Router = new ethers.utils.Interface(IUniswapV2Router.abi);
     const removeLiquidityTxData = iUniswapV2Router.encodeFunctionData(
       Transaction.REMOVE_LIQUIDITY,
-      [
-        assetA,
-        assetB,
-        amount,
-        0,
-        0,
-        this.address,
-        Math.floor(Date.now() / 1000) + 60 * 20 // 20 minutes from the current Unix time
-      ]
+      [assetA, assetB, amount, 0, 0, this.address, deadline]
     );
     const tx = await this.poolLogic.execTransaction(
       routerAddress[this.network][dapp],
@@ -657,16 +697,13 @@ export class Pool {
       iAaveIncentivesController,
       this.signer
     );
-
     const amount = await aaveIncentivesController.getUserUnclaimedRewards(
       this.address
     );
-
     const claimTxData = iAaveIncentivesController.encodeFunctionData(
       Transaction.CLAIM_REWARDS,
       [assets, amount, this.address]
     );
-
     const tx = await this.poolLogic.execTransaction(
       aaveIncentivesAddress,
       claimTxData,
@@ -674,4 +711,195 @@ export class Pool {
     );
     return tx;
   }
+
+  /**
+   * Create UniswapV3 liquidity 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 { number } minPrice Lower price range (assetB per assetA)
+   * @param { number } maxPrice Upper price range (assetB per assetA)
+   * @param { number } minTick Lower tick range
+   * @param { number } maxTick Upper tick range
+   * @param { FeeAmount } feeAmount Fee tier (Low 0.05%, Medium 0.3%, High 1%)
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async addLiquidityUniswapV3(
+    assetA: string,
+    assetB: string,
+    amountA: BigNumber | string,
+    amountB: BigNumber | string,
+    minPrice: number | null,
+    maxPrice: number | null,
+    minTick: number | null,
+    maxTick: number | null,
+    feeAmount: FeeAmount,
+    options: any = null
+  ): Promise<any> {
+    if ((!minPrice || !maxPrice) && (!minTick || !maxTick))
+      throw new Error("Need to provide price or tick range");
+
+    const iNonfungiblePositionManager = new ethers.utils.Interface(
+      INonfungiblePositionManager.abi
+    );
+
+    const mintTxParams = await getUniswapV3MintParams(
+      this,
+      assetA,
+      assetB,
+      amountA,
+      amountB,
+      minPrice,
+      maxPrice,
+      minTick,
+      maxTick,
+      feeAmount
+    );
+    const mintTxData = iNonfungiblePositionManager.encodeFunctionData(
+      Transaction.MINT,
+      [mintTxParams]
+    );
+    const tx = await this.poolLogic.execTransaction(
+      nonfungiblePositionManagerAddress[this.network],
+      mintTxData,
+      options
+    );
+    return tx;
+  }
+
+  /**
+   * Remove liquidity from an UniswapV3 liquidity pool
+   * @param {string} tokenId Token Id of UniswapV3 position
+   * @param {number} amount Amount in percent of assets to be removed
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async removeLiquidityUniswapV3(
+    tokenId: string,
+    amount = 100,
+    options: any = null
+  ): Promise<any> {
+    const iNonfungiblePositionManager = new ethers.utils.Interface(
+      INonfungiblePositionManager.abi
+    );
+    const liquidity = (await getUniswapV3Liquidity(tokenId, this))
+      .mul(amount)
+      .div(100);
+    const decreaseLiquidityTxData = iNonfungiblePositionManager.encodeFunctionData(
+      Transaction.DECREASE_LIQUIDITY,
+      [[tokenId, liquidity, 0, 0, deadline]]
+    );
+    const collectTxData = iNonfungiblePositionManager.encodeFunctionData(
+      Transaction.COLLECT,
+      [[tokenId, this.address, MaxUint128, MaxUint128]]
+    );
+
+    const multicallParams = [decreaseLiquidityTxData, collectTxData];
+
+    if (amount === 100) {
+      const burnTxData = iNonfungiblePositionManager.encodeFunctionData(
+        Transaction.BURN,
+        [tokenId]
+      );
+      multicallParams.push(burnTxData);
+    }
+    const multicallTxData = iNonfungiblePositionManager.encodeFunctionData(
+      Transaction.MULTI_CALL,
+      [multicallParams]
+    );
+    const tx = await this.poolLogic.execTransaction(
+      nonfungiblePositionManagerAddress[this.network],
+      multicallTxData,
+      options
+    );
+    return tx;
+  }
+
+  /**
+   * Increase liquidity of an UniswapV3 liquidity pool
+   * @param {string} tokenId Token Id of UniswapV3 position
+   * @param {BigNumber | string} amountA Amount first asset
+   * @param {BigNumber | string} amountB Amount second asset
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async increaseLiquidityUniswapV3(
+    tokenId: string,
+    amountA: BigNumber | string,
+    amountB: BigNumber | string,
+    options: any = null
+  ): Promise<any> {
+    const iNonfungiblePositionManager = new ethers.utils.Interface(
+      INonfungiblePositionManager.abi
+    );
+    const increaseLiquidityTxData = iNonfungiblePositionManager.encodeFunctionData(
+      Transaction.INCREASE_LIQUIDITY,
+      [[tokenId, amountA, amountB, 0, 0, deadline]]
+    );
+    const tx = await this.poolLogic.execTransaction(
+      nonfungiblePositionManagerAddress[this.network],
+      increaseLiquidityTxData,
+      options
+    );
+    return tx;
+  }
+
+  /**
+   * Claim fees of an UniswapV3 liquidity pool
+   * @param {string} tokenId Token Id of UniswapV3 position
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async claimFeesUniswapV3(tokenId: string, options: any = null): Promise<any> {
+    const iNonfungiblePositionManager = new ethers.utils.Interface(
+      INonfungiblePositionManager.abi
+    );
+    const collectTxData = iNonfungiblePositionManager.encodeFunctionData(
+      Transaction.COLLECT,
+      [[tokenId, this.address, MaxUint128, MaxUint128]]
+    );
+    const tx = await this.poolLogic.execTransaction(
+      nonfungiblePositionManagerAddress[this.network],
+      collectTxData,
+      options
+    );
+    return tx;
+  }
+
+  /**
+   * Trade an asset into another asset
+   * @param {Dapp} dapp Platform like Sushiswap or Uniswap
+   * @param {string} assetFrom Asset to trade from
+   * @param {string} assetTo Asset to trade into
+   * @param {BigNumber | string} amountIn Amount
+   * @param { FeeAmount } feeAmount Fee tier (Low 0.05%, Medium 0.3%, High 1%)
+   * @param {number} slippage Slippage tolerance in %
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async tradeUniswapV3(
+    assetFrom: string,
+    assetTo: string,
+    amountIn: BigNumber | string,
+    feeAmount: FeeAmount,
+    slippage = 0.5,
+    options: any = null
+  ): Promise<any> {
+    const swapxData = await getUniswapV3SwapTxData(
+      this,
+      assetFrom,
+      assetTo,
+      amountIn,
+      slippage,
+      feeAmount
+    );
+    const tx = await this.poolLogic.execTransaction(
+      routerAddress[this.network][Dapp.UNISWAPV3],
+      swapxData,
+      options
+    );
+    return tx;
+  }
 }

package/src/entities/utils.ts

@@ -125,6 +125,18 @@ export class Utils {
     return balance;
   }
 
+  /**
+   * Returns the decimals of an asset (ERC20) token
+   * @param {string} asset string token address
+   * @returns { number } Balance of asset
+   */
+
+  async getDecimals(asset: string): Promise<number> {
+    const iERC20 = new ethers.Contract(asset, IERC20.abi, this.signer);
+    const decimals = await iERC20.decimals();
+    return decimals;
+  }
+
   /**
    * Return the minimum amount out for a trade between two assets
    * given the trade amount and slippage

package/src/services/uniswap/V3Liquidity.ts

@@ -0,0 +1,134 @@
+import { Price, Token } from "@uniswap/sdk-core";
+import {
+  encodeSqrtRatioX96,
+  FeeAmount,
+  nearestUsableTick,
+  priceToClosestTick,
+  TICK_SPACINGS,
+  TickMath
+} from "@uniswap/v3-sdk";
+import { ethers } from "ethers";
+import JSBI from "jsbi";
+import { Pool } from "../..";
+import {
+  networkChainIdMap,
+  nonfungiblePositionManagerAddress
+} from "../../config";
+import { UniswapV3MintParams } from "./types";
+import INonfungiblePositionManager from "../../abi/INonfungiblePositionManager.json";
+
+export function tryParsePrice(
+  baseToken: Token,
+  quoteToken: Token,
+  value: string
+): Price<Token, Token> {
+  const [whole, fraction] = value.split(".");
+
+  const decimals = fraction?.length ?? 0;
+  const withoutDecimals = JSBI.BigInt((whole ?? "") + (fraction ?? ""));
+
+  return new Price(
+    baseToken,
+    quoteToken,
+    JSBI.multiply(
+      JSBI.BigInt(10 ** decimals),
+      JSBI.BigInt(10 ** baseToken.decimals)
+    ),
+    JSBI.multiply(withoutDecimals, JSBI.BigInt(10 ** quoteToken.decimals))
+  );
+}
+
+export function tryParseTick(
+  baseToken: Token,
+  quoteToken: Token,
+  feeAmount: FeeAmount,
+  value: string
+): number {
+  const price = tryParsePrice(baseToken, quoteToken, value);
+
+  let tick: number;
+
+  // check price is within min/max bounds, if outside return min/max
+  const sqrtRatioX96 = encodeSqrtRatioX96(price.numerator, price.denominator);
+
+  if (JSBI.greaterThanOrEqual(sqrtRatioX96, TickMath.MAX_SQRT_RATIO)) {
+    tick = TickMath.MAX_TICK;
+  } else if (JSBI.lessThanOrEqual(sqrtRatioX96, TickMath.MIN_SQRT_RATIO)) {
+    tick = TickMath.MIN_TICK;
+  } else {
+    // this function is agnostic to the base, will always return the correct tick
+    tick = priceToClosestTick(price);
+  }
+
+  return nearestUsableTick(tick, TICK_SPACINGS[feeAmount]);
+}
+
+export async function getUniswapV3MintParams(
+  pool: Pool,
+  assetA: string,
+  assetB: string,
+  amountA: string | ethers.BigNumber,
+  amountB: string | ethers.BigNumber,
+  minPrice: number | null,
+  maxPrice: number | null,
+  minTick: number | null,
+  maxTick: number | null,
+  feeAmount: FeeAmount
+): Promise<UniswapV3MintParams> {
+  let tickLower = 0;
+  let tickUpper = 0;
+  const chainId = networkChainIdMap[pool.network];
+  const decimals = await Promise.all(
+    [assetA, assetB].map(asset => pool.utils.getDecimals(asset))
+  );
+  const tokenA = new Token(chainId, assetA, decimals[0]);
+  const tokenB = new Token(chainId, assetB, decimals[1]);
+  const [token0, token1] = tokenA.sortsBefore(tokenB)
+    ? [tokenA, tokenB]
+    : [tokenB, tokenA];
+  const invertPrice = !tokenA.equals(token0);
+
+  if (minPrice && maxPrice) {
+    tickLower = invertPrice
+      ? tryParseTick(token1, token0, feeAmount, maxPrice.toString())
+      : tryParseTick(token0, token1, feeAmount, minPrice.toString());
+    tickUpper = invertPrice
+      ? tryParseTick(token1, token0, feeAmount, minPrice.toString())
+      : tryParseTick(token0, token1, feeAmount, maxPrice.toString());
+  } else if (minTick && maxTick) {
+    tickLower = minTick;
+    tickUpper = maxTick;
+  }
+  const [amount0, amount1] = invertPrice
+    ? [amountB, amountA]
+    : [amountA, amountB];
+
+  const deadline = Math.floor(Date.now() / 1000) + 60 * 20;
+
+  return [
+    token0.address,
+    token1.address,
+    feeAmount,
+    tickLower,
+    tickUpper,
+    amount0,
+    amount1,
+    "0",
+    "0",
+    pool.address,
+    deadline
+  ];
+}
+
+export async function getUniswapV3Liquidity(
+  tokenId: string,
+  pool: Pool
+): Promise<ethers.BigNumber> {
+  const iNonfungiblePositionManager = new ethers.Contract(
+    nonfungiblePositionManagerAddress[pool.network],
+    INonfungiblePositionManager.abi,
+    pool.signer
+  );
+  const result = await iNonfungiblePositionManager.positions(tokenId);
+  return result.liquidity;
+}

package/src/services/uniswap/V3Trade.ts

@@ -0,0 +1,47 @@
+import { FeeAmount } from "@uniswap/v3-sdk";
+import { ethers } from "ethers";
+import { Pool } from "../..";
+
+import IUniswapV3Router from "../../abi/IUniswapV3Router.json";
+import IUniswapV3Quoter from "../../abi/IUniswapV3Quoter.json";
+import { UNISWAPV3_QUOTER_ADDRESS } from "../../config";
+
+export async function getUniswapV3SwapTxData(
+  pool: Pool,
+  assetA: string,
+  assetB: string,
+  amountIn: string | ethers.BigNumber,
+  slippage: number,
+  feeAmount: FeeAmount
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+): Promise<any> {
+  const quoterContract = new ethers.Contract(
+    UNISWAPV3_QUOTER_ADDRESS,
+    IUniswapV3Quoter.abi,
+    pool.signer
+  );
+
+  const quotedAmountOut: ethers.BigNumber = await quoterContract.callStatic.quoteExactInputSingle(
+    assetA,
+    assetB,
+    feeAmount,
+    amountIn.toString(),
+    0
+  );
+
+  const minAmountOut = quotedAmountOut.mul((100 - slippage) * 100).div(10000);
+
+  const iUniswapV3Router = new ethers.utils.Interface(IUniswapV3Router.abi);
+  const swapTx = iUniswapV3Router.encodeFunctionData("exactInputSingle", [
+    [
+      assetA,
+      assetB,
+      feeAmount,
+      pool.address,
+      amountIn.toString(),
+      minAmountOut.toString(),
+      0
+    ]
+  ]);
+  return swapTx;
+}

package/src/services/uniswap/types.ts

@@ -0,0 +1,16 @@
+import { FeeAmount } from "@uniswap/v3-sdk";
+import { ethers } from "ethers";
+
+export type UniswapV3MintParams = [
+  string,
+  string,
+  FeeAmount,
+  number,
+  number,
+  ethers.BigNumber | string,
+  ethers.BigNumber | string,
+  ethers.BigNumber | string,
+  ethers.BigNumber | string,
+  string,
+  number
+];

package/src/test/constants.ts

@@ -1,8 +1,12 @@
-export const USDC = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
+//export const USDC = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
+//Optimism
+export const USDC = "0x7F5c764cBc14f9669B88837ca1490cCa17c31607";
 export const USDT = "0xc2132D05D31c914a87C6611C10748AEb04B58e8F";
 export const DAI = "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063";
 export const TUSD = "0x2e1ad108ff1d8c782fcbbb89aad783ac49586756";
-export const WETH = "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619";
+//export const WETH = "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619";
+//Optimism
+export const WETH = "0x4200000000000000000000000000000000000006";
 export const WBTC = "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6";
 export const SUSHI = "0x0b3f868e0be5597d5db7feb59e1cadbb0fdda50a";
 export const WMATIC = "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270";
@@ -10,4 +14,4 @@ export const BAL = "0x9a71012B13CA4d3D0Cdc72A177DF3ef03b0E76A3";
 export const AMUSDC = "0x1a13f4ca1d028320a707d99520abfefca3998b7f";
 export const VDEBTWETH = "0xede17e9d79fc6f9ff9250d9eefbdb88cc18038b5";
 
-export const TEST_POOL = "0x3deeba9ca29e2dd98d32eed8dd559dac55014615";
+export const TEST_POOL = "0xf36f550907872faaa02477f791df3ce33fe38854";

package/src/test/pool.test.ts

@@ -15,7 +15,7 @@ jest.setTimeout(100000);
 
 describe("pool", () => {
   beforeAll(() => {
-    dhedge = new Dhedge(wallet, Network.POLYGON);
+    dhedge = new Dhedge(wallet, Network.OPTIMISM);
   });
 
   it("checks fund composition", async () => {

package/src/test/synthetix.test.ts

@@ -0,0 +1,34 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Dhedge } from "..";
+import { Dapp, Network } from "../types";
+import { TEST_POOL } from "./constants";
+//import { getTxOptions } from "./txOptions";
+
+import { wallet } from "./wallet";
+
+let dhedge: Dhedge;
+let options: any;
+jest.setTimeout(100000);
+
+describe("pool", () => {
+  beforeAll(async () => {
+    dhedge = new Dhedge(wallet, Network.OPTIMISM);
+    //options = await getTxOptions();
+    options = { gasLimit: "3000000" };
+  });
+
+  it("should swap sETH into sUSD on Synthetix", async () => {
+    const pool = await dhedge.loadPool(TEST_POOL);
+    const result = await pool.trade(
+      Dapp.SYNTHETIX,
+      "sETH",
+      "sUSD",
+      "1000000000000000",
+      undefined,
+      options
+    );
+
+    console.log(result);
+    expect(result).not.toBe(null);
+  });
+});

package/src/test/txOptions.ts

@@ -0,0 +1,15 @@
+import axios from "axios";
+import BigNumber from "bignumber.js";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const getTxOptions = async (): Promise<any> => {
+  const result = await axios("https://gasstation-mainnet.matic.network/v2");
+
+  return {
+    gasLimit: "3000000",
+    maxPriorityFeePerGas: new BigNumber(result.data.fast.maxPriorityFee)
+      .shiftedBy(9)
+      .toFixed(0),
+    maxFeePerGas: new BigNumber(result.data.fast.maxFee).shiftedBy(9).toFixed(0)
+  };
+};