@dhedge/v2-sdk 1.3.0 → 1.4.0

package/package.json

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

package/src/abi/IArrakisV1RouterStaking.json

@@ -0,0 +1,107 @@
+{
+  "abi": [
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "gauge",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount0Max",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount1Max",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount0Min",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount1Min",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "receiver",
+          "type": "address"
+        }
+      ],
+      "name": "addLiquidityAndStake",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amount0",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount1",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "mintAmount",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "gauge",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "burnAmount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount0Min",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount1Min",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "receiver",
+          "type": "address"
+        }
+      ],
+      "name": "removeLiquidityAndUnstake",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "amount0",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount1",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint128",
+          "name": "liquidityBurned",
+          "type": "uint128"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    }
+  ]
+}

package/src/abi/ILiquidityGaugeV4.json

@@ -0,0 +1,153 @@
+{ "abi": [
+	{
+		"inputs": [
+			{
+				"internalType": "address",
+				"name": "user",
+				"type": "address"
+			}
+		],
+		"name": "claim_rewards",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "address",
+				"name": "user",
+				"type": "address"
+			},
+			{
+				"internalType": "address",
+				"name": "receiver",
+				"type": "address"
+			}
+		],
+		"name": "claim_rewards",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"name": "claim_rewards",
+		"outputs": [],
+		"stateMutability": "nonpayable",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "address",
+				"name": "user",
+				"type": "address"
+			},
+			{
+				"internalType": "address",
+				"name": "rewardToken",
+				"type": "address"
+			}
+		],
+		"name": "claimable_reward",
+		"outputs": [
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"name": "reward_count",
+		"outputs": [
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "address",
+				"name": "token",
+				"type": "address"
+			}
+		],
+		"name": "reward_data",
+		"outputs": [
+			{
+				"internalType": "address",
+				"name": "",
+				"type": "address"
+			},
+			{
+				"internalType": "address",
+				"name": "",
+				"type": "address"
+			},
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			},
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			},
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			},
+			{
+				"internalType": "uint256",
+				"name": "",
+				"type": "uint256"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "uint256",
+				"name": "index",
+				"type": "uint256"
+			}
+		],
+		"name": "reward_tokens",
+		"outputs": [
+			{
+				"internalType": "address",
+				"name": "",
+				"type": "address"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	},
+	{
+		"inputs": [],
+		"name": "staking_token",
+		"outputs": [
+			{
+				"internalType": "address",
+				"name": "",
+				"type": "address"
+			}
+		],
+		"stateMutability": "view",
+		"type": "function"
+	}
+]}

package/src/config.ts

@@ -20,14 +20,18 @@ export const routerAddress: AddressDappNetworkMap = {
   [Network.POLYGON]: {
     [Dapp.SUSHISWAP]: "0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506",
     [Dapp.AAVE]: "0x8dFf5E27EA6b7AC08EbFdf9eB090F32ee9a30fcf",
+    [Dapp.AAVEV3]: "0x794a61358D6845594F94dc1DB02A252b5b4814aD",
     [Dapp.ONEINCH]: "0x1111111254fb6c44bac0bed2854e76f90643097d",
     [Dapp.QUICKSWAP]: "0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff",
     [Dapp.BALANCER]: "0xBA12222222228d8Ba445958a75a0704d566BF2C8",
-    [Dapp.UNISWAPV3]: "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"
+    [Dapp.UNISWAPV3]: "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
+    [Dapp.ARRAKIS]: "0xbc91a120cCD8F80b819EAF32F0996daC3Fa76a6C"
   },
   [Network.OPTIMISM]: {
     [Dapp.UNISWAPV3]: "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
-    [Dapp.SYNTHETIX]: "0x8700dAec35aF8Ff88c16BdF0418774CB3D7599B4"
+    [Dapp.SYNTHETIX]: "0x8700dAec35aF8Ff88c16BdF0418774CB3D7599B4",
+    [Dapp.AAVEV3]: "0x794a61358D6845594F94dc1DB02A252b5b4814aD",
+    [Dapp.ONEINCH]: "0x1111111254760F7ab3F16433eea9304126DCd199"
   }
 };
 

