@dhedge/v2-sdk 1.1.1 → 1.3.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

@@ -0,0 +1,73 @@
+import { Dhedge, ethers } from "..";
+import { Network } from "../types";
+import { AMUSDC, TEST_POOL, VDEBTWETH } from "./constants";
+
+import { wallet } from "./wallet";
+
+let dhedge: Dhedge;
+
+jest.setTimeout(100000);
+
+const options = {
+  gasLimit: 5000000,
+  gasPrice: ethers.utils.parseUnits("100", "gwei")
+};
+
+describe("pool", () => {
+  beforeAll(() => {
+    dhedge = new Dhedge(wallet, Network.POLYGON);
+  });
+
+  // it("withdraws 1 USDC from Aave lending pool", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(myPool);
+  //   try {
+  //     result = await pool.withdrawDeposit(
+  //       Dapp.AAVE,
+  //       weth,
+  //       "86567951006165",
+  //       options
+  //     );
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("borrows 0.0001 WETH from Aave lending pool", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(myPool);
+  //   try {
+  //     result = await pool.borrow(Dapp.AAVE, weth, "100000000000000");
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("reapys 0.0001 WETH to Aave lending pool", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(myPool);
+  //   try {
+  //     result = await pool.repay(Dapp.AAVE, weth, "100000000000000", options);
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   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);
+  });
+});

package/src/test/balancer.test.ts

@@ -0,0 +1,109 @@
+import { Dhedge, ethers } from "..";
+import { Network } from "../types";
+import { TEST_POOL } from "./constants";
+
+import { wallet } from "./wallet";
+
+let dhedge: Dhedge;
+
+jest.setTimeout(100000);
+
+const options = {
+  gasLimit: 2000000,
+  gasPrice: ethers.utils.parseUnits("1000", "gwei")
+};
+
+describe("pool", () => {
+  beforeAll(() => {
+    dhedge = new Dhedge(wallet, Network.POLYGON);
+  });
+
+  // it("approves unlimited USDC on Balancer", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     result = await pool.approve(
+  //       Dapp.BALANCER,
+  //       USDC,
+  //       ethers.constants.MaxInt256,
+  //       options
+  //     );
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("trades 2 USDC into SUSHI on Balancer", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(myPool);
+  //   try {
+  //     result = await pool.trade(
+  //       Dapp.BALANCER,
+  //       usdc,
+  //       sushi,
+  //       "2000000",
+  //       0.5,
+  //       options
+  //     );
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("adds 1 USDC to a USDC/TUSD/DAI/USDT balancer pool", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   const assets = [USDC, TUSD, DAI, USDT];
+  //   const amounts = ["1000000", "0", "0", "0"];
+  //   try {
+  //     result = await pool.joinBalancerPool(
+  //       "0x0d34e5dd4d8f043557145598e4e2dc286b35fd4f000000000000000000000068",
+  //       assets,
+  //       amounts,
+  //       options
+  //     );
+  //     console.log("result", result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  // it("exits entire balance of WBTC/USDC/WETH balancer pool", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(myPool);
+  //   const assets = [wbtc, usdc, weth];
+  //   const amount = await dhedge.utils.getBalance(
+  //     "0x03cd191f589d12b0582a99808cf19851e468e6b5",
+  //     pool.address
+  //   );
+  //   try {
+  //     result = await pool.exitBalancerPool(
+  //       "0x03cd191f589d12b0582a99808cf19851e468e6b500010000000000000000000a",
+  //       assets,
+  //       amount,
+  //       options
+  //     );
+  //     console.log("result", result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  it("claims balancer rewards", async () => {
+    let result;
+    const pool = await dhedge.loadPool(TEST_POOL);
+    try {
+      result = await pool.harvestBalancerRewards(options);
+      console.log("result", result);
+    } catch (e) {
+      console.log(e);
+    }
+    expect(result).not.toBe(null);
+  });
+});

package/src/test/constants.ts

@@ -0,0 +1,17 @@
+//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";
+//Optimism
+export const WETH = "0x4200000000000000000000000000000000000006";
+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 TEST_POOL = "0xf36f550907872faaa02477f791df3ce33fe38854";

package/src/test/oneInch.test.ts

@@ -0,0 +1,56 @@
+import { Dhedge, ethers } from "..";
+import { Dapp, Network } from "../types";
+import { TEST_POOL, USDC, WETH } from "./constants";
+
+import { wallet } from "./wallet";
+
+let dhedge: Dhedge;
+
+jest.setTimeout(100000);
+
+const options = {
+  gasLimit: 5000000,
+  gasPrice: ethers.utils.parseUnits("35", "gwei")
+};
+
+describe("pool", () => {
+  beforeAll(() => {
+    dhedge = new Dhedge(wallet, Network.POLYGON);
+  });
+
+  // it("approves unlimited USDC on 1Inch", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     result = await pool.approve(
+  //       Dapp.ONEINCH,
+  //       USDC,
+  //       ethers.constants.MaxInt256,
+  //       options
+  //     );
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
+  it("trades 1 USDC into WETH 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
+      );
+      console.log("1inch trade", result);
+    } catch (e) {
+      console.log(e);
+    }
+    expect(result).not.toBe(null);
+  });
+});