@dhedge/v2-sdk 1.2.0 → 1.4.0

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/aave.test.ts

@@ -1,6 +1,6 @@
-import { Dhedge, ethers } from "..";
-import { Network } from "../types";
-import { AMUSDC, TEST_POOL, VDEBTWETH } from "./constants";
+import { Dhedge } from "..";
+import { Dapp, Network } from "../types";
+import { TEST_POOL, WETH } from "./constants";
 
 import { wallet } from "./wallet";
 
@@ -8,16 +8,32 @@ let dhedge: Dhedge;
 
 jest.setTimeout(100000);
 
-const options = {
-  gasLimit: 5000000,
-  gasPrice: ethers.utils.parseUnits("100", "gwei")
-};
+// const options = {
+//   gasLimit: 5000000,
+//   gasPrice: ethers.utils.parseUnits("100", "gwei")
+// };
 
 describe("pool", () => {
   beforeAll(() => {
-    dhedge = new Dhedge(wallet, Network.POLYGON);
+    dhedge = new Dhedge(wallet, Network.OPTIMISM);
   });
 
+  // it("approves USDC to Aave", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     result = await pool.approve(
+  //       Dapp.AAVEV3,
+  //       USDC,
+  //       ethers.constants.MaxUint256
+  //     );
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
   // it("withdraws 1 USDC from Aave lending pool", async () => {
   //   let result;
   //   const pool = await dhedge.loadPool(myPool);
@@ -35,11 +51,23 @@ describe("pool", () => {
   //   expect(result).not.toBe(null);
   // });
 
-  // it("borrows 0.0001 WETH from Aave lending pool", async () => {
+  it("borrows 0.001 WETH from Aave lending pool", async () => {
+    let result;
+    const pool = await dhedge.loadPool(TEST_POOL);
+    try {
+      result = await pool.borrow(Dapp.AAVEV3, WETH, "1000000000000000");
+      console.log(result);
+    } catch (e) {
+      console.log(e);
+    }
+    expect(result).not.toBe(null);
+  });
+
+  // it("reapys 1USDC to Aave lending pool", async () => {
   //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
+  //   const pool = await dhedge.loadPool(TEST_POOL);
   //   try {
-  //     result = await pool.borrow(Dapp.AAVE, weth, "100000000000000");
+  //     result = await pool.repay(Dapp.AAVEV3, USDC, "1380000");
   //     console.log(result);
   //   } catch (e) {
   //     console.log(e);
@@ -47,11 +75,11 @@ describe("pool", () => {
   //   expect(result).not.toBe(null);
   // });
 
-  // it("reapys 0.0001 WETH to Aave lending pool", async () => {
+  // it("claims rewards from Aave", async () => {
   //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
+  //   const pool = await dhedge.loadPool(TEST_POOL);
   //   try {
-  //     result = await pool.repay(Dapp.AAVE, weth, "100000000000000", options);
+  //     result = await pool.harvestAaveRewards([AMUSDC, VDEBTWETH], options);
   //     console.log(result);
   //   } catch (e) {
   //     console.log(e);
@@ -59,15 +87,15 @@ describe("pool", () => {
   //   expect(result).not.toBe(null);
   // });
 
-  it("claims rewards from Aave", async () => {
-    let result;
-    const pool = await dhedge.loadPool(TEST_POOL);
-    try {
-      result = await pool.harvestAaveRewards([AMUSDC, VDEBTWETH], options);
-      console.log(result);
-    } catch (e) {
-      console.log(e);
-    }
-    expect(result).not.toBe(null);
-  });
+  // it("lends USDC to Aave", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     const balance = await dhedge.utils.getBalance(WETH, pool.address);
+  //     result = await pool.lend(Dapp.AAVEV3, WETH, balance, 196);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
 });

package/src/test/arrakis.test.ts

@@ -0,0 +1,89 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Dhedge } from "..";
+import { Dapp, Network } from "../types";
+import { ARRAKIS_USDC_WETH_GAUGE, TEST_POOL } from "./constants";
+import { getTxOptions } from "./txOptions";
+//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.POLYGON);
+    options = await getTxOptions();
+  });
+
+  // it("approves unlimited WETH on  Arrakis", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     result = await pool.approve(
+  //       Dapp.ARRAKIS,
+  //       USDC,
+  //       ethers.constants.MaxInt256,
+  //       options
+  //     );
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("should add liquidity and stake in an WETH/USDC Arrakis pool", async () => {
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   const result = await pool.increaseLiquidity(
+  //     Dapp.ARRAKIS,
+  //     "0x33d1ad9Cd88A509397CD924C2d7613C285602C20",
+  //     "776000",
+  //     "470000000000000",
+  //     options
+  //   );
+  //   console.log("result", result);
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("approves unlimited LP staking Token before on  Arrakis", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     result = await pool.approve(
+  //       Dapp.ARRAKIS,
+  //       ARRAKIS_USDC_WETH_GAUGE,
+  //       ethers.constants.MaxInt256,
+  //       options
+  //     );
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  it("should remove liquidity from an existing pool ", async () => {
+    const pool = await dhedge.loadPool(TEST_POOL);
+    const result = await pool.decreaseLiquidity(
+      Dapp.ARRAKIS,
+      ARRAKIS_USDC_WETH_GAUGE,
+      100,
+      options
+    );
+    console.log("result", result);
+    expect(result).not.toBe(null);
+  });
+
+  // it("should claim fees an existing pool", async () => {
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   const result = await pool.claimFees(
+  //     Dapp.ARRAKIS,
+  //     ARRAKIS_USDC_WETH_GAUGE,
+  //     options
+  //   );
+  //   console.log("result", result);
+  //   expect(result).not.toBe(null);
+  // });
+});

package/src/test/constants.ts

@@ -1,13 +1,21 @@
+//Polygon
 export const USDC = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
+export const WETH = "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619";
 export const USDT = "0xc2132D05D31c914a87C6611C10748AEb04B58e8F";
 export const DAI = "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063";
 export const TUSD = "0x2e1ad108ff1d8c782fcbbb89aad783ac49586756";
-export const WETH = "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619";
 export const WBTC = "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6";
 export const SUSHI = "0x0b3f868e0be5597d5db7feb59e1cadbb0fdda50a";
 export const WMATIC = "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270";
 export const BAL = "0x9a71012B13CA4d3D0Cdc72A177DF3ef03b0E76A3";
 export const AMUSDC = "0x1a13f4ca1d028320a707d99520abfefca3998b7f";
 export const VDEBTWETH = "0xede17e9d79fc6f9ff9250d9eefbdb88cc18038b5";
+export const ARRAKIS_USDC_WETH_GAUGE =
+  "0x33d1ad9Cd88A509397CD924C2d7613C285602C20";
+
+//Optimism
+// export const WETH = "0x4200000000000000000000000000000000000006";
+// export const USDC = "0x7F5c764cBc14f9669B88837ca1490cCa17c31607";
+// export const DAI = "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1";
 
-export const TEST_POOL = "0x3deeba9ca29e2dd98d32eed8dd559dac55014615";
+export const TEST_POOL = "TEST_POOL_ADDRESS";

package/src/test/oneInch.test.ts

@@ -1,6 +1,6 @@
-import { Dhedge, ethers } from "..";
+import { Dhedge } from "..";
 import { Dapp, Network } from "../types";
-import { TEST_POOL, USDC, WETH } from "./constants";
+import { DAI, TEST_POOL, USDC } from "./constants";
 
 import { wallet } from "./wallet";
 
@@ -8,25 +8,24 @@ let dhedge: Dhedge;
 
 jest.setTimeout(100000);
 
-const options = {
-  gasLimit: 5000000,
-  gasPrice: ethers.utils.parseUnits("35", "gwei")
-};
+// const options = {
+//   gasLimit: 5000000,
+//   gasPrice: ethers.utils.parseUnits("35", "gwei")
+// };
 
 describe("pool", () => {
   beforeAll(() => {
-    dhedge = new Dhedge(wallet, Network.POLYGON);
+    dhedge = new Dhedge(wallet, Network.OPTIMISM);
   });
 
-  // it("approves unlimited USDC on 1Inch", async () => {
+  // it("approves unlimited DAI on 1Inch", async () => {
   //   let result;
   //   const pool = await dhedge.loadPool(TEST_POOL);
   //   try {
   //     result = await pool.approve(
   //       Dapp.ONEINCH,
-  //       USDC,
-  //       ethers.constants.MaxInt256,
-  //       options
+  //       DAI,
+  //       ethers.constants.MaxInt256
   //     );
   //     console.log(result);
   //   } catch (e) {
@@ -35,18 +34,12 @@ describe("pool", () => {
   //   expect(result).not.toBe(null);
   // });
 
-  it("trades 1 USDC into WETH on 1Inch", async () => {
+  it("trades 1 entire DAI balance into USDC on 1Inch", async () => {
     let result;
     const pool = await dhedge.loadPool(TEST_POOL);
     try {
-      result = await pool.trade(
-        Dapp.ONEINCH,
-        USDC,
-        WETH,
-        "1000000",
-        0.5,
-        options
-      );
+      const balance = await dhedge.utils.getBalance(DAI, pool.address);
+      result = await pool.trade(Dapp.ONEINCH, DAI, USDC, balance, 0.5);
       console.log("1inch trade", result);
     } catch (e) {
       console.log(e);

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)
+  };
+};

package/src/test/uniswap.test.ts

@@ -0,0 +1,125 @@
+/* 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.POLYGON);
+    options = await getTxOptions();
+    //options = { gasLimit: "3000000" };
+  });
+
+  // it("approves unlimited WETH on for UniswapV3 LP", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     result = await pool.approveUniswapV3Liquidity(
+  //       USDC,
+  //       ethers.constants.MaxInt256,
+  //       options
+  //     );
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("adds WETH and WBTC to a new V3 pool", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   const usdcBalance = await dhedge.utils.getBalance(USDC, pool.address);
+  //   const wethBalance = await dhedge.utils.getBalance(WETH, pool.address);
+
+  //   try {
+  //     result = await pool.addLiquidityUniswapV3(
+  //       USDC,
+  //       WETH,
+  //       usdcBalance,
+  //       wethBalance,
+  //       0.0003,
+  //       0.0004,
+  //       null,
+  //       null,
+  //       FeeAmount.LOW,
+  //       options
+  //     );
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  it("should remove liquidity from an existing pool ", async () => {
+    const pool = await dhedge.loadPool(TEST_POOL);
+    const result = await pool.decreaseLiquidity(
+      Dapp.UNISWAPV3,
+      "110507",
+      100,
+      options
+    );
+    console.log("result", result);
+    expect(result).not.toBe(null);
+  });
+
+  // it("should increase liquidity in an existing pool WETH/WBTC pool", async () => {
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   const result = await pool.increaseLiquidity(
+  //     Dapp.UNISWAPV3,
+  //     "110507",
+  //     "244838",
+  //     "258300000000000",
+  //     options
+  //   );
+  //   console.log("result", result);
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("should claim fees an existing pool", async () => {
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   const result = await pool.claimFeesUniswapV3("54929", options);
+  //   console.log("result", result);
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("approves unlimited USDC to swap on UniswapV3", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     result = await pool.approve(
+  //       Dapp.UNISWAPV3,
+  //       USDC,
+  //       ethers.constants.MaxInt256,
+  //       options
+  //     );
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("should swap USDC into WETH on UniswapV3 pool", async () => {
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   const result = await pool.tradeUniswapV3(
+  //     USDC,
+  //     WETH,
+  //     "1000000",
+  //     FeeAmount.LOW,
+  //     1,
+  //     options
+  //   );
+
+  //   console.log(result);
+  //   expect(result).not.toBe(null);
+  // });
+});

package/src/test/wallet.ts

@@ -3,6 +3,10 @@ import { ethers } from "ethers";
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 require("dotenv").config();
 
+// const provider = new ethers.providers.JsonRpcProvider(
+//   `https://opt-mainnet.g.alchemy.com/v2/${process.env.ALCHEMY_PROJECT_ID}`
+// );
+
 const provider = new ethers.providers.JsonRpcProvider(
   `https://polygon-mainnet.infura.io/v3/${process.env.INFURA_PROJECT_ID}`
 );