@dhedge/v2-sdk 1.9.2 → 1.9.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dhedge/v2-sdk",
-  "version": "1.9.2",
+  "version": "1.9.4",
   "license": "MIT",
   "description": "🛠 An SDK for building applications on top of dHEDGE V2",
   "main": "dist/index.js",

package/src/abi/IXRam.json

@@ -0,0 +1,99 @@
+{ "abi": [
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "_amount",
+				"type": "uint256"
+			}
+		],
+		"name": "createVest",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "_vestID",
+				"type": "uint256"
+			},
+			{
+				"internalType": "bool",
+				"name": "_ve",
+				"type": "bool"
+			}
+		],
+		"name": "exitVest",
+		"outputs": [
+			{
+				"internalType": "bool",
+				"name": "",
+				"type": "bool"
+			}
+		],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "address",
+				"name": "_user",
+				"type": "address"
+			}
+		],
+		"name": "usersTotalVests",
+		"outputs": [
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "address",
+				"name": "user",
+				"type": "address"
+			}
+		],
+		"name": "vestInfo",
+		"outputs": [
+			{
+				"components": [
+					{
+						"internalType": "uint256",
+						"name": "amount",
+						"type": "uint256"
+					},
+					{
+						"internalType": "uint256",
+						"name": "start",
+						"type": "uint256"
+					},
+					{
+						"internalType": "uint256",
+						"name": "maxEnd",
+						"type": "uint256"
+					},
+					{
+						"internalType": "uint256",
+						"name": "vestID",
+						"type": "uint256"
+					}
+				],
+				"internalType": "struct IXRam.VestPosition[]",
+				"name": "",
+				"type": "tuple[]"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	}
+]}

package/src/config.ts

@@ -48,7 +48,8 @@ export const routerAddress: AddressDappNetworkMap = {
     [Dapp.ONEINCH]: "0x1111111254EEB25477B68fb85Ed929f73A960582",
     [Dapp.UNISWAPV3]: "0xe592427a0aece92de3edee1f18e0157c05861564",
     [Dapp.AAVEV3]: "0x794a61358D6845594F94dc1DB02A252b5b4814aD",
-    [Dapp.BALANCER]: "0xBA12222222228d8Ba445958a75a0704d566BF2C8"
+    [Dapp.BALANCER]: "0xBA12222222228d8Ba445958a75a0704d566BF2C8",
+    [Dapp.RAMSES]: "0xaaa87963efeb6f7e0a2711f397663105acb1805e"
   }
 };
 

package/src/entities/pool.ts