package/src/entities/pool.ts

@@ -11,9 +11,12 @@ 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 {
   deadline,
   MaxUint128,
+  networkChainIdMap,
   nonfungiblePositionManagerAddress,
   routerAddress,
   stakingAddress,
@@ -234,7 +237,8 @@ export class Pool {
   ): Promise<any> {
     let swapTxData: string;
     if (dapp === Dapp.ONEINCH) {
-      const apiUrl = `https://api.1inch.exchange/v4.0/137/swap?fromTokenAddress=${assetFrom}&toTokenAddress=${assetTo}&amount=${amountIn.toString()}&fromAddress=${
+      const chainId = networkChainIdMap[this.network];
+      const apiUrl = `https://api.1inch.exchange/v4.0/${chainId}/swap?fromTokenAddress=${assetFrom}&toTokenAddress=${assetTo}&amount=${amountIn.toString()}&fromAddress=${
         this.address
       }&destReceiver=${
         this.address
@@ -770,99 +774,149 @@ export class Pool {
   }
 
   /**
-   * Remove liquidity from an UniswapV3 liquidity pool
+   * Remove liquidity from an UniswapV3 or Arrakis liquidity pool
+   * @param {Dapp} dapp Platform either UniswapV3 or Arrakis
    * @param {string} tokenId Token Id of UniswapV3 position
    * @param {number} amount Amount in percent of assets to be removed
    * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
-  async removeLiquidityUniswapV3(
+  async decreaseLiquidity(
+    dapp: Dapp,
     tokenId: string,
     amount = 100,
     options: any = null
   ): Promise<any> {
-    const iNonfungiblePositionManager = new ethers.utils.Interface(
-      INonfungiblePositionManager.abi
-    );
-    const liquidity = (await getUniswapV3Liquidity(tokenId, this))
-      .mul(amount)
-      .div(100);
-    const decreaseLiquidityTxData = iNonfungiblePositionManager.encodeFunctionData(
-      Transaction.DECREASE_LIQUIDITY,
-      [[tokenId, liquidity, 0, 0, deadline]]
-    );
-    const collectTxData = iNonfungiblePositionManager.encodeFunctionData(
-      Transaction.COLLECT,
-      [[tokenId, this.address, MaxUint128, MaxUint128]]
-    );
+    let txData;
+    let dappAddress;
+    if (dapp === Dapp.UNISWAPV3) {
+      dappAddress = nonfungiblePositionManagerAddress[this.network];
+      const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
+      const liquidity = (await getUniswapV3Liquidity(tokenId, this))
+        .mul(amount)
+        .div(100);
+      const decreaseLiquidityTxData = abi.encodeFunctionData(
+        Transaction.DECREASE_LIQUIDITY,
+        [[tokenId, liquidity, 0, 0, deadline]]
+      );
+      const collectTxData = abi.encodeFunctionData(Transaction.COLLECT, [
+        [tokenId, this.address, MaxUint128, MaxUint128]
+      ]);
 
-    const multicallParams = [decreaseLiquidityTxData, collectTxData];
+      const multicallParams = [decreaseLiquidityTxData, collectTxData];
 
-    if (amount === 100) {
-      const burnTxData = iNonfungiblePositionManager.encodeFunctionData(
-        Transaction.BURN,
-        [tokenId]
-      );
-      multicallParams.push(burnTxData);
+      if (amount === 100) {
+        const burnTxData = abi.encodeFunctionData(Transaction.BURN, [tokenId]);
+        multicallParams.push(burnTxData);
+      }
+      txData = abi.encodeFunctionData(Transaction.MULTI_CALL, [
+        multicallParams
+      ]);
+    } else if (dapp === Dapp.ARRAKIS) {
+      dappAddress = routerAddress[this.network][dapp];
+      const abi = new ethers.utils.Interface(IArrakisV1RouterStaking.abi);
+      const liquidity = (await this.utils.getBalance(tokenId, this.address))
+        .mul(amount)
+        .div(100);
+      txData = abi.encodeFunctionData(Transaction.REMOVE_LIQUIDITY_UNSTAKE, [
+        tokenId,
+        liquidity,
+        0,
+        0,
+        this.address
+      ]);
+    } else {
+      throw new Error("dapp not supported");
     }
-    const multicallTxData = iNonfungiblePositionManager.encodeFunctionData(
-      Transaction.MULTI_CALL,
-      [multicallParams]
-    );
+
     const tx = await this.poolLogic.execTransaction(
-      nonfungiblePositionManagerAddress[this.network],
-      multicallTxData,
+      dappAddress,
+      txData,
       options
     );
     return tx;
   }
 
   /**
-   * Increase liquidity of an UniswapV3 liquidity pool
+   * Increase liquidity of an UniswapV3 or Arrakis liquidity pool
+   * @param {Dapp} dapp Platform either UniswapV3 or Arrakis
    * @param {string} tokenId Token Id of UniswapV3 position
    * @param {BigNumber | string} amountA Amount first asset
    * @param {BigNumber | string} amountB Amount second asset
    * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
-  async increaseLiquidityUniswapV3(
+  async increaseLiquidity(
+    dapp: Dapp,
     tokenId: string,
     amountA: BigNumber | string,
     amountB: BigNumber | string,
     options: any = null
   ): Promise<any> {
-    const iNonfungiblePositionManager = new ethers.utils.Interface(
-      INonfungiblePositionManager.abi
-    );
-    const increaseLiquidityTxData = iNonfungiblePositionManager.encodeFunctionData(
-      Transaction.INCREASE_LIQUIDITY,
-      [[tokenId, amountA, amountB, 0, 0, deadline]]
-    );
+    let txData;
+    let dappAddress;
+    if (dapp === Dapp.UNISWAPV3) {
+      dappAddress = nonfungiblePositionManagerAddress[this.network];
+      const abi = new ethers.utils.Interface(INonfungiblePositionManager.abi);
+      txData = abi.encodeFunctionData(Transaction.INCREASE_LIQUIDITY, [
+        [tokenId, amountA, amountB, 0, 0, deadline]
+      ]);
+    } else if (dapp === Dapp.ARRAKIS) {
+      dappAddress = routerAddress[this.network][dapp];
+      const abi = new ethers.utils.Interface(IArrakisV1RouterStaking.abi);
+      txData = abi.encodeFunctionData(Transaction.ADD_LIQUIDITY_STAKE, [
+        tokenId,
+        amountA,
+        amountB,
+        0,
+        0,
+        this.address
+      ]);
+    } else {
+      throw new Error("dapp not supported");
+    }
+
     const tx = await this.poolLogic.execTransaction(
-      nonfungiblePositionManagerAddress[this.network],
-      increaseLiquidityTxData,
+      dappAddress,
+      txData,
       options
     );
     return tx;
   }
 
   /**
-   * Claim fees of an UniswapV3 liquidity pool
-   * @param {string} tokenId Token Id of UniswapV3 position
+   * Claim fees of an UniswapV3 liquidity or Arrakis pool
+   * @param {Dapp} dapp Platform either UniswapV3 or Arrakis
+   * @param {string} tokenId Token Id of UniswapV3 or Arrakis position
    * @param {any} options Transaction options
    * @returns {Promise<any>} Transaction
    */
-  async claimFeesUniswapV3(tokenId: string, options: any = null): Promise<any> {
-    const iNonfungiblePositionManager = new ethers.utils.Interface(
-      INonfungiblePositionManager.abi
-    );
-    const collectTxData = iNonfungiblePositionManager.encodeFunctionData(
-      Transaction.COLLECT,
-      [[tokenId, this.address, MaxUint128, MaxUint128]]
-    );
+  async claimFees(
+    dapp: Dapp,
+    tokenId: string,
+    options: any = null
+  ): Promise<any> {
+    let txData;
+    let contractAddress;
+    if (dapp === Dapp.UNISWAPV3) {
+      contractAddress = nonfungiblePositionManagerAddress[this.network];
+      const iNonfungiblePositionManager = new ethers.utils.Interface(
+        INonfungiblePositionManager.abi
+      );
+      txData = iNonfungiblePositionManager.encodeFunctionData(
+        Transaction.COLLECT,
+        [[tokenId, this.address, MaxUint128, MaxUint128]]
+      );
+    } else if (dapp === Dapp.ARRAKIS) {
+      contractAddress = tokenId;
+      const abi = new ethers.utils.Interface(ILiquidityGaugeV4.abi);
+      txData = abi.encodeFunctionData("claim_rewards()", []);
+    } else {
+      throw new Error("dapp not supported");
+    }
     const tx = await this.poolLogic.execTransaction(
-      nonfungiblePositionManagerAddress[this.network],
-      collectTxData,
+      contractAddress,
+      txData,
       options
     );
     return tx;

package/src/test/aave.test.ts

@@ -1,6 +1,6 @@
-import { Dhedge, ethers } from "..";
-import { Network } from "../types";
-import { AMUSDC, TEST_POOL, VDEBTWETH } from "./constants";
+import { Dhedge } from "..";
+import { Dapp, Network } from "../types";
+import { TEST_POOL, WETH } from "./constants";
 
 import { wallet } from "./wallet";
 
@@ -8,16 +8,32 @@ let dhedge: Dhedge;
 
 jest.setTimeout(100000);
 
-const options = {
-  gasLimit: 5000000,
-  gasPrice: ethers.utils.parseUnits("100", "gwei")
-};
+// const options = {
+//   gasLimit: 5000000,
+//   gasPrice: ethers.utils.parseUnits("100", "gwei")
+// };
 
 describe("pool", () => {
   beforeAll(() => {
-    dhedge = new Dhedge(wallet, Network.POLYGON);
+    dhedge = new Dhedge(wallet, Network.OPTIMISM);
   });
 
+  // it("approves USDC to Aave", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     result = await pool.approve(
+  //       Dapp.AAVEV3,
+  //       USDC,
+  //       ethers.constants.MaxUint256
+  //     );
+  //     console.log(result);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
+
   // it("withdraws 1 USDC from Aave lending pool", async () => {
   //   let result;
   //   const pool = await dhedge.loadPool(myPool);
@@ -35,11 +51,23 @@ describe("pool", () => {
   //   expect(result).not.toBe(null);
   // });
 
-  // it("borrows 0.0001 WETH from Aave lending pool", async () => {
+  it("borrows 0.001 WETH from Aave lending pool", async () => {
+    let result;
+    const pool = await dhedge.loadPool(TEST_POOL);
+    try {
+      result = await pool.borrow(Dapp.AAVEV3, WETH, "1000000000000000");
+      console.log(result);
+    } catch (e) {
+      console.log(e);
+    }
+    expect(result).not.toBe(null);
+  });
+
+  // it("reapys 1USDC to Aave lending pool", async () => {
   //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
+  //   const pool = await dhedge.loadPool(TEST_POOL);
   //   try {
-  //     result = await pool.borrow(Dapp.AAVE, weth, "100000000000000");
+  //     result = await pool.repay(Dapp.AAVEV3, USDC, "1380000");
   //     console.log(result);
   //   } catch (e) {
   //     console.log(e);
@@ -47,11 +75,11 @@ describe("pool", () => {
   //   expect(result).not.toBe(null);
   // });
 
-  // it("reapys 0.0001 WETH to Aave lending pool", async () => {
+  // it("claims rewards from Aave", async () => {
   //   let result;
-  //   const pool = await dhedge.loadPool(myPool);
+  //   const pool = await dhedge.loadPool(TEST_POOL);
   //   try {
-  //     result = await pool.repay(Dapp.AAVE, weth, "100000000000000", options);
+  //     result = await pool.harvestAaveRewards([AMUSDC, VDEBTWETH], options);
   //     console.log(result);
   //   } catch (e) {
   //     console.log(e);
@@ -59,15 +87,15 @@ describe("pool", () => {
   //   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);
-  });
+  // it("lends USDC to Aave", async () => {
+  //   let result;
+  //   const pool = await dhedge.loadPool(TEST_POOL);
+  //   try {
+  //     const balance = await dhedge.utils.getBalance(WETH, pool.address);
+  //     result = await pool.lend(Dapp.AAVEV3, WETH, balance, 196);
+  //   } catch (e) {
+  //     console.log(e);
+  //   }
+  //   expect(result).not.toBe(null);
+  // });
 });