@dhedge/v2-sdk 1.7.2 → 1.8.0

package/src/test/toros.test.ts

@@ -1,117 +1,69 @@
-import { Dhedge, ethers } from "..";
-import {
-  getEasySwapperDepositQuote,
-  getEasySwapperWithdrawalQuote,
-  getPoolDepositAsset
-} from "../services/toros/easySwapper";
+/* 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 { BTCBEAR2X, ETHBULL3X, TEST_POOL, USDC, WBTC } from "./constants";
-import { getTxOptions } from "./txOptions";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import { allowanceDelta, balanceDelta } from "./utils/token";
 
 import { wallet } from "./wallet";
 
-let dhedge: Dhedge;
-let options: any;
+const ETHy = "0xb2cfb909e8657c0ec44d3dd898c1053b87804755";
+const network = Network.OPTIMISM;
+const SUSD = CONTRACT_ADDRESS[network].SUSD;
 
+let dhedge: Dhedge;
+let pool: Pool;
 jest.setTimeout(100000);
 
 describe("pool", () => {
   beforeAll(async () => {
-    dhedge = new Dhedge(wallet, Network.POLYGON);
-    options = await getTxOptions(Network.POLYGON);
+    dhedge = new Dhedge(wallet, network);
+    pool = await dhedge.loadPool(TEST_POOL[network]);
   });
 
-  it("gets Deposit Quote for ETHBULL3X invest with USDC", async () => {
-    let result;
-    const pool = await dhedge.loadPool(ETHBULL3X);
-    try {
-      const depositAsset = await getPoolDepositAsset(pool, ETHBULL3X, USDC);
-      if (!depositAsset) throw new Error("no deposit assets");
-
-      result = await getEasySwapperDepositQuote(
-        pool,
-        pool.address,
-        USDC,
-        depositAsset,
-        ethers.BigNumber.from("100000000")
-      );
-      console.log("deposit quote", result.toString());
-    } catch (e) {
-      console.log(e);
-    }
-    expect(result).not.toBe(null);
+  it("approves unlimited ETHy on Toros (Easyswapper)", async () => {
+    await pool.approve(Dapp.TOROS, ETHy, MAX_AMOUNT);
+    const ETHyAllowanceDelta = await allowanceDelta(
+      pool.address,
+      ETHy,
+      routerAddress[network].toros!,
+      pool.signer
+    );
+    expect(ETHyAllowanceDelta.gt(0));
   });
 
-  it("gets withdrawal Quote for BTCBEAR2X sell for WBTC", async () => {
-    let result;
-    const pool = await dhedge.loadPool(BTCBEAR2X);
-    try {
-      result = await getEasySwapperWithdrawalQuote(
-        pool,
-        pool.address,
-        WBTC,
-        ethers.BigNumber.from("9751590099507644982205")
-      );
-      console.log("withdrawal quote", result.toString());
-    } catch (e) {
-      console.log(e);
-    }
-    expect(result).not.toBe(null);
+  it("sell ETHy to SUSD on Toros", async () => {
+    const ETHyBalance = await pool.utils.getBalance(ETHy, pool.address);
+    await pool.trade(Dapp.TOROS, ETHy, SUSD, ETHyBalance, 3);
+    const ETHyBalanceDelta = await balanceDelta(
+      pool.address,
+      SUSD,
+      pool.signer
+    );
+    expect(ETHyBalanceDelta.lt(0));
   });
 
-  it("approves unlimited ETHBULL3X on Easyswapper", async () => {
-    let result;
-    const pool = await dhedge.loadPool(TEST_POOL);
-    try {
-      result = await pool.approve(
-        Dapp.TOROS,
-        ETHBULL3X,
-        ethers.constants.MaxInt256,
-        options
-      );
-      console.log(result);
-    } catch (e) {
-      console.log(e);
-    }
-    expect(result).not.toBe(null);
+  it("approves unlimited sUSD on Toros (Easyswapper)", async () => {
+    await pool.approve(Dapp.TOROS, SUSD, MAX_AMOUNT, { gasLimit: "3000000" });
+    const sUSDAllowanceDelta = await allowanceDelta(
+      pool.address,
+      SUSD,
+      routerAddress[network].toros!,
+      pool.signer
+    );
+    expect(sUSDAllowanceDelta.gt(0));
   });
 
-  // it("buys ETHBULL3X for 1 USDC", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(TEST_POOL);
-  //   try {
-  //     result = await pool.trade(
-  //       Dapp.TOROS,
-  //       USDC,
-  //       ETHBULL3X,
-  //       "1000000",
-  //       0.5,
-  //       options
-  //     );
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  it("sells ETHBULL3X balance for USDC", async () => {
-    let result;
-    const pool = await dhedge.loadPool(TEST_POOL);
-    const balance = await pool.utils.getBalance(ETHBULL3X, pool.address);
-    try {
-      result = await pool.trade(
-        Dapp.TOROS,
-        ETHBULL3X,
-        USDC,
-        balance,
-        3,
-        options
-      );
-      console.log(result);
-    } catch (e) {
-      console.log(e);
-    }
-    expect(result).not.toBe(null);
+  it("buys ETHy for 3 sUSD", async () => {
+    await pool.trade(Dapp.TOROS, SUSD, ETHy, (3 * 10e18).toString(), 3, {
+      gasLimit: "3000000"
+    });
+    const ETHyBalanceDelta = await balanceDelta(
+      pool.address,
+      ETHy,
+      pool.signer
+    );
+    expect(ETHyBalanceDelta.gt(0));
   });
 });

package/src/test/uniswap.test.ts

@@ -1,35 +1,70 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Dhedge } from "..";
+import { FeeAmount } from "@uniswap/v3-sdk";
+import { Dhedge, ethers, Pool } from "..";
+import { routerAddress } from "../config";
 import { Dapp, Network } from "../types";
-import { TEST_POOL } from "./constants";
-import { getTxOptions } from "./txOptions";
+import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
+import { allowanceDelta, balanceDelta } from "./utils/token";
 
 import { wallet } from "./wallet";
 
 let dhedge: Dhedge;
-let options: any;
+let pool: Pool;
 jest.setTimeout(100000);
 
+const network = Network.POLYGON;
+
 describe("pool", () => {
   beforeAll(async () => {
-    dhedge = new Dhedge(wallet, Network.POLYGON);
-    options = await getTxOptions(Network.POLYGON);
-    //options = { gasLimit: "3000000" };
+    dhedge = new Dhedge(wallet, network);
+    pool = await dhedge.loadPool(TEST_POOL[network]);
+  });
+
+  it("approves unlimited USDC on for trading on UniswapV3", async () => {
+    await pool.approve(
+      Dapp.UNISWAPV3,
+      CONTRACT_ADDRESS[network].USDC,
+      ethers.constants.MaxUint256
+    );
+    const UsdcAllowanceDelta = await allowanceDelta(
+      pool.address,
+      CONTRACT_ADDRESS[network].USDC,
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      routerAddress[network].uniswapV3!,
+      pool.signer
+    );
+    expect(UsdcAllowanceDelta.gte(0));
+  });
+
+  it("should swap 5 USDC into WETH on UniswapV3", async () => {
+    await pool.tradeUniswapV3(
+      CONTRACT_ADDRESS[network].USDC,
+      CONTRACT_ADDRESS[network].WETH,
+      "5000000",
+      FeeAmount.LOW,
+      0.5
+    );
+
+    const wethAllowanceDelta = await balanceDelta(
+      pool.address,
+      CONTRACT_ADDRESS[network].WETH,
+      pool.signer
+    );
+    expect(wethAllowanceDelta.gt(0));
   });
 
   // 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);
-  //   }
+  //   await pool.approveUniswapV3Liquidity(
+  //     CONTRACT_ADDRESS[network].USDC,
+  //     ethers.constants.MaxInt256
+  //   );
+  //   const UsdcAllowanceDelta = await allowanceDelta(
+  //     pool.address,
+  //     CONTRACT_ADDRESS[network].USDC,
+  //     pool.address,
+  //     pool.signer
+  //   );
+
   //   expect(result).not.toBe(null);
   // });
 
@@ -59,17 +94,17 @@ describe("pool", () => {
   //   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 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);

package/src/test/utils/token.ts

@@ -0,0 +1,31 @@
+import { BigNumber, Wallet, Contract } from "ethers";
+import IERC20 from "../../abi/IERC20.json";
+
+export const balanceDelta = async (
+  owner: string,
+  asset: string,
+  signer: Wallet
+): Promise<BigNumber> => {
+  const block = await signer.provider.getBlockNumber();
+  const iERC20 = new Contract(asset, IERC20.abi, signer);
+  const [balanceBefore, balanceAfter] = await Promise.all(
+    [block - 1, block].map(e => iERC20.balanceOf(owner, { blockTag: e }))
+  );
+  return balanceAfter.sub(balanceBefore);
+};
+
+export const allowanceDelta = async (
+  owner: string,
+  asset: string,
+  spender: string,
+  signer: Wallet
+): Promise<BigNumber> => {
+  const block = await signer.provider.getBlockNumber();
+  const iERC20 = new Contract(asset, IERC20.abi, signer);
+  const [allowanceBefore, allowanceAfter] = await Promise.all(
+    [block - 1, block].map(e =>
+      iERC20.allowance(owner, spender, { blockTag: e })
+    )
+  );
+  return allowanceAfter.sub(allowanceBefore);
+};

package/src/test/velodrome.test.ts

@@ -1,141 +1,114 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Dhedge, ethers } from "..";
+import { Dhedge, Pool } from "..";
+import { routerAddress } from "../config";
 import { Dapp, Network } from "../types";
-import { TEST_POOL, VEL, WETH, WSTETH } from "./constants";
-import { getTxOptions } from "./txOptions";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import { allowanceDelta, balanceDelta } from "./utils/token";
 
 import { wallet } from "./wallet";
 
-const wETHwstETHLp = "0xBf205335De602ac38244F112d712ab04CB59A498";
-const wETHwstETHGauge = "0x131Ae347E654248671Afc885F0767cB605C065d7";
+const USDC_SUSD_Lp = "0xd16232ad60188b68076a235c65d692090caba155";
+const USDC_SUSD_Gauge = "0xb03f52d2db3e758dd49982defd6aeefea9454e80";
+const network = Network.OPTIMISM;
+const SUSD = CONTRACT_ADDRESS[network].SUSD;
+const USDC = CONTRACT_ADDRESS[network].USDC;
 
 let dhedge: Dhedge;
-let options: any;
+let pool: Pool;
 jest.setTimeout(100000);
 
 describe("pool", () => {
   beforeAll(async () => {
-    dhedge = new Dhedge(wallet, Network.OPTIMISM);
-    options = await getTxOptions(Network.OPTIMISM);
+    dhedge = new Dhedge(wallet, network);
+    pool = await dhedge.loadPool(TEST_POOL[network]);
   });
 
-  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("approves unlimited sUSD and USDC on for Velodrome", async () => {
+    await pool.approve(Dapp.VELODROME, SUSD, MAX_AMOUNT);
+    await pool.approve(Dapp.VELODROME, USDC, MAX_AMOUNT);
+    const UsdcAllowanceDelta = await allowanceDelta(
+      pool.address,
+      USDC,
+      routerAddress[network].velodrome!,
+      pool.signer
+    );
+    await expect(UsdcAllowanceDelta.gt(0));
   });
 
-  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
+  it("adds USDC and SUSD to a Velodrome stable pool", async () => {
+    await pool.addLiquidityVelodrome(
+      USDC,
+      SUSD,
+      (5 * 1e6).toString(),
+      (5 * 1e18).toString(),
+      true
     );
 
-    result.wait(1);
-    const lpBalance = await dhedge.utils.getBalance(wETHwstETHLp, pool.address);
-    expect(lpBalance.gt(0));
+    const lpTokenDelta = await balanceDelta(
+      pool.address,
+      USDC_SUSD_Lp,
+      pool.signer
+    );
+    expect(lpTokenDelta.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
+  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.VELODROME, 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 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));
+    const tx = await pool.claimFees(Dapp.VELODROME, USDC_SUSD_Gauge);
+    expect(tx).not.toBe(null);
   });
 
-  it("should unStake wETH/wStETH LP from a gauge", async () => {
-    const pool = await dhedge.loadPool(TEST_POOL);
+  it("should unStake USDC-sUSD LP from a gauge", async () => {
     const gaugeBalance = await dhedge.utils.getBalance(
-      wETHwstETHGauge,
+      USDC_SUSD_Gauge,
       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
+    await pool.unstakeFromGauge(USDC_SUSD_Gauge, gaugeBalance);
+    const lpTokenDelta = await balanceDelta(
+      pool.address,
+      USDC_SUSD_Lp,
+      pool.signer
     );
-    expect(gaugeBalanceAfter.eq(0));
+    expect(lpTokenDelta.gt(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);
+    await pool.approve(Dapp.VELODROME, 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 pool = await dhedge.loadPool(TEST_POOL);
-    const balance = await dhedge.utils.getBalance(wETHwstETHLp, pool.address);
-    const result = await pool.removeLiquidityVelodrome(
-      WETH,
-      WSTETH,
-      balance,
-      options
+    const balance = await dhedge.utils.getBalance(USDC_SUSD_Lp, pool.address);
+    await pool.removeLiquidityVelodrome(USDC, SUSD, balance, true);
+    const usdcBalanceDelta = await balanceDelta(
+      pool.address,
+      USDC,
+      pool.signer
     );
-    result.wait(1);
-    const balanceAfter = await dhedge.utils.getBalance(
-      wETHwstETHLp,
-      pool.address
+    const susdBalanceDelta = await balanceDelta(
+      pool.address,
+      SUSD,
+      pool.signer
     );
-    expect(balanceAfter.eq(0));
+    expect(usdcBalanceDelta.gt(0));
+    expect(susdBalanceDelta.gt(0));
   });
 });

package/src/test/wallet.ts

@@ -3,9 +3,9 @@ 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://opt-mainnet.g.alchemy.com/v2/${process.env.ALCHEMY_PROJECT_ID}`
+// );
 
 // const provider = new ethers.providers.JsonRpcProvider(
 //   `https://opt-kovan.g.alchemy.com/v2/${process.env.ALCHEMY_PROJECT_ID}`
@@ -19,6 +19,8 @@ const provider = new ethers.providers.JsonRpcProvider(
 //   `https://polygon-mainnet.infura.io/v3/${process.env.INFURA_PROJECT_ID}`
 // );
 
+const provider = new ethers.providers.JsonRpcProvider("http://127.0.0.1:8545/");
+
 export const wallet = new ethers.Wallet(
   process.env.PRIVATE_KEY as string,
   provider

package/src/utils/deadline.ts

@@ -0,0 +1,6 @@
+import { Pool } from "../entities";
+
+export const getDeadline = async (pool: Pool): Promise<number> => {
+  const timestamp = (await pool.signer.provider.getBlock("latest")).timestamp;
+  return timestamp + 60 * 20; //add 20 min
+};

package/dist/services/claim-balancer/claim.service.d.ts

@@ -1,17 +0,0 @@
-import { ethers, Wallet } from "ethers";
-import { MultiTokenPendingClaims, TokenClaimInfo } from "./types";
-import { Network } from "../../types";
-export declare class ClaimService {
-    network: Network;
-    signer: ethers.Wallet;
-    constructor(network: Network, signer: Wallet);
-    getMultiTokensPendingClaims(account: string): Promise<MultiTokenPendingClaims[]>;
-    getTokenPendingClaims(tokenClaimInfo: TokenClaimInfo, account: string): Promise<MultiTokenPendingClaims>;
-    multiTokenClaimRewards(account: string, multiTokenPendingClaims: MultiTokenPendingClaims[]): Promise<any>;
-    private computeClaimProofs;
-    private computeClaimProof;
-    private getTokenClaimsInfo;
-    private getSnapshot;
-    private getClaimStatus;
-    private getReports;
-}

package/dist/services/claim-balancer/claim.worker.d.ts

@@ -1,4 +0,0 @@
-import { ComputeClaimProofPayload } from "./types";
-export declare class ClaimWorker {
-    calcClaimProof(payload: ComputeClaimProofPayload): any;
-}

package/dist/services/claim-balancer/ipfs.service.d.ts

@@ -1,4 +0,0 @@
-export default class IpfsService {
-    get<T>(hash: string, protocol?: string): Promise<T>;
-}
-export declare const ipfsService: IpfsService;

package/dist/services/claim-balancer/types.d.ts

@@ -1,54 +0,0 @@
-export interface Claim {
-    id: string;
-    amount: string;
-}
-export declare type Snapshot = Record<number, string>;
-export declare type TokenClaimInfo = {
-    label: string;
-    distributor: string;
-    token: string;
-    decimals: number;
-    manifest: string;
-    weekStart: number;
-};
-export declare type MultiTokenPendingClaims = {
-    claims: Claim[];
-    reports: Report;
-    tokenClaimInfo: TokenClaimInfo;
-    availableToClaim: string;
-};
-export declare type ClaimStatus = boolean;
-export declare type Report = Record<string, any>;
-export declare type MultiTokenCurrentRewardsEstimateResponse = {
-    success: boolean;
-    result: {
-        current_timestamp: string;
-        "liquidity-providers": Array<{
-            snapshot_timestamp: string;
-            address: string;
-            token_address: string;
-            chain_id: number;
-            current_estimate: string;
-            velocity: string;
-            week: number;
-        }>;
-    };
-};
-export declare type MultiTokenCurrentRewardsEstimate = {
-    rewards: string;
-    velocity: string;
-    token: string;
-};
-export declare type ClaimProofTuple = [number, string, string, number, string[]];
-export declare type ComputeClaimProofPayload = {
-    report: Report;
-    account: string;
-    claim: Claim;
-    distributor: string;
-    tokenIndex: number;
-    decimals: number;
-};
-export declare type ClaimWorkerMessage<P = any> = {
-    type: "computeClaimProof";
-    payload: P;
-};