@@ -59,6 +59,10 @@ import {
 import { getFuturesCancelOrderTxData } from "../services/futures/trade";
 import { getZeroExTradeTxData } from "../services/zeroEx/zeroExTrade";
 import { getOneInchSwapTxData } from "../services/oneInch";
+import {
+  getCreateVestTxData,
+  getExitVestTxData
+} from "../services/ramses/vesting";
 
 export class Pool {
   public readonly poolLogic: Contract;
@@ -486,6 +490,7 @@ export class Pool {
         ]);
         break;
       case Dapp.VELODROME:
+      case Dapp.RAMSES:
         stakeTxData = getVelodromeStakeTxData(amount, false);
         break;
       case Dapp.VELODROMEV2:
@@ -1056,6 +1061,7 @@ export class Pool {
         txData = abi.encodeFunctionData("claim_rewards()", []);
         break;
       case Dapp.VELODROME:
+      case Dapp.RAMSES:
         contractAddress = tokenId;
         txData = getVelodromeClaimTxData(this, tokenId, false);
         break;
@@ -1235,6 +1241,73 @@ export class Pool {
     return tx;
   }
 
+  /**
+   * Add liquidity to Velodrome V2 or Ramses pool
+   * @param {Dapp} dapp VelodromeV2 or Ramses
+   * @param {string} assetA First asset
+   * @param {string} assetB Second asset
+   * @param {BigNumber | string} amountA Amount first asset
+   * @param {BigNumber | string} amountB Amount second asset
+   * @param { boolean } isStable Is stable pool
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async addLiquidityV2(
+    dapp: Dapp.VELODROMEV2 | Dapp.RAMSES,
+    assetA: string,
+    assetB: string,
+    amountA: BigNumber | string,
+    amountB: BigNumber | string,
+    isStable: boolean,
+    options: any = null
+  ): Promise<any> {
+    const tx = await this.poolLogic.execTransaction(
+      routerAddress[this.network][dapp],
+      await getVelodromeAddLiquidityTxData(
+        this,
+        assetA,
+        assetB,
+        amountA,
+        amountB,
+        isStable
+      ),
+      options
+    );
+    return tx;
+  }
+
+  /**
+   * Remove liquidity from Velodrome V2 or Ramses pool
+   * @param {Dapp} dapp VelodromeV2 or Ramses
+   * @param {string} assetA First asset
+   * @param {string} assetB Second asset
+   * @param {BigNumber | string} amount Amount of LP tokens
+   * @param { boolean } isStable Is stable pool
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async removeLiquidityV2(
+    dapp: Dapp.VELODROMEV2 | Dapp.RAMSES,
+    assetA: string,
+    assetB: string,
+    amount: BigNumber | string,
+    isStable: boolean,
+    options: any = null
+  ): Promise<any> {
+    const tx = await this.poolLogic.execTransaction(
+      routerAddress[this.network][dapp],
+      await getVelodromeRemoveLiquidityTxData(
+        this,
+        assetA,
+        assetB,
+        amount,
+        isStable
+      ),
+      options
+    );
+    return tx;
+  }
+
   /**
    * Trade options on lyra
    * @param {LyraOptionMarket} market Underlying market e.g. eth
@@ -1341,4 +1414,65 @@ export class Pool {
     const tx = await this.poolLogic.execTransaction(market, txData, options);
     return tx;
   }
+
+  /**
+   * mintManagerFee
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async mintManagerFee(options: any = null): Promise<any> {
+    const tx = await this.poolLogic.mintManagerFee(options);
+    return tx;
+  }
+
+  /**
+   * getAvailableManagerFee
+   * @returns {Promise<BigNumber>} fee
+   */
+  async getAvailableManagerFee(): Promise<BigNumber> {
+    const fee = await this.poolLogic.availableManagerFee();
+    return BigNumber.from(fee);
+  }
+
+  /** Vest tokens (e.g. Ramses xoRAM)
+   *
+   * @param {string} tokenAddress Address of the token to vest
+   * @param {BigNumber | string } changeAmount Negative for short, positive for long
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async vestTokens(
+    tokenAddress: string,
+    amount: BigNumber | string,
+    options: any = null
+  ): Promise<any> {
+    const txData = await getCreateVestTxData(amount);
+    const tx = await this.poolLogic.execTransaction(
+      tokenAddress,
+      txData,
+      options
+    );
+    return tx;
+  }
+
+  /** Exit position of vested tokens (e.g. Ramses xoRAM)
+   *
+   * @param {string} tokenAddress Address of the token to vest
+   * @param {number } id position Id of the vested tokens
+   * @param {any} options Transaction options
+   * @returns {Promise<any>} Transaction
+   */
+  async exitVestedToken(
+    tokenAddress: string,
+    id: number,
+    options: any = null
+  ): Promise<any> {
+    const txData = await getExitVestTxData(id);
+    const tx = await this.poolLogic.execTransaction(
+      tokenAddress,
+      txData,
+      options
+    );
+    return tx;
+  }
 }

package/src/services/ramses/vesting.ts

@@ -0,0 +1,13 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { BigNumber, ethers } from "ethers";
+import IXRam from "../../abi/IXRam.json";
+
+const iXRam = new ethers.utils.Interface(IXRam.abi);
+
+export function getCreateVestTxData(amount: BigNumber | string): string {
+  return iXRam.encodeFunctionData("createVest", [amount]);
+}
+
+export function getExitVestTxData(vestId: number): string {
+  return iXRam.encodeFunctionData("exitVest", [vestId, false]);
+}

package/src/test/constants.ts

@@ -47,6 +47,7 @@ export const TEST_POOL = {
 export const CONTRACT_ADDRESS = {
   [Network.POLYGON]: {
     USDC: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
+    SWETH: "",
     WETH: "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619",
     WBTC: "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6",
     ARRAKIS_USDC_WETH_GAUGE: "0x33d1ad9Cd88A509397CD924C2d7613C285602C20",
@@ -55,11 +56,14 @@ export const CONTRACT_ADDRESS = {
   [Network.OPTIMISM]: {
     USDC: "0x7F5c764cBc14f9669B88837ca1490cCa17c31607",
     SUSD: "0x8c6f28f2f1a3c87f0f938b96d27520d9751ec8d9",
+    SWETH: "",
     WETH: "0x4200000000000000000000000000000000000006",
+    WBTC: "0x68f180fcCe6836688e9084f035309E29Bf0A2095",
     KWENTA_ETH_PERP_V2: "0x2b3bb4c683bfc5239b029131eef3b1d214478d93"
   },
   [Network.ARBITRUM]: {
-    USDC: "0xff970a61a04b1ca14834a43f5de4533ebddb5cc8",
+    USDC: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    SWETH: "0xbc011A12Da28e8F0f528d9eE5E7039E22F91cf18",
     WETH: "0x82af49447d8a07e3bd95bd0d56f35241523fbab1",
     WBTC: "0x2f2a2543b76a4166549f7aab2e75bef0aefc5b0f",
     WSTETH: "0x5979d7b546e38e414f7e9822514be443a4800529",

package/src/test/pool.test.ts

@@ -1,60 +1,104 @@
+import { BigNumber } from "ethers";
 import { Dhedge, ethers, Pool } from "..";
 import { AssetEnabled, Network } from "../types";
 import { CONTRACT_ADDRESS, TEST_POOL } from "./constants";
+
+import {
+  beforeAfterReset,
+  testingHelper,
+  TestingRunParams
+} from "./utils/testingHelper";
 import { allowanceDelta, balanceDelta } from "./utils/token";
-import { wallet } from "./wallet";
 
-let dhedge: Dhedge;
-let pool: Pool;
+const testPool = ({ wallet, network, provider }: TestingRunParams) => {
+  let dhedge: Dhedge;
+  let pool: Pool;
 
-jest.setTimeout(100000);
+  jest.setTimeout(200000);
 
-const network = Network.POLYGON;
+  describe(`pool on ${network}`, () => {
+    beforeAll(async () => {
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+    });
+    beforeAfterReset({ beforeAll, afterAll, provider });
 
-describe("pool", () => {
-  beforeAll(async () => {
-    dhedge = new Dhedge(wallet, network);
-    pool = await dhedge.loadPool(TEST_POOL[network]);
-  });
+    it("checks fund composition", async () => {
+      const result = await pool.getComposition();
+      expect(result.length).toBeGreaterThan(0);
+    });
 
-  it("checks fund composition", async () => {
-    const result = await pool.getComposition();
-    expect(result.length).toBeGreaterThan(0);
-  });
+    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("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("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("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("adds WBTC to enabled assets", async () => {
+      const assetsBefore = await pool.getComposition();
 
-  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);
+      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();
+      if (assetsBefore.length < newAssets.length) {
+        expect(assetsAfter.length).toBeGreaterThan(assetsBefore.length);
+      } else {
+        expect(assetsAfter.length).toBeLessThanOrEqual(assetsBefore.length);
+      }
+    });
+
+    it("get available Manager Fee", async () => {
+      const result = await pool.getAvailableManagerFee();
+      expect(result).toBeInstanceOf(BigNumber);
+    });
+
+    it("mintManagerFee; should not revert", async () => {
+      const tx = await pool.mintManagerFee();
+      expect(tx).toHaveProperty("wait");
+    });
+
+    it("withdraw 0.1 pool token into Pool", async () => {
+      await provider.send("evm_increaseTime", [24 * 60 * 60]);
+      await provider.send("evm_mine", []);
+      await pool.withdraw((0.1 * 1e18).toString());
+      const poolTokenDelta = await balanceDelta(
+        pool.signer.address,
+        pool.address,
+        pool.signer
+      );
+      expect(poolTokenDelta.lt(0));
+    });
   });
+};
+
+testingHelper({
+  network: Network.POLYGON,
+  testingRun: testPool
 });
+
+// testingHelper({
+//   network: Network.OPTIMISM,
+//   testingRun: testPool
+// });

package/src/test/ramses.test.ts

@@ -0,0 +1,190 @@
+/* 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,
+  beforeAfterReset,
+  testingHelper
+} from "./utils/testingHelper";
+import { allowanceDelta, balanceDelta } from "./utils/token";
+import { getWalletData } from "./wallet";
+
+const testRamses = ({ network, provider }: TestingRunParams) => {
+  const USDC_swETH_Lp = "0xf1a5444a7ed5f24962a118512b076a015b0e6c0b";
+  const USDC_swETH_Gauge = "0x9765cdaec6395b04737edc22c5b3e7d85677328a";
+  const RAM = "0xaaa6c1e32c55a7bfa8066a6fae9b42650f262418";
+  const xoRAM = "0xaaa1ee8dc1864ae49185c368e8c64dd780a50fb7";
+
+  const USDC = CONTRACT_ADDRESS[network].USDC;
+  const SWETH = CONTRACT_ADDRESS[network].SWETH;
+
+  let dhedge: Dhedge;
+  let pool: Pool;
+  jest.setTimeout(100000);
+
+  describe(`[${network}] ramses tests`, () => {
+    beforeAll(async () => {
+      const { wallet } = getWalletData(network);
+      // top up ETH (gas)
+      await provider.send("hardhat_setBalance", [
+        wallet.address,
+        "0x100000000000000"
+      ]);
+      dhedge = new Dhedge(wallet, network);
+      pool = await dhedge.loadPool(TEST_POOL[network]);
+      await pool.trade(Dapp.ONEINCH, USDC, SWETH, (5 * 1e6).toString());
+    });
+    beforeAfterReset({ beforeAll, afterAll, provider });
+
+    it("approves unlimited USDC and swETH on for Ramses", async () => {
+      await pool.approve(Dapp.RAMSES, USDC, MAX_AMOUNT);
+      await pool.approve(Dapp.RAMSES, SWETH, MAX_AMOUNT);
+      const UsdcAllowanceDelta = await allowanceDelta(
+        pool.address,
+        USDC,
+        routerAddress[network].ramses!,
+        pool.signer
+      );
+      await expect(UsdcAllowanceDelta.gt(0));
+    });
+
+    it("adds USDC and swETH to a Ramses volatile pool", async () => {
+      const usdcBalance = await pool.utils.getBalance(USDC, pool.address);
+      const swethBalance = await pool.utils.getBalance(SWETH, pool.address);
+      await pool.addLiquidityV2(
+        Dapp.RAMSES,
+        USDC,
+        SWETH,
+        usdcBalance,
+        swethBalance,
+        false
+      );
+
+      const lpTokenDelta = await balanceDelta(
+        pool.address,
+        USDC_swETH_Lp,
+        pool.signer
+      );
+      expect(lpTokenDelta.gt(0));
+    });
+
+    it("should stake USDC-swETH LP in a gauge", async () => {
+      const balance = await dhedge.utils.getBalance(
+        USDC_swETH_Lp,
+        pool.address
+      );
+      await pool.approveSpender(USDC_swETH_Gauge, USDC_swETH_Lp, MAX_AMOUNT);
+      await pool.stakeInGauge(Dapp.RAMSES, USDC_swETH_Gauge, balance);
+      const gaugeBalance = await balanceDelta(
+        pool.address,
+        USDC_swETH_Gauge,
+        pool.signer
+      );
+      expect(gaugeBalance.gt(0));
+    });
+
+    it("should claim rewards from Gauge", async () => {
+      await provider.send("evm_increaseTime", [24 * 60 * 60]); // 1 day
+      await provider.send("evm_mine", []);
+      const claimTx = await pool.claimFees(Dapp.RAMSES, USDC_swETH_Gauge);
+      expect(claimTx).not.toBe(null);
+      const ramBalanceDelta = await balanceDelta(
+        pool.address,
+        RAM,
+        pool.signer
+      );
+      const xoRamBalanceDelta = await balanceDelta(
+        pool.address,
+        xoRAM,
+        pool.signer
+      );
+      expect(ramBalanceDelta.gt(0));
+      expect(xoRamBalanceDelta.gt(0));
+    });
+
+    it("createVest for xoRAM", async () => {
+      const xoRAMBalanceBefore = await dhedge.utils.getBalance(
+        xoRAM,
+        pool.address
+      );
+      expect(xoRAMBalanceBefore.gt(0));
+      const vestTx = await pool.vestTokens(xoRAM, xoRAMBalanceBefore);
+      expect(vestTx).not.toBe(null);
+      const xoRAMBalanceAfter = await dhedge.utils.getBalance(
+        xoRAM,
+        pool.address
+      );
+      expect(xoRAMBalanceAfter.eq(0));
+    });
+
+    it("exitVest for xoRAM", async () => {
+      await provider.send("evm_increaseTime", [3600 * 24 * 90]); // 90 days
+      await provider.send("evm_mine", []);
+
+      const ramBalanceBefore = await dhedge.utils.getBalance(RAM, pool.address);
+
+      const exitvestTx = await pool.exitVestedToken(xoRAM, 0);
+      const xoRAMBalanceAfter = await dhedge.utils.getBalance(
+        USDC_swETH_Gauge,
+        pool.address
+      );
+      expect(exitvestTx).not.toBe(null);
+      const ramBalanceAfter = await dhedge.utils.getBalance(RAM, pool.address);
+      expect(xoRAMBalanceAfter.eq(0));
+      expect(ramBalanceAfter.gt(ramBalanceBefore));
+    });
+
+    it("should unStake USDC-swETH LP from a gauge", async () => {
+      const gaugeBalance = await dhedge.utils.getBalance(
+        USDC_swETH_Gauge,
+        pool.address
+      );
+      await pool.unstakeFromGauge(USDC_swETH_Gauge, gaugeBalance);
+      const lpTokenDelta = await balanceDelta(
+        pool.address,
+        USDC_swETH_Lp,
+        pool.signer
+      );
+      expect(lpTokenDelta.gt(0));
+    });
+
+    it("approves unlimited USDC/swETH LP for Ramses", async () => {
+      await pool.approve(Dapp.RAMSES, USDC_swETH_Lp, MAX_AMOUNT);
+      const lpAllowanceDelta = await allowanceDelta(
+        pool.address,
+        USDC_swETH_Lp,
+        routerAddress[network].ramses!,
+        pool.signer
+      );
+      expect(lpAllowanceDelta.gt(0));
+    });
+
+    it("should remove all liquidity from an existing pool ", async () => {
+      const balance = await dhedge.utils.getBalance(
+        USDC_swETH_Lp,
+        pool.address
+      );
+      await pool.removeLiquidityV2(Dapp.RAMSES, USDC, SWETH, balance, false);
+      const usdcBalanceDelta = await balanceDelta(
+        pool.address,
+        USDC,
+        pool.signer
+      );
+      const swETHBalanceDelta = await balanceDelta(
+        pool.address,
+        SWETH,
+        pool.signer
+      );
+      expect(usdcBalanceDelta.gt(0));
+      expect(swETHBalanceDelta.gt(0));
+    });
+  });
+};
+
+testingHelper({
+  network: Network.ARBITRUM,
+  testingRun: testRamses
+});