@dhedge/v2-sdk 1.10.4 → 1.10.6

package/src/services/oneInch/index.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import axios from "axios";
 import { ApiError, ethers } from "../..";
-import { networkChainIdMap } from "../../config";
+import { networkChainIdMap, routerAddress } from "../../config";
 import { Pool } from "../../entities";
 
 const oneInchBaseUrl = "https://api.1inch.dev/swap/v6.0/";
@@ -11,8 +11,9 @@ export async function getOneInchSwapTxData(
   assetFrom: string,
   assetTo: string,
   amountIn: ethers.BigNumber | string,
-  slippage: number
-): Promise<string> {
+  slippage: number,
+  forEasySwapper = false
+): Promise<{ swapTxData: string; dstAmount: string }> {
   if (!process.env.ONEINCH_API_KEY)
     throw new Error("ONEINCH_API_KEY not configured in .env file");
 
@@ -22,8 +23,8 @@ export async function getOneInchSwapTxData(
     src: assetFrom,
     dst: assetTo,
     amount: amountIn.toString(),
-    from: pool.address,
-    origin: pool.signer.address,
+    from: forEasySwapper ? routerAddress[pool.network].toros : pool.address,
+    receiver: forEasySwapper ? routerAddress[pool.network].toros : pool.address,
     slippage: slippage,
     disableEstimate: true,
     usePermit2: false
@@ -35,7 +36,9 @@ export async function getOneInchSwapTxData(
       },
       params
     });
-    return response.data.tx.data;
+    const swapTxData = response.data.tx.data;
+    const dstAmount = response.data.dstAmount;
+    return { swapTxData, dstAmount };
   } catch (e) {
     throw new ApiError("Swap api request of 1inch failed");
   }

package/src/services/ramses/vesting.ts

@@ -1,8 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { BigNumber, ethers } from "ethers";
 import IXRam from "../../abi/IXRam.json";
+import IRamsesNonfungiblePositionManager from "../../abi/IRamsesNonfungiblePositionManager.json";
 
 const iXRam = new ethers.utils.Interface(IXRam.abi);
+const iRamsesNonfungiblePositionManager = new ethers.utils.Interface(
+  IRamsesNonfungiblePositionManager
+);
 
 export function getCreateVestTxData(amount: BigNumber | string): string {
   return iXRam.encodeFunctionData("createVest", [amount]);
@@ -11,3 +15,10 @@ export function getCreateVestTxData(amount: BigNumber | string): string {
 export function getExitVestTxData(vestId: number): string {
   return iXRam.encodeFunctionData("exitVest", [vestId, false]);
 }
+
+export function getRewardsTxDta(tokenId: string, rewards: string[]): string {
+  return iRamsesNonfungiblePositionManager.encodeFunctionData("getReward", [
+    tokenId,
+    rewards
+  ]);
+}

package/src/services/toros/easySwapper.ts

@@ -5,6 +5,8 @@ import IDhedgeEasySwapper from "../../abi/IDhedgeEasySwapper.json";
 import { routerAddress } from "../../config";
 import { getChainlinkPriceInUsd } from "../chainLink/price";
 import { isPool, loadPool } from "./pool";
+import { getOneInchSwapTxData } from "../oneInch";
+import { wait } from "../../test/utils/testingHelper";
 
 export async function getPoolDepositAsset(
   pool: Pool,
@@ -33,22 +35,15 @@ export async function getEasySwapperDepositQuote(
   pool: Pool,
   torosAsset: string,
   investAsset: string,
-  depositAsset: string,
   amountIn: ethers.BigNumber
 ): Promise<ethers.BigNumber> {
   const easySwapper = new ethers.Contract(
     routerAddress[pool.network][Dapp.TOROS] as string,
-    IDhedgeEasySwapper.abi,
+    IDhedgeEasySwapper,
     pool.signer
   );
 
-  return await easySwapper.depositQuote(
-    torosAsset,
-    investAsset,
-    amountIn,
-    depositAsset,
-    true
-  );
+  return await easySwapper.depositQuote(torosAsset, investAsset, amountIn);
 }
 
 export async function getEasySwapperWithdrawalQuote(
@@ -82,19 +77,12 @@ export async function getEasySwapperTxData(
   const [torosAsset, investAsset] = isWithdrawal
     ? [assetFrom, assetTo]
     : [assetTo, assetFrom];
-  const iDhedgeEasySwapper = new ethers.utils.Interface(IDhedgeEasySwapper.abi);
+  const iDhedgeEasySwapper = new ethers.utils.Interface(IDhedgeEasySwapper);
   if (isWithdrawal) {
-    const minAmountOut = await getEasySwapperWithdrawalQuote(
-      pool,
-      torosAsset,
-      investAsset,
-      amountIn
-    );
-    return iDhedgeEasySwapper.encodeFunctionData("withdraw", [
+    return iDhedgeEasySwapper.encodeFunctionData("initWithdrawal", [
       torosAsset,
       amountIn,
-      investAsset,
-      minAmountOut.mul(10000 - slippage * 100).div(10000)
+      slippage * 100
     ]);
   } else {
     const depositAsset = await getPoolDepositAsset(
@@ -103,19 +91,73 @@ export async function getEasySwapperTxData(
       investAsset
     );
     if (!depositAsset) throw new Error("no deposit assets");
+    if (depositAsset.toLowerCase() !== investAsset.toLowerCase())
+      throw new Error("can only trade deposit asset");
     const minAmountOut = await getEasySwapperDepositQuote(
       pool,
       torosAsset,
       investAsset,
-      depositAsset,
       amountIn
     );
     return iDhedgeEasySwapper.encodeFunctionData("depositWithCustomCooldown", [
       torosAsset,
-      investAsset,
-      amountIn,
       depositAsset,
+      amountIn,
       minAmountOut.mul(10000 - slippage * 100).div(10000)
     ]);
   }
 }
+
+export async function getCompleteWithdrawalTxData(
+  pool: Pool,
+  destToken: string,
+  slippage: number
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+): Promise<string> {
+  const easySwapper = new ethers.Contract(
+    routerAddress[pool.network][Dapp.TOROS] as string,
+    IDhedgeEasySwapper,
+    pool.signer
+  );
+  const trackedAssets: {
+    token: string;
+    balance: ethers.BigNumber;
+  }[] = await easySwapper.getTrackedAssets(pool.address);
+  const trackedAssetsExcludingDestToken = trackedAssets.filter(
+    ({ token }) => token.toLowerCase() !== destToken.toLowerCase()
+  );
+
+  const srcData = [];
+  let minDestAmount = ethers.BigNumber.from(0);
+  for (const { token, balance } of trackedAssetsExcludingDestToken) {
+    const { swapTxData, dstAmount } = await getOneInchSwapTxData(
+      pool,
+      token,
+      destToken,
+      balance,
+      slippage,
+      true
+    );
+    srcData.push({
+      token,
+      amount: balance,
+      aggregatorData: {
+        routerKey: ethers.utils.formatBytes32String("ONE_INCH"),
+        swapData: swapTxData
+      }
+    });
+    minDestAmount = minDestAmount.add(dstAmount);
+    await wait(2);
+  }
+
+  return easySwapper.interface.encodeFunctionData("completeWithdrawal", [
+    {
+      srcData,
+      destData: {
+        destToken,
+        minDestAmount
+      }
+    },
+    minDestAmount.mul(10000 - slippage * 100).div(10000)
+  ]);
+}

package/src/services/uniswap/V3Liquidity.ts

@@ -19,6 +19,7 @@ import {
 } from "../../config";
 import INonfungiblePositionManager from "../../abi/INonfungiblePositionManager.json";
 import IVeldodromePositionManager from "../../abi/IVelodromeNonfungiblePositionManager.json";
+import IRamsesPositionManager from "../../abi/IRamsesNonfungiblePositionManager.json";
 import IArrakisV1RouterStaking from "../../abi/IArrakisV1RouterStaking.json";
 import { getDeadline } from "../../utils/deadline";
 import BigNumber from "bignumber.js";
@@ -70,7 +71,7 @@ export function tryParseTick(
 }
 
 export async function getUniswapV3MintTxData(
-  dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL | Dapp.AERODROMECL,
+  dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL | Dapp.AERODROMECL | Dapp.RAMSESCL,
   pool: Pool,
   assetA: string,
   assetB: string,
@@ -154,6 +155,13 @@ export async function getUniswapV3MintTxData(
     mintParams.push(0);
   }
 
+  if (dapp === Dapp.RAMSESCL) {
+    iNonfungiblePositionManager = new ethers.utils.Interface(
+      IRamsesPositionManager
+    );
+    mintParams.push(0);
+  }
+
   return iNonfungiblePositionManager.encodeFunctionData(Transaction.MINT, [
     mintParams
   ]);
@@ -162,7 +170,7 @@ export async function getUniswapV3MintTxData(
 }
 
 export async function getUniswapV3Liquidity(
-  dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL | Dapp.AERODROMECL,
+  dapp: Dapp.UNISWAPV3 | Dapp.VELODROMECL | Dapp.AERODROMECL | Dapp.RAMSESCL,
   tokenId: string,
   pool: Pool
 ): Promise<BigNumber> {
@@ -187,7 +195,8 @@ export async function getIncreaseLiquidityTxData(
   if (
     dapp === Dapp.UNISWAPV3 ||
     dapp === Dapp.VELODROMECL ||
-    dapp === Dapp.AERODROMECL
+    dapp === Dapp.AERODROMECL ||
+    dapp === Dapp.RAMSESCL
   ) {
     const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
     txData = abi.encodeFunctionData(Transaction.INCREASE_LIQUIDITY, [
@@ -221,7 +230,8 @@ export async function getDecreaseLiquidityTxData(
   if (
     dapp === Dapp.UNISWAPV3 ||
     dapp === Dapp.VELODROMECL ||
-    dapp === Dapp.AERODROMECL
+    dapp === Dapp.AERODROMECL ||
+    dapp === Dapp.RAMSESCL
   ) {
     const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
     const liquidity = (await getUniswapV3Liquidity(dapp, tokenId, pool))

package/src/test/constants.ts

@@ -41,7 +41,7 @@ export const KWENTA_ETH_PERP_V2 = "0x2b3bb4c683bfc5239b029131eef3b1d214478d93";
 export const TEST_POOL = {
   [Network.POLYGON]: "0x699fd4d6eadb216704c7e355cfa0a12f51813163",
   [Network.OPTIMISM]: "0x12573bfdf764ab9d52aca20e2827497a66829716",
-  [Network.ARBITRUM]: "0x2dc2f936c8b6619facc69355d65dd93d2f4cc2bd",
+  [Network.ARBITRUM]: "0x0b5f6591c8eb23e5a68102d3d39ebbb464ee5c14",
   [Network.BASE]: "0x4842b42F68524383F609aa46eAfc18c1459cE3cD"
 };
 
@@ -49,6 +49,7 @@ export const CONTRACT_ADDRESS = {
   [Network.POLYGON]: {
     USDC: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
     USDT: "",
+    SUSD: "",
     SWETH: "",
     WETH: "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619",
     WBTC: "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6",
@@ -60,7 +61,8 @@ export const CONTRACT_ADDRESS = {
     },
     VELODROME_CL_USDC_WETH_GAUGE: "",
     VELO: "",
-    COMPOUNDV3_WETH: ""
+    COMPOUNDV3_WETH: "",
+    TOROS: ""
   },
 
   [Network.OPTIMISM]: {
@@ -81,11 +83,13 @@ export const CONTRACT_ADDRESS = {
     ARRAKIS_USDC_WETH_LP: "",
     VELODROME_CL_USDC_WETH_GAUGE: "0xa75127121d28a9BF848F3B70e7Eea26570aa7700",
     VELO: "0x9560e827aF36c94D2Ac33a39bCE1Fe78631088Db",
-    COMPOUNDV3_WETH: ""
+    COMPOUNDV3_WETH: "",
+    TOROS: "0x49bf093277bf4dde49c48c6aa55a3bda3eedef68" //USDmny
   },
   [Network.ARBITRUM]: {
     USDC: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
     USDT: "",
+    SUSD: "",
     SWETH: "0xbc011A12Da28e8F0f528d9eE5E7039E22F91cf18",
     WETH: "0x82af49447d8a07e3bd95bd0d56f35241523fbab1",
     WBTC: "0x2f2a2543b76a4166549f7aab2e75bef0aefc5b0f",
@@ -103,11 +107,13 @@ export const CONTRACT_ADDRESS = {
     WMATIC: "",
     VELODROME_CL_USDC_WETH_GAUGE: "",
     VELO: "",
-    COMPOUNDV3_WETH: "0x6f7D514bbD4aFf3BcD1140B7344b32f063dEe486"
+    COMPOUNDV3_WETH: "0x6f7D514bbD4aFf3BcD1140B7344b32f063dEe486",
+    TOROS: ""
   },
   [Network.BASE]: {
     USDC: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
     USDT: "0xfde4c96c8593536e31f229ea8f37b2ada2699bb2",
+    SUSD: "",
     WETH: "0x4200000000000000000000000000000000000006",
     WBTC: "",
     SWETH: "",
@@ -120,7 +126,8 @@ export const CONTRACT_ADDRESS = {
     WMATIC: "",
     VELODROME_CL_USDC_WETH_GAUGE: "0xF33a96b5932D9E9B9A0eDA447AbD8C9d48d2e0c8",
     VELO: "0x940181a94A35A4569E4529A3CDfB74e38FD98631",
-    COMPOUNDV3_WETH: ""
+    COMPOUNDV3_WETH: "",
+    TOROS: ""
   }
 };
 

package/src/test/ramsesCL.test.ts

@@ -0,0 +1,155 @@
+import { Dhedge, Pool, ethers } from "..";
+
+import { nonfungiblePositionManagerAddress } from "../config";
+import { AssetEnabled, Dapp, Network } from "../types";
+import { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import {
+  TestingRunParams,
+  beforeAfterReset,
+  setChainlinkTimeout,
+  testingHelper
+} from "./utils/testingHelper";
+import { allowanceDelta, balanceDelta } from "./utils/token";
+import INonfungiblePositionManager from "../abi/INonfungiblePositionManager.json";
+
+const testRamsesCL = ({ wallet, network, provider }: TestingRunParams) => {
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const RAMSES_POSITION_MANGER = nonfungiblePositionManagerAddress[network][
+    Dapp.RAMSESCL
+  ]!;
+
+  const USDC = CONTRACT_ADDRESS[network].USDC;
+  const WETH = CONTRACT_ADDRESS[network].WETH;
+  //if other chains then define per network
+  const RAM = "0xaaa6c1e32c55a7bfa8066a6fae9b42650f262418";
+  const ARB = "0x912ce59144191c1204e64559fe8253a0e49e6548";
+
+  let dhedge: Dhedge;
+  let pool: Pool;
+  let ramsesPositionManager: ethers.Contract;
+  let tokenId: string;
+  jest.setTimeout(100000);
+
+  describe(`[${network}] Ramses CL  tests`, () => {
+    beforeAll(async () => {
+      // top up ETH (gas)
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x100000000000000"
+      ]);
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+
+      // setChainlinkTimeout
+      await setChainlinkTimeout({ pool, provider }, 86400 * 365);
+
+      const newAssets: AssetEnabled[] = [
+        { asset: USDC, isDeposit: true },
+        { asset: WETH, isDeposit: true },
+        {
+          asset: RAMSES_POSITION_MANGER,
+          isDeposit: false
+        },
+        {
+          asset: ARB,
+          isDeposit: false
+        }
+      ];
+      await pool.changeAssets(newAssets);
+      await pool.approve(Dapp.ONEINCH, USDC, MAX_AMOUNT);
+      await pool.trade(Dapp.ONEINCH, USDC, WETH, (2.5 * 1e6).toString());
+
+      ramsesPositionManager = new ethers.Contract(
+        RAMSES_POSITION_MANGER,
+        INonfungiblePositionManager.abi,
+        pool.signer
+      );
+    });
+
+    beforeAfterReset({ beforeAll, afterAll, provider });
+
+    describe("Liquidity", () => {
+      it("approves unlimited USDC and WETH on for Velodrome CL", async () => {
+        await pool.approveSpender(RAMSES_POSITION_MANGER, USDC, MAX_AMOUNT);
+        await pool.approveSpender(RAMSES_POSITION_MANGER, WETH, MAX_AMOUNT);
+        const UsdcAllowanceDelta = await allowanceDelta(
+          pool.address,
+          USDC,
+          RAMSES_POSITION_MANGER,
+          pool.signer
+        );
+        await expect(UsdcAllowanceDelta.gt(0));
+      });
+
+      it("adds USDC and WETH to a Velodrome CL (mint position)", async () => {
+        const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+        const wethBalance = await pool.utils.getBalance(WETH, pool.address);
+        await pool.addLiquidityUniswapV3(
+          Dapp.RAMSESCL,
+          WETH,
+          USDC,
+          usdcBalance.div(2),
+          wethBalance.div(2),
+          null,
+          null,
+          -204460,
+          -193470,
+          500
+        );
+
+        tokenId = (
+          await ramsesPositionManager.tokenOfOwnerByIndex(pool.address, 0)
+        ).toString();
+        expect(tokenId).not.toBe(null);
+      });
+
+      it("increases liquidity in a CL position", async () => {
+        const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+        const wethBalance = await pool.utils.getBalance(WETH, pool.address);
+        const positionBefore = await ramsesPositionManager.positions(tokenId);
+        await pool.increaseLiquidity(
+          Dapp.RAMSESCL,
+          tokenId,
+          usdcBalance.div(2),
+          wethBalance.div(2)
+        );
+        const positionAfter = await ramsesPositionManager.positions(tokenId);
+        expect(positionAfter.liquidity.gt(positionBefore.liquidity));
+      });
+
+      it("decreases liquidity from a CL position", async () => {
+        const positionBefore = await ramsesPositionManager.positions(tokenId);
+        await pool.decreaseLiquidity(Dapp.RAMSESCL, tokenId, 50);
+        const positionAfter = await ramsesPositionManager.positions(tokenId);
+        expect(positionAfter.liquidity.lt(positionBefore.liquidity));
+      });
+
+      it("collects fess of a CL position", async () => {
+        await provider.send("evm_increaseTime", [24 * 3600 * 3]); // 1 day
+        await provider.send("evm_mine", []);
+        await pool.claimFees(Dapp.RAMSESCL, tokenId);
+        expect((await balanceDelta(pool.address, USDC, pool.signer)).gt(0));
+      });
+
+      it("get rewards of a CL position", async () => {
+        await provider.send("evm_increaseTime", [24 * 3600 * 3]); // 1 day
+        await provider.send("evm_mine", []);
+        await pool.getRewards(Dapp.RAMSESCL, tokenId, [RAM]);
+        expect((await balanceDelta(pool.address, RAM, pool.signer)).gt(0));
+      });
+
+      it("decreases 100% liquidity and burns a CL position", async () => {
+        await pool.decreaseLiquidity(Dapp.RAMSESCL, tokenId, 100);
+        const positionAfter = await ramsesPositionManager.balanceOf(
+          pool.address
+        );
+        expect(positionAfter.eq(0));
+      });
+    });
+  });
+};
+
+testingHelper({
+  network: Network.ARBITRUM,
+  testingRun: testRamsesCL
+});

package/src/test/toros.test.ts

@@ -1,69 +1,97 @@
 /* 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 { CONTRACT_ADDRESS, MAX_AMOUNT, TEST_POOL } from "./constants";
+import {
+  TestingRunParams,
+  setChainlinkTimeout,
+  setUSDCAmount,
+  testingHelper
+} from "./utils/testingHelper";
 import { allowanceDelta, balanceDelta } from "./utils/token";
+import BigNumber from "bignumber.js";
 
-import { wallet } from "./wallet";
-
-const ETHy = "0xb2cfb909e8657c0ec44d3dd898c1053b87804755";
-const network = Network.OPTIMISM;
-const SUSD = CONTRACT_ADDRESS[network].SUSD;
+const testToros = ({ wallet, network, provider }: TestingRunParams) => {
+  const USDC = CONTRACT_ADDRESS[network].USDC;
+  const TOROS = CONTRACT_ADDRESS[network].TOROS;
 
-let dhedge: Dhedge;
-let pool: Pool;
-jest.setTimeout(100000);
+  let dhedge: Dhedge;
+  let pool: Pool;
+  jest.setTimeout(100000);
 
-describe("pool", () => {
-  beforeAll(async () => {
-    dhedge = new Dhedge(wallet, network);
-    pool = await dhedge.loadPool(TEST_POOL[network]);
-  });
+  describe(`pool on ${network}`, () => {
+    beforeAll(async () => {
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+      await setChainlinkTimeout({ pool, provider }, 86400 * 365);
+      // top up gas
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x10000000000000000"
+      ]);
+      await provider.send("evm_mine", []);
+      // top up USDC
+      const amount = new BigNumber(1000).times(1e6).toFixed(0);
+      await setUSDCAmount({
+        amount,
+        userAddress: pool.address,
+        network,
+        provider
+      });
+    });
 
-  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("approves unlimited USDC on Toros", async () => {
+      await pool.approve(Dapp.TOROS, USDC, MAX_AMOUNT);
+      const usdcAllowanceDelta = await allowanceDelta(
+        pool.address,
+        USDC,
+        routerAddress[network].toros!,
+        pool.signer
+      );
+      await expect(usdcAllowanceDelta.gt(0));
+    });
 
-  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("trades USDC balance into Toros Token", async () => {
+      const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+      await pool.trade(Dapp.TOROS, USDC, TOROS, usdcBalance, 1);
+      const torosBalanceDelta = await balanceDelta(
+        pool.address,
+        TOROS,
+        pool.signer
+      );
+      expect(torosBalanceDelta.gt(0));
+    });
 
-  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("init Toros Token for withdrawal", async () => {
+      await provider.send("evm_increaseTime", [86400]);
+      await provider.send("evm_mine", []);
+      const torosBalance = await pool.utils.getBalance(TOROS, pool.address);
+      await pool.approve(Dapp.TOROS, TOROS, MAX_AMOUNT);
+      await pool.trade(Dapp.TOROS, TOROS, USDC, torosBalance, 1);
+      const torosBalanceDelta = await balanceDelta(
+        pool.address,
+        TOROS,
+        pool.signer
+      );
+      expect(torosBalanceDelta.lt(0));
+    });
 
-  it("buys ETHy for 3 sUSD", async () => {
-    await pool.trade(Dapp.TOROS, SUSD, ETHy, (3 * 10e18).toString(), 3, {
-      gasLimit: "3000000"
+    it("complete withdrawal from Toros asset", async () => {
+      await pool.completeTorosWithdrawal(USDC, 1);
+      const usdcBalanceDelta = await balanceDelta(
+        pool.address,
+        USDC,
+        pool.signer
+      );
+      expect(usdcBalanceDelta.gt(0));
     });
-    const ETHyBalanceDelta = await balanceDelta(
-      pool.address,
-      ETHy,
-      pool.signer
-    );
-    expect(ETHyBalanceDelta.gt(0));
   });
+};
+
+testingHelper({
+  network: Network.OPTIMISM,
+  testingRun: testToros
 });

package/src/test/utils/testingHelper.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { BigNumber, Contract, ethers } from "ethers";
 import { Network } from "../../types";
 import { getWalletData } from "../wallet";
@@ -34,8 +35,8 @@ export const beforeAfterReset = ({
   afterAll,
   provider
 }: {
-  beforeAll: jest.Lifecycle;
-  afterAll: jest.Lifecycle;
+  beforeAll: any;
+  afterAll: any;
   provider: ethers.providers.JsonRpcProvider;
 }): void => {
   let snapshot = "";

package/src/types.ts

@@ -26,7 +26,8 @@ export enum Dapp {
   ZEROEX = "0x",
   RAMSES = "ramses",
   AERODROME = "aerodrome",
-  AERODROMECL = "aerodromeCL"
+  AERODROMECL = "aerodromeCL",
+  RAMSESCL = "ramsesCL"
 }
 
 export enum Transaction {