@dhedge/v2-sdk 1.7.2 → 1.8.0

package/src/entities/pool.ts

@@ -9,14 +9,12 @@ 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 IArrakisV1RouterStaking from "../abi/IArrakisV1RouterStaking.json";
 import ILiquidityGaugeV4 from "../abi/ILiquidityGaugeV4.json";
 import IBalancerRewardsGauge from "../abi/IBalancerRewardsGauge.json";
 
 import {
-  deadline,
   MaxUint128,
   networkChainIdMap,
   nonfungiblePositionManagerAddress,
@@ -37,7 +35,6 @@ import {
 } from "../types";
 
 import { Utils } from "./utils";
-import { ClaimService } from "../services/claim-balancer/claim.service";
 import {
   getUniswapV3Liquidity,
   getUniswapV3MintParams
@@ -57,6 +54,11 @@ import {
 } from "../services/velodrome/staking";
 import { getLyraOptionTxData } from "../services/lyra/trade";
 import { getOptionPositions } from "../services/lyra/positions";
+import { getDeadline } from "../utils/deadline";
+import {
+  getFuturesChangePositionTxData,
+  getFuturesChangeMarginTxData
+} from "../services/futures";
 
 export class Pool {
   public readonly poolLogic: Contract;
@@ -286,7 +288,7 @@ export class Pool {
       case Dapp.ONEINCH:
         const chainId = networkChainIdMap[this.network];
         const protocols = await getOneInchProtocols(chainId);
-        const apiUrl = `https://api.1inch.exchange/v4.0/${chainId}/swap?fromTokenAddress=${assetFrom}&toTokenAddress=${assetTo}&amount=${amountIn.toString()}&fromAddress=${
+        const apiUrl = `https://api.1inch.exchange/v5.0/${chainId}/swap?fromTokenAddress=${assetFrom}&toTokenAddress=${assetTo}&amount=${amountIn.toString()}&fromAddress=${
           this.address
         }&destReceiver=${
           this.address
@@ -342,7 +344,7 @@ export class Pool {
           minAmountOut,
           [assetFrom, assetTo],
           this.address,
-          deadline
+          await getDeadline(this)
         ]);
     }
     const tx = await this.poolLogic.execTransaction(
@@ -374,7 +376,16 @@ 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, deadline]
+      [
+        assetA,
+        assetB,
+        amountA,
+        amountB,
+        0,
+        0,
+        this.address,
+        await getDeadline(this)
+      ]
     );
     const tx = await this.poolLogic.execTransaction(
       routerAddress[this.network][dapp],
@@ -403,7 +414,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, deadline]
+      [assetA, assetB, amount, 0, 0, this.address, await getDeadline(this)]
     );
     const tx = await this.poolLogic.execTransaction(
       routerAddress[this.network][dapp],
@@ -773,39 +784,6 @@ export class Pool {
     return tx;
   }
 
-  /**
-   * Claim rewards from Balancer pools
-   * @param {string[]} assets Array of tokens being claimed
-   * @param {any} options Transaction options
-   * @returns {Promise<any>} Transaction
-   */
-  async harvestBalancerRewards(options: any = null): Promise<any> {
-    const claimService = new ClaimService(this.network, this.signer);
-    const multiTokenPendingClaims = await claimService.getMultiTokensPendingClaims(
-      this.address
-    );
-    const tokens = multiTokenPendingClaims.map(
-      tokenPendingClaims => tokenPendingClaims.tokenClaimInfo.token
-    );
-    const claims = await claimService.multiTokenClaimRewards(
-      this.address,
-      multiTokenPendingClaims
-    );
-    const iBalancerMerkleOrchard = new ethers.utils.Interface(
-      IBalancerMerkleOrchard.abi
-    );
-    const harvestTxData = iBalancerMerkleOrchard.encodeFunctionData(
-      Transaction.CLAIM_DISTRIBIUTIONS,
-      [this.address, claims, tokens]
-    );
-    const tx = await this.poolLogic.execTransaction(
-      stakingAddress[this.network][Dapp.BALANCER],
-      harvestTxData,
-      options
-    );
-    return tx;
-  }
-
   /**
    * Claim rewards from Aave platform
    * @param {string[]} assets Aave tokens (deposit/debt) hold by pool
@@ -947,7 +925,7 @@ export class Pool {
         .div(1e6);
       const decreaseLiquidityTxData = abi.encodeFunctionData(
         Transaction.DECREASE_LIQUIDITY,
-        [[tokenId, liquidity, 0, 0, deadline]]
+        [[tokenId, liquidity, 0, 0, await getDeadline(this)]]
       );
       const collectTxData = abi.encodeFunctionData(Transaction.COLLECT, [
         [tokenId, this.address, MaxUint128, MaxUint128]
@@ -1009,7 +987,7 @@ export class Pool {
       dappAddress = nonfungiblePositionManagerAddress[this.network];
       const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
       txData = abi.encodeFunctionData(Transaction.INCREASE_LIQUIDITY, [
-        [tokenId, amountA, amountB, 0, 0, deadline]
+        [tokenId, amountA, amountB, 0, 0, await getDeadline(this)]
       ]);
     } else if (dapp === Dapp.ARRAKIS) {
       dappAddress = routerAddress[this.network][dapp];
@@ -1135,7 +1113,7 @@ export class Pool {
   ): Promise<any> {
     const tx = await this.poolLogic.execTransaction(
       routerAddress[this.network][Dapp.VELODROME],
-      getVelodromeAddLiquidityTxData(
+      await getVelodromeAddLiquidityTxData(
         this,
         assetA,
         assetB,
@@ -1166,7 +1144,13 @@ export class Pool {
   ): Promise<any> {
     const tx = await this.poolLogic.execTransaction(
       routerAddress[this.network][Dapp.VELODROME],
-      getVelodromeRemoveLiquidityTxData(this, assetA, assetB, amount, isStable),
+      await getVelodromeRemoveLiquidityTxData(
+        this,
+        assetA,
+        assetB,
+        amount,
+        isStable
+      ),
       options
     );
     return tx;
@@ -1225,4 +1209,44 @@ export class Pool {
   async getLyraPositions(market: LyraOptionMarket): Promise<LyraPosition[]> {
     return await getOptionPositions(this, market);
   }
+
+  /** Deposit or withdraws (negative amount) asset for Synthetix future margin trading
+   *
+   * @param {string} market Address of futures market
+   * @param {BigNumber | string } changeAmount Amount to increase/decrease margin
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async changeFuturesMargin(
+    market: string,
+    changeAmount: BigNumber | string,
+    options: any = null
+  ): Promise<any> {
+    const tx = await this.poolLogic.execTransaction(
+      market,
+      getFuturesChangeMarginTxData(changeAmount),
+      options
+    );
+    return tx;
+  }
+
+  /** Change position in Synthetix futures market (long/short)
+   *
+   * @param {string} market Address of futures market
+   * @param {BigNumber | string } changeAmount Negative for short, positive for long
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async changeFuturesPosition(
+    market: string,
+    changeAmount: BigNumber | string,
+    options: any = null
+  ): Promise<any> {
+    const tx = await this.poolLogic.execTransaction(
+      market,
+      getFuturesChangePositionTxData(changeAmount),
+      options
+    );
+    return tx;
+  }
 }

package/src/services/futures/constants.ts

@@ -0,0 +1,4 @@
+import { BigNumber } from "ethers";
+
+export const PRICE_IMPACT_DELTA = BigNumber.from("500000000000000000");
+export const FUTURES_TRACKING = "DHEDGE";

package/src/services/futures/index.ts

@@ -0,0 +1,2 @@
+export { getFuturesChangeMarginTxData } from "./margin";
+export { getFuturesChangePositionTxData } from "./trade";

package/src/services/futures/margin.ts

@@ -0,0 +1,10 @@
+import { ethers } from "../..";
+import ISynthetixFuturesMarketV2 from "../../abi/ISynthetixFuturesMarketV2.json";
+
+export function getFuturesChangeMarginTxData(
+  amount: ethers.BigNumber | string
+): string {
+  return new ethers.utils.Interface(
+    ISynthetixFuturesMarketV2.abi
+  ).encodeFunctionData("transferMargin", [amount]);
+}

package/src/services/futures/trade.ts

@@ -0,0 +1,15 @@
+import { ethers } from "../..";
+import { FUTURES_TRACKING, PRICE_IMPACT_DELTA } from "./constants";
+import ISynthetixFuturesMarketV2 from "../../abi/ISynthetixFuturesMarketV2.json";
+
+export function getFuturesChangePositionTxData(
+  amount: ethers.BigNumber | string
+): string {
+  return new ethers.utils.Interface(
+    ISynthetixFuturesMarketV2.abi
+  ).encodeFunctionData("submitOffchainDelayedOrderWithTracking", [
+    amount,
+    PRICE_IMPACT_DELTA,
+    ethers.utils.formatBytes32String(FUTURES_TRACKING)
+  ]);
+}

package/src/services/oneInch/protocols.ts

@@ -5,7 +5,7 @@ const excludedProtocols = ["OPTIMISM_PMM6"]; //Clipper
 export async function getOneInchProtocols(chainId: number): Promise<string> {
   try {
     const response = await axios.get(
-      `https://api.1inch.io/v4.0/${chainId}/liquidity-sources`
+      `https://api.1inch.io/v5.0/${chainId}/liquidity-sources`
     );
     const protocols = response.data.protocols.map((e: { id: string }) => e.id);
     const filteredProtocols = protocols.filter(

package/src/services/toros/easySwapper.ts

@@ -46,7 +46,8 @@ export async function getEasySwapperDepositQuote(
     torosAsset,
     investAsset,
     amountIn,
-    depositAsset
+    depositAsset,
+    true
   );
 }
 
@@ -109,7 +110,7 @@ export async function getEasySwapperTxData(
       depositAsset,
       amountIn
     );
-    return iDhedgeEasySwapper.encodeFunctionData("deposit", [
+    return iDhedgeEasySwapper.encodeFunctionData("depositWithCustomCooldown", [
       torosAsset,
       investAsset,
       amountIn,

package/src/services/uniswap/V3Liquidity.ts

@@ -16,6 +16,7 @@ import {
 } from "../../config";
 import { UniswapV3MintParams } from "./types";
 import INonfungiblePositionManager from "../../abi/INonfungiblePositionManager.json";
+import { getDeadline } from "../../utils/deadline";
 
 export function tryParsePrice(
   baseToken: Token,
@@ -103,8 +104,6 @@ export async function getUniswapV3MintParams(
     ? [amountB, amountA]
     : [amountA, amountB];
 
-  const deadline = Math.floor(Date.now() / 1000) + 60 * 20;
-
   return [
     token0.address,
     token1.address,
@@ -116,7 +115,7 @@ export async function getUniswapV3MintParams(
     "0",
     "0",
     pool.address,
-    deadline
+    await getDeadline(pool)
   ];
 }
 

package/src/services/velodrome/liquidity.ts

@@ -1,18 +1,18 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { BigNumber, ethers } from "ethers";
 import IVelodromeRouter from "../../abi/IVeldodromeRouter.json";
-import { deadline } from "../../config";
 import { Pool } from "../../entities";
 import { Transaction } from "../../types";
+import { getDeadline } from "../../utils/deadline";
 
-export function getVelodromeAddLiquidityTxData(
+export async function getVelodromeAddLiquidityTxData(
   pool: Pool,
   assetA: string,
   assetB: string,
   amountA: BigNumber | string,
   amountB: BigNumber | string,
   isStable: boolean
-): any {
+): Promise<any> {
   const iVelodromeRouter = new ethers.utils.Interface(IVelodromeRouter.abi);
   return iVelodromeRouter.encodeFunctionData(Transaction.ADD_LIQUIDITY, [
     assetA,
@@ -23,17 +23,17 @@ export function getVelodromeAddLiquidityTxData(
     "0",
     "0",
     pool.address,
-    deadline
+    await getDeadline(pool)
   ]);
 }
 
-export function getVelodromeRemoveLiquidityTxData(
+export async function getVelodromeRemoveLiquidityTxData(
   pool: Pool,
   assetA: string,
   assetB: string,
   amount: BigNumber | string,
   isStable: boolean
-): any {
+): Promise<any> {
   const iVelodromeRouter = new ethers.utils.Interface(IVelodromeRouter.abi);
   return iVelodromeRouter.encodeFunctionData(Transaction.REMOVE_LIQUIDITY, [
     assetA,
@@ -43,6 +43,6 @@ export function getVelodromeRemoveLiquidityTxData(
     "0",
     "0",
     pool.address,
-    deadline
+    await getDeadline(pool)
   ]);
 }

package/src/test/constants.ts

@@ -19,17 +19,42 @@
 // export const ETHBULL3X = "0x460b60565cb73845d56564384ab84bf84c13e47d";
 // export const BTCBEAR2X = "0x3dbce2c8303609c17aa23b69ebe83c2f5c510ada";
 
+import { ethers } from "ethers";
+import { Network } from "../types";
+
 //Optimism
 export const WETH = "0x4200000000000000000000000000000000000006";
 export const USDC = "0x7F5c764cBc14f9669B88837ca1490cCa17c31607";
 export const DAI = "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1";
 export const USDy = "0x1ec50880101022c11530a069690f5446d1464592";
 export const WBTC = "0x68f180fcCe6836688e9084f035309E29Bf0A2095";
-export const OP = "4200000000000000000000000000000000000042";
+export const OP = "0x4200000000000000000000000000000000000042";
 export const WSTETH = "0x1F32b1c2345538c0c6f582fCB022739c4A194Ebb";
 export const VEL = "0x3c8B650257cFb5f272f799F5e2b4e65093a11a05";
 export const SUSD = "0x8c6f28f2f1a3c87f0f938b96d27520d9751ec8d9";
+export const SETH = "0xE405de8F52ba7559f9df3C368500B6E6ae6Cee49";
 export const ARRAKIS_USDC_WETH_GAUGE =
   "0xb8888ea29e2f70ad62a3b69b1a1342720612a00d";
+export const KWENTA_ETH_PERP = "0xf86048dff23cf130107dfb4e6386f574231a5c65";
+export const KWENTA_ETH_PERP_V2 = "0x2b3bb4c683bfc5239b029131eef3b1d214478d93";
+
+export const TEST_POOL = {
+  [Network.POLYGON]: "0x699fd4d6eadb216704c7e355cfa0a12f51813163",
+  [Network.OPTIMISM]: "0x12573bfdf764ab9d52aca20e2827497a66829716"
+};
+
+export const CONTRACT_ADDRESS = {
+  [Network.POLYGON]: {
+    USDC: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
+    WETH: "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619",
+    WBTC: "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6"
+  },
+  [Network.OPTIMISM]: {
+    USDC: "0x7F5c764cBc14f9669B88837ca1490cCa17c31607",
+    SUSD: "0x8c6f28f2f1a3c87f0f938b96d27520d9751ec8d9",
+    WETH: "0x4200000000000000000000000000000000000006",
+    KWENTA_ETH_PERP_V2: "0x2b3bb4c683bfc5239b029131eef3b1d214478d93"
+  }
+};
 
-export const TEST_POOL = "0x3d45e539df0f9fa6015106a968d732a8f6c2a40b";
+export const MAX_AMOUNT = ethers.constants.MaxUint256;

package/src/test/futures.test.ts

@@ -0,0 +1,48 @@
+import { Dhedge, Pool } from "..";
+import { Network } from "../types";
+import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
+import { balanceDelta } from "./utils/token";
+import { wallet } from "./wallet";
+
+jest.setTimeout(100000);
+
+const network = Network.OPTIMISM;
+const perp = CONTRACT_ADDRESS[network].KWENTA_ETH_PERP_V2;
+
+describe("pool", () => {
+  let dhedge: Dhedge;
+  let pool: Pool;
+  beforeAll(async () => {
+    dhedge = new Dhedge(wallet, network);
+    pool = await dhedge.loadPool(TEST_POOL[network]);
+  });
+
+  it("deposits 50 sUSD margin into ETH future market", async () => {
+    const depositAmount = (50 * 1e18).toString();
+    await pool.changeFuturesMargin(perp, depositAmount);
+
+    const sUSDBalanceDelta = await balanceDelta(
+      pool.address,
+      CONTRACT_ADDRESS[network].SUSD,
+      pool.signer
+    );
+    expect(sUSDBalanceDelta.abs().toString()).toBe(depositAmount);
+  });
+
+  it("goes long ETH-PERP about 3x leverage", async () => {
+    //size 50*3/1600 (margin * leverage  / price)
+    const size = (0.09 * 1e18).toString();
+    const tx = await pool.changeFuturesPosition(perp, size);
+    expect(tx).not.toBe(null);
+  });
+
+  it("removes 20 sUSD margin from ETH future market", async () => {
+    await pool.changeFuturesMargin(perp, (-20 * 1e18).toString());
+    const sUSDBalanceDelta = await balanceDelta(
+      pool.address,
+      CONTRACT_ADDRESS[network].SUSD,
+      pool.signer
+    );
+    expect(sUSDBalanceDelta.gt(0));
+  });
+});

package/src/test/oneInch.test.ts

@@ -1,49 +1,45 @@
-import { Dhedge } from "..";
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { Dhedge, Pool } from "..";
+import { routerAddress } from "../config";
 import { Dapp, Network } from "../types";
-import { DAI, TEST_POOL, USDC } from "./constants";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import { allowanceDelta, balanceDelta } from "./utils/token";
 
 import { wallet } from "./wallet";
 
-let dhedge: Dhedge;
+// const network = Network.OPTIMISM;
+const network = Network.POLYGON;
+const USDC = CONTRACT_ADDRESS[network].USDC;
+const WETH = CONTRACT_ADDRESS[network].WETH;
 
+let dhedge: Dhedge;
+let pool: Pool;
 jest.setTimeout(100000);
 
-// const options = {
-//   gasLimit: 5000000,
-//   gasPrice: ethers.utils.parseUnits("35", "gwei")
-// };
-
 describe("pool", () => {
-  beforeAll(() => {
-    dhedge = new Dhedge(wallet, Network.OPTIMISM);
+  beforeAll(async () => {
+    dhedge = new Dhedge(wallet, network);
+    pool = await dhedge.loadPool(TEST_POOL[network]);
   });
 
-  // it("approves unlimited DAI on 1Inch", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(TEST_POOL);
-  //   try {
-  //     result = await pool.approve(
-  //       Dapp.ONEINCH,
-  //       DAI,
-  //       ethers.constants.MaxInt256
-  //     );
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
+  it("approves unlimited USDC on 1Inch", async () => {
+    await pool.approve(Dapp.ONEINCH, USDC, MAX_AMOUNT);
+    const usdcAllowanceDelta = await allowanceDelta(
+      pool.address,
+      USDC,
+      routerAddress[network]["1inch"]!,
+      pool.signer
+    );
+    await expect(usdcAllowanceDelta.gt(0));
+  });
 
-  it("trades 1 entire DAI balance into USDC on 1Inch", async () => {
-    let result;
-    const pool = await dhedge.loadPool(TEST_POOL);
-    try {
-      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);
-    }
-    expect(result).not.toBe(null);
+  it("trades 5 USDC into WETH on 1Inch", async () => {
+    await pool.trade(Dapp.ONEINCH, USDC, WETH, "5000000", 0.5);
+    const wethBalanceDelta = await balanceDelta(
+      pool.address,
+      WETH,
+      pool.signer
+    );
+    expect(wethBalanceDelta.gt(0));
   });
 });

package/src/test/pool.test.ts

@@ -1,103 +1,60 @@
-import { Dhedge } from "..";
-import { Network } from "../types";
-import { TEST_POOL } from "./constants";
-
+import { Dhedge, ethers, Pool } from "..";
+import { AssetEnabled, Network } from "../types";
+import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
+import { allowanceDelta, balanceDelta } from "./utils/token";
 import { wallet } from "./wallet";
 
 let dhedge: Dhedge;
+let pool: Pool;
 
 jest.setTimeout(100000);
 
-// const options = {
-//   gasLimit: 5000000,
-//   gasPrice: ethers.utils.parseUnits("35", "gwei")
-// };
+const network = Network.POLYGON;
 
 describe("pool", () => {
-  beforeAll(() => {
-    dhedge = new Dhedge(wallet, Network.OPTIMISM);
+  beforeAll(async () => {
+    dhedge = new Dhedge(wallet, network);
+    pool = await dhedge.loadPool(TEST_POOL[network]);
   });
 
   it("checks fund composition", async () => {
-    const pool = await dhedge.loadPool(TEST_POOL);
     const result = await pool.getComposition();
-    console.log(result);
     expect(result.length).toBeGreaterThan(0);
   });
 
-  // it("withdraws 1.00002975 fund tokens", async () => {
-  //   const pool = await dhedge.loadPool(myPool);
-  //   const result = await pool.withdraw("1000029750000000000");
-  //   expect(result).toBeGreaterThan(0);
-  // });
-
-  // it("approve USDC balance of User for Deposit", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.approveDeposit(usdt, ethers.constants.MaxUint256);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("deposit 0.1 USDC into Pool", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.deposit(usdc, depositAmountUsdc);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
-
-  // it("adds LpUSDCWETH/SUSHI/WMATIC to enabled assets", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   const newAssets: AssetEnabled[] = [
-  //     { asset: usdc, isDeposit: true },
-  //     { asset: weth, isDeposit: true },
-  //     { asset: usdt, isDeposit: true },
-  //     { asset: amusdc, isDeposit: false },
-  //     { asset: lpUsdcUsdt, isDeposit: false }
-  //   ];
-  //   try {
-  //     result = await pool.changeAssets(newAssets);
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
+  it("approves USDC balance of User for Deposit", async () => {
+    await pool.approveDeposit(
+      CONTRACT_ADDRESS[network].USDC,
+      ethers.constants.MaxUint256
+    );
+    const UsdcAllowanceDelta = await allowanceDelta(
+      pool.signer.address,
+      CONTRACT_ADDRESS[network].USDC,
+      pool.address,
+      pool.signer
+    );
+    expect(UsdcAllowanceDelta.gt(0));
+  });
 
-  // it("removes all assets except USDC and USDT", async () => {
-  //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
-  //   const newAssets: AssetEnabled[] = [
-  //     { asset: usdc, isDeposit: false },
-  //     { asset: weth, isDeposit: true }
-  //   ];
-  //   try {
-  //     result = await pool.changeAssets(newAssets);
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
+  it("deposits 1 USDC into Pool", async () => {
+    await pool.deposit(CONTRACT_ADDRESS[network].USDC, (1e6).toString());
+    const poolTokenDelta = await balanceDelta(
+      pool.signer.address,
+      pool.address,
+      pool.signer
+    );
+    expect(poolTokenDelta.gt(0));
+  });
 
-  // it("sets a trader account", async () => {
-  //   let result;
-  //   const newTrader = "0xC52D9a9D9b05a01887871216fF02bA4235e8503d";
-  //   const pool = await dhedge.loadPool(myPool);
-  //   try {
-  //     result = await pool.setTrader(newTrader);
-  //     console.log(result);
-  //   } catch (e) {
-  //     console.log(e);
-  //   }
-  //   expect(result).not.toBe(null);
-  // });
+  it("adds WBTC to enabled assets", async () => {
+    const assetsBefore = await pool.getComposition();
+    const newAssets: AssetEnabled[] = [
+      { asset: CONTRACT_ADDRESS[network].USDC, isDeposit: true },
+      { asset: CONTRACT_ADDRESS[network].WETH, isDeposit: false },
+      { asset: CONTRACT_ADDRESS[network].WBTC, isDeposit: false }
+    ];
+    await pool.changeAssets(newAssets);
+    const assetsAfter = await pool.getComposition();
+    expect(assetsAfter.length).toBeGreaterThan(assetsBefore.length);
+  });
 